Go语言入门

package main

import "fmt"

func main(){
	fmt.Println("Hello world")
}

package // 定义包名的关键字
import // 导入包名关键字
const // 常量声明的关键字
var // 变量声明的关键字
func // 函数声明的关键字
defer // 延迟执行的关键字
go // 并发语法糖关键字
return // 函数返回关键字

struct // 定义结构体关键字
interface // 定义接口关键字
map // 声明或创建map类型关键字
chan // 声明或创建chan类型关键字

if else // 分支语句关键字
for range break continue // 循环语句关键字
switch select type case default fallthrough // switch和select语句使用的关键字
goto // 跳转语句

// 数值 16 个
   // 整型 12 个
   byte int int8 int16 int32 int64
   uint uint8 uint16 uint32 uint64 uintptr
   // 浮点型 2 个
   float32 float64
   // 复数型 2 个
   complex64 complex128
// 字符和字符串类型 2 个
   string rune
// 接口型 1 个
   error
// 布尔型 1 个
bool

make new len cap append copy delete panic recover close complex real print println

true false // bool类型的两个常量
iota // 用在连续的枚举类型的声明中
nil // 指针/引用类型变量的默认值

+ - * / %

& | ^ &^ >> <<

:= = += -+ *= /= %= &= |= ^= &^= >>= <<=

> >= < <= == !=

() {} []

&& || !

++ --

: , ; . ... <-

42
0600
0xBadFAce

0.
98.1
1.e+0
1E6

0i
011i
1.e+0i

'a'
'本'
'\t'
'\u12e4'

"Hello World"

var varName dataType [ = value]

varName := value

a, b := 1, "Hello"

// 一组声明
const (
 c0 = iota // 0
 c1 = iota // 1
 c2 = iota // 2
)

// 简写模式
const (
 c0 = iota // 0
 c1        // 1
 c2        // 2
)

// 在一组赋值中, 即使iota不出现, 其值也会增加
const (
  a = 1 << iota // a == 1 iota == 0
  b = 1 << iota // b == 2 iota == 1
  c = 3 // c == 3 iota == 2
  d = 1 << iota // d == 8 iota == 3
)

// 分开的const语句, iota每次都是从0开始
const x = iota // x == 0
const y = iota // y == 0

// 声明方式
var ok bool = false
var ok1 bool
ok1 = true
ok2 := true

// 布尔类型不能够与整型数据进行相互转换
var a bool
a = 1 // error

// 比较表达式和逻辑表达式的结果都是bool类型
var b bool = (x>y)&&(x>0)

// if 和 for 语句的条件部分一定是bool类型的值或者表达式

// bool类型的初始值为false

var a int = 1
var b int32 =2
b = a // error

// 整型支持算数运算和位运算, 算数表达式和位运算的结果还是整型
var a int = (1+2)*3
var b int = 1000>>2

package main

import "fmt"

var n uint = 10
const N uint = 10

func main(){
	var x byte = (1<<n) %100
	var y byte = (1<<N) %100
	
	fmt.Printf("x:%d, y:%d",x,y) // x:0, y:24
}

v := complex(2.1, 3) // 构造一个复数
a:= real(v) // 返回复数实部
b:= imag(v) // 返回复数虚部
fmt.Println(a,b)

var a = "Hello"
// 字符串是常量, 可以通过类似数组的索引的方式访问其单元, 但是不能修改某个字节的值
b := a[0]

// 字符串转换为[]byte(s)要慎用, 每一次转换都会复制一份

// 字符串尾部不包含Null字符

// 字符串类型底层实现是一个二元的数据结构, 一个是指针, 指向字节数组的起点, 另一个是长度

// 基于字符串创建的切片和元字符串指向相同的底层字符数组, 一样不能修改, 对字符串的切片操作返回的子串仍然是sring
b := a[0:4]
c := a[1:4]
d := a[:4]

// 字符串可以转换为字节数组, 也可以转换为Unicode的字数组
b := []byte(a)
c := []rune(a)

// 字符串可以使用+进行拼接, 也可以进行遍历
for i:=0;i<len(a);i++{ // 遍历字节数组
    fmt.Println(a[i])
}

for i,v := range a{
    fmt.Println(i,v) // 遍历rune数组
}

// 数组的初始化
a := [3]int{1,2,3} // 指定长度和初始化字面量
a := [...]int{1,2,3} // 不指定长度, 由后面的初始化的列表的数量来确定其长度
a := [3]int{1:1,2:3} // 指定总长度, 通过索引进行初始化, 没有初始化的位置使用默认值
a := [...]int{1:1,2:3} // 不指定长度, 通过索引进行初始化, 数组的长度由最高的一个索引确定

// 1. 由数组创建
	var array = [...]int{0,1,2,3,4,5,6,7}
	s1 := array[0:4]
	fmt.Println(s1, len(s1) ,cap(s1)) // [0 1 2 3] 4 8
	// 需要注意的是这是切片引用的数组还是原来的数组, 修改切片元素的话, 数组元素也会发生变化
	s1[0] = 8
	fmt.Println(array) // [8 1 2 3 4 5 6 7]
	// 使用append也是一样的结果
	s1 = append(s1, 10)
	fmt.Println(s1, len(s1) ,cap(s1)) // [8 1 2 3 10] 5 8
	fmt.Println(array) // [8 1 2 3 10 5 6 7]

// 通过内置函数make创建切片
	a := make([]int,10) // 此时创建了一个len为10的切片, 这10个元素被默认为该类型的0值
	fmt.Println(a)
	
	// 也可以指定cap
	a = make([]int,10, 15)
	fmt.Println(len(a), cap(a))
	
	// 切片中的零值是没有作用的, 可以创建长度为0的切片, 之后向里面添加元素
	a = make([]int,0)

str := "hello 世界"
a := []byte(str)
b := []rune(str)

// 使用字面量进行创建
ma := map[string]int{"a":1,"b":2}
println(ma["a"])

// 使用内置的make函数进行创建
mp1 := make(map[int]strign) // 使用默认容量
mp1 := make(map[int]strign, 10) // 指定容量

struct {
    Feild Type
}

type TypeName struct {
    Feild Type
}

type Person struct {
    Name string
    Age int
}

a := Person{"wei",18} // 不推荐, 类型字段变化时, 初始化会出错
b := Person{Name:"wei",Age:18} // 这样的话, 没有初始化的字段都为0值
c := &Person{Name:"wei",Age:18}

package main

func main(){
	switch isOk()
	{
	case true:
		println("true")
	case false:
		println("false")
	}
}

func isOk()bool{
	return false
}

for init; condition;post{}

// 访问map
for key, value := range map{}
for key := range map{}

// 访问数组或切片
for index, value := range array{}
for index := range array{}
for _, value := range array{}

// 访问通道
for value := range channel{}