1.5 表达式、语句、内置函数 #

1
2
3
4

if err := file.Chmod(0664); err != nil {
	log.Print(err)
	return err
}

1
2
3

if x > 0 {
	return y
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

f, err := os.Open(name)
if err != nil {
    return err
}

d, err := f.Stat()  
if err != nil {
    f.Close()
    return err
}

codeUsing(f, d)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func unhex(c byte) byte {
	switch {
	case '0' <= c && c <= '9':
		return c - '0'
	case 'a' <= c && c <= 'f':
		return c - 'a' + 10
	case 'A' <= c && c <= 'F':
		return c - 'A' + 10
	}
	return 0
}

1
2
3
4
5
6
7

func shouldEscape(c byte) bool {
	switch c {
	case ' ', '?', '&', '=', '#', '+', '%':
		return true
	}
	return false
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

**Loop**:
	for n := 0; n < len(src); n += size {
		switch {
		case src[n] < sizeOne:
			if validateOnly {
				break
			}
			size = 1
			update(src[n])

		case src[n] < sizeTwo:
			if n+1 >= len(src) {
				err = errShortInput
				break **Loop**
			}
			if validateOnly {
				break
			}
			size = 2
			update(src[n] + src[n+1]<<shift)
		}
	}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// Compare 按字典顺序比较两个字节切片并返回一个整数。
// 若 a == b，则结果为零；若 a < b；则结果为 -1；若 a > b，则结果为 +1。
func Compare(a, b []byte) int {
	for i := 0; i < len(a) && i < len(b); i++ {
		switch {
		case a[i] > b[i]:
			return 1
		case a[i] < b[i]:
			return -1
		}
	}
	switch {
	case len(a) > len(b):
		return 1
	case len(a) < len(b):
		return -1
	}
	return 0
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

var t interface{}
t = functionOfSomeType()
switch t := t.(type) {
default:
	fmt.Printf("unexpected type %T", t)       // %T 输出 t 是什么类型
case bool:
	fmt.Printf("boolean %t\n", t)             // t 是 bool 类型
case int:
	fmt.Printf("integer %d\n", t)             // t 是 int 类型
case *bool:
	fmt.Printf("pointer to boolean %t\n", *t) // t 是 *bool 类型
case *int:
	fmt.Printf("pointer to integer %d\n", *t) // t 是 *int 类型
}

1
2
3
4
5
6
7
8

// 形式一：如同C的for循环
for init; condition; post { }

// 形式二：降级为C的while循环
for condition { }

// 形式三：降级为空子句的C的for(;;)循环
for { }

1
2
3
4

sum := 0
for i := 0; i < 10; i++ {
	sum += i
}

1
2
3

for key, value := range oldMap {
	newMap[key] = value
}

1
2
3
4

// 反转 a
for i, j := 0, len(a)-1; i < j; **i, j = i+1, j-1** {
	a[i], a[j] = a[j], a[i]
}

1
2
3
4

slice := []int{1, 2, 3}
length := len(slice)  // 内置函数 **编译器直接生成获取长度的代码**，不需要函数调用开销

// length := len(slice)  // 如果 len 是普通函数，会有 **压栈、跳转、返回等 函数调用开销**

1
2
3
4
5

// 内置函数有特殊的类型检查规则。**如果 len 有标准类型，需要复杂的重载或泛型支持**
len("hello")     // 字符串长度
len([]int{1,2})  // 切片长度
len([3]int{})    // 数组长度
len(map[string]int{}) // 映射长度

1
2

// 编译器可以对内置函数进行特殊优化。**如果 make 是普通函数，优化空间有限**
slice := make([]int, 10, 20)  // **编译器直接生成内存分配代码**

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 内置函数没有标准的函数类型
var f func([]int) int = len  // ❌ 编译错误：cannot use len as func([]int) int value

// 只能出现在调用表达式中
length := len(slice)

// 不能作为参数传递
processFunction(len)  // ❌ 错误：不能传递内置函数

// 不能作为返回值
return len  // ❌ 错误：不能返回内置函数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 创建包装函数
func getLength(slice []int) int {
    return len(slice)
}
// ✅ 可以传递包装函数
var f func([]int) int = getLength


// 函数类型别名
type LengthFunc func([]int) int
var f LengthFunc = getLength