go学习记录——第一天

go的基本组成部分

• 包声明
• 引入包
• 函数
• 变量
• 语句 & 表达式
• 注释

go变量声明

go中用var来声明变量，语法如下：

var variableName dataType

其中，variableName为变量名，dataType为变量的数据类型。

一次声明多个变量

var (
    variable1 dataType1
    variable2 dataType2
    variable3 dataType3
)

第一种，指定变量类型，如果没有初始化则默认为0

var v_name v_type
v_name = value
或
var v_name v_type = value

第二种，不指定类型，由编译器自动推导

var v_name = value

第三种，短变量声明，在函数内使用，注意当已经进行了变量声明再使用短声明会报错。短声明只适用于函数内使用，不能在全局作用域使用。

v_name := value

第四种，多变量声明

var (
    v1, v2, v3 = 1, 2, "hello"
)
或
var v1, v2, v3 = 1, 2, "hello" // 这个为主使用，和python类似，迁移起来较快
或
v1, v2, v3 := 1, 2, "hello"

go常量声明

只能使用布尔型、数字型（int, float, 复数）和字符串型

常量定义格式

const constantName  [type]= value

多个常量声明

const constantName1, constantName2 = value1, value2

常量中可以使用内置函数进行运算，如len(), cap(), unsafe.Sizeof()等。

inta

inta是go中的特殊常量，可以当作一个可以被编译成功的常量

inta在const关键词出现时将被重置为0，const中每加一行都将使inta加1。

inta可以做枚举值

const (
    a = inta
    b = inta
    c = inta
)

inta也可以做一个类似行索引的功能

const (
    a = inta
    b
    c
)

输出的结果就是a=0, b=1, c=2。

inta用法

package main

import (
	"fmt"
)

func main() {
	const (
		a = iota
		b
		c
		d = "ha"
		e
		f = 100
		g
		h = iota
		i
	)

	fmt.Println(a, b, c, d, e, f, g, h, i)
}
// output：
// 0 1 2 ha 4 100 6 7 8

go的运算符

算数运算符

1. ++ 自增，和+=1类似

2. – 自减，和-=1类似

别的和python一样

关系运算符

和python一样，直接忽略

逻辑运算符

1. && -> and

2. || -> or

3. ! -> not

从字母换成了符号，其他没区别

位运算符

1. & -> 按位与

2. | -> 按位或

3. ^ -> 按位异或

4. << -> 左移

5. -> 右移

6. ~ -> 按位取反

赋值运算符

1. <<= -> 左移后赋值

2. = -> 右移后赋值

3. &= -> 按位与后赋值
4. |= -> 按位或后赋值
5. ^= -> 按位异或后赋值

其他和python一样

其他运算符

1. & -> 返回实际地址
2. ‘*’ -> 指针变量

运算优先级

优先级	运算符
1 一元运算符	* &（取地址） +（正号） -（负号）! ~（按位异或）
2 乘除类运算符	* / % << >> &（按位与） &^（按位清除）
3 加减类运算符	+ - ‘
4 关系运算符	== != < <= > >=
5 逻辑运算符	&& 逻辑或（符号markdown无法显示就用文字代替了）

条件语句

和python一样，但编写方式有些不同

if

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
}

if…else

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
} else {
  /* 在布尔表达式为 false 时执行 */
}

if…else if…else

if 布尔表达式1 {
   /* 在布尔表达式1为 true 时执行 */
} else if 布尔表达式2 {
   /* 在布尔表达式2为 true 时执行 */
} else {
  /* 在布尔表达式1和表达式2都为 false 时执行 */
}

switch

switch 表达式 {
   case 值1:
      /* 当表达式的值等于值1时执行 */
      break
   case 值2:
      /* 当表达式的值等于值2时执行 */
      break
   default:
      /* 当以上都不满足时执行 */
}

Type Swith

用于判断某个interface变量的实际类型

switch x.(type){
    case type:
       statement(s);      
    case type:
       statement(s); 
    /* 你可以定义任意个数的case */
    default: /* 可选 */
       statement(s);
}

例子如下

package main

import "fmt"

func main() {
   var x interface{}
     
   switch i := x.(type) {
      case nil:   
         fmt.Printf(" x 的类型 :%T",i)                
      case int:   
         fmt.Printf("x 是 int 型")                       
      case float64:
         fmt.Printf("x 是 float64 型")           
      case func(int) float64:
         fmt.Printf("x 是 func(int) 型")                      
      case bool, string:
         fmt.Printf("x 是 bool 或 string 型" )       
      default:
         fmt.Printf("未知型")     
   }   
}

output:
x 的类型 : <nil>

fullthrough

强制执行case后语句，不会判断是否为true
即使用了fullthrough，也可以直接用break跳出switch

select

此select非彼select。不是SQL中的那个查看

这里的select虽然类似switch，但只能作用于通道，一个case只能进行接受或发送

select会监听每个通道，只要有一个case准备好了就立马执行。如果多个准备好就随机挑选一个。如果一个都没准备好执行default。

select {
  case <- channel1:
    // 执行的代码
  case value := <- channel2:
    // 执行的代码
  case channel3 <- value:
    // 执行的代码

    // 你可以定义任意数量的 case

  default:
    // 所有通道都没有准备好，执行的代码
}

注意

• 每一个case都必须对应一个通道
• 所有channel表达式都会被求值
• 所有被发送的表达式都会被求值
• 如果有default则会在case均未准备好时执行。如果没有则会阻塞，直到有通道可以运行。Go不会重新对channel或值进行求值

今儿的就学到这里吧，感觉上在语句写法上和C类似。不过可能是我一直用Python所以还有点不习惯用花括号来作为代码块的感觉。慢慢习惯吧，今儿没啥心情，感觉学不下去了，休息咯~