第三章(表达式)

硬件的方向是物理，软件的结局是数学

• go语言仅25个保留关键字

• 无显式类型声明的常量，那么该常量操作数会自动转型

package main

import "fmt"

func main() {
	const v = 20 //无显式类型声明的变量
	fmt.Printf("%T,%v\n", v, v)
	var a byte = 10
	b := a + v                  //v自动转换为byte/uint8类型
	fmt.Printf("%T,%v\n", v, v) // int,20 v还是int类型，上面只是计算时隐式转换成uint8
	fmt.Printf("%T,%v", b, b)   //uint8,30
}

• 优先级

  一元运算符优先级最高，二元则分为五个等级，从高往低分别是

相同优先级的二元运算符，从左往右依次计算

• &^运算符(AND NOT)

        //AND NOT
	n1 := 6
	n2 := 11
	n3 := n1 &^ n2         // 0101 &^ 1011  //右操作数取反后与左操作数求&
	fmt.Printf("%04b", n3) // 0100

eg （AND NOT）

package main

import "fmt"

const (
	read   byte = 1 << iota // 0001
	write                   //0010
	exec                    //0100
	freeze                  //1000
)

func main() {
	//fmt.Printf("%04b  %04b  %04b %04b\n", read, write, exec, freeze)
	a := read | write | freeze                   // 0001 | 0010 | 1000 = 1011
	b := read | freeze | exec                    //0001 | 1000 | 0100 = 1101
	c := a &^ b                                  // 1011 &^ 1101   =  1011 & 0010 = 0010
	fmt.Printf("%04b &^ %04b = %04b\n", a, b, c) //1011 &^ 1101 = 0010
}

• 自增运算符不能前置，不能用于表达式，只能作为独立语句

• 指针不能做加减法运算(和C不用)和类型转换，支持相等运算符。如果两个指针指向同一地址或都为nil,那么它们相等

• 符合类型(array/slice/map/struct)变量初始化时：

  • 初始化表达式必须含类型标签
  • 左花括号必须在类型尾部，不能另起一行
  • 多个成员初始值用逗号分隔
  • 允许多行，单每行须以逗号或花括号结束

eg

        //正确示例
	type data struct {
		x int
		s string
	}
	var a2 = data{1, "abc"}
	b2 := data{
		1,
		"abc",
	}
	fmt.Println(a2, b2)

• switch相邻的空case不构成多条件匹配

func main() {
	a := 1
	switch a {
	case 1:  //隐式的 "case 1: break;"
	case 2:
		println(2)
	}
}

• fallthrough(在switch语句使用)

  • 如需贯通后续case，须执行fallthrough,直接执行后续语句，而不匹配条件表达式,可以使用break语句终止。

  eg

  switch z := 5; z {
  
    case 5:
    	z += 10
    	println(z)
    	fallthrough
    case 6:
    	z += 20
    	println(z)
    	fallthrough
    default:
    	z += 100
    	println(z)
    }
        //输出 15 35 135
  

• 如果range目标表达式是函数调用，仅执行一次