• 3 go语言变量类型
  • 1 数字
    • 1.1 int、int8、int16、int32、int64
    • 1.2 uint、uint8、uint16、uint32、uint64
      • 1.3 浮点型
      • 1.4 复数
      • 1.5 byte和rune
  • 2 字符串
  • 3 布尔类型
  • 4 常量
  • 5 iota 常量生成器
    • （1）定义规则
  • 6 语句块、可见规则、作用域范围
    • 6.1 语句块
    • 6.2 可见行规则
    • 6.3 作用域范围
      • （1）全局变量
      • （2）局部变量
        • ① 不同的层级作用域
        • ② 内层变量覆盖外层变量
  • 7 函数
    • 7.1 语法规则
      • 7.2 匿名函数
    • 7.3 闭包函数

3 go语言变量类型

1 数字

1.1 int、int8、int16、int32、int64

1.2 uint、uint8、uint16、uint32、uint64

1.3 浮点型

var p1 float32 = 12.12345678901234567890
var p2 float64 = 12.12345678901234567890

fmt.Println(p1)  // 12.123457
fmt.Println(p2) // 12.123456789012346

1.4 复数

	var a complex64 = 4 + 4i
	var b complex64 = 9 + 7i

	fmt.Println(a + b) // (13+11i)

1.5 byte和rune

python 中len()函数算的是字节长度

2 字符串

string

• 双引号：字符串
• 单引号：表示一个字符 - 默认使用int32字符串

字符串 没有则返回空字符串

数字类型 则返回0

3 布尔类型

4 常量

常量：恒定不变的常量，定义后值固定不变，不允许修改，用const关键字定义

• 定义单个

const name string = "duo"  // 完整定义后不允许改
const name = "duo"  

• 定义多个

// 1 这种方式定义多个，只能为同一类型
const name2,age2 = "duo","12"


// 2 可以定义多个不同类型的常量
const (
   loveGod string = "Cupid"
   warGod string = "Athens"
   godAge int = 100
)


// 3 同时定义多个常量，如果没有赋初值，初值就是上一个的值
const (
		a1 = 13
		b1 = 12
		c
		d
		e
		f
)
fmt.Println(c, d, e, f)  //12 12 12 12

5 iota 常量生成器

关键字iota，创建一些列相关的值，省略逐个定义

（1）定义规则

iota声明的常量默认会自增1，iota可理解为const语句块中的行索引

	// iota 常量生成器
	const (
		a1 = 12
		b1 = 12
		c  = iota
		d
		e
		f
	)
	fmt.Println(c, d, e, f)  //2 3 4 5

  // 支持位运算
	const (
		KB = 1 << (10 * iota)
		MB
		GB
	)
	fmt.Println(KB, MB, GB)  // 1 1024 1048576

iota注意事项：

• ① iota的使用，必须在const语句块中
• ② iota 放在第几行，值就是多少，后续的都会自增

6 语句块、可见规则、作用域范围

6.1 语句块

语句块是指：有由大括号围起来的一个语句序列，比如for循环语句块，if/else判断语句块。在语句块内部声明的变量对外部不可见，块把声明围起来，决定了它的作用域

6.2 可见行规则

包通过 导出 机制控制 变量、结构体、函数等数据可见性

• 可见行规则：

全局可见：首字母大写，可导出

包内可见：首字母小写，不可导出

6.3 作用域范围

（1）全局变量

根据可见行规则，决定在包内可用还是在全局可用

（2）局部变量

① 不同的层级作用域

外层定义的变量在内层可以使用，内层定义的变量外层不可以使用。 常见的 if, for 等都是不同的代码块， 每个代码块组成了一个层级。

② 内层变量覆盖外层变量

一个程序可以包含多个相同名称的变量，只要这些变量处在不同的语句块内，而内层的会覆盖外出的同名变量

package main

import "fmt"
// 语句块
var phoneVersion string = "12 plus"

func printVersion (){
	var phoneVersion string = "11 plus"
	fmt.Println(phoneVersion)
}

func main() {
	fmt.Println(phoneVersion)
	printVersion()
}
-------------
12 plus
11 plus

7 函数

函数 是将一个或者一类问题包装为一个代码块，可以被多次调用，提高代码重用性。

7.1 语法规则

func 函数名(参数1 类型, 参数2 类型, ...) (返回值1类型, 返回值2类型, ...) {

		逻辑...
    return 返回值1, 返回值2, ...
}	

/Users/duoduo/mianshi/django_1

// 普通函数，有参数 有返回值
func sayHello(name,sentence string) string {
   fmt.Printf("%s说了：%s",name,sentence)
   return sentence
}

// 调用
sayHello("duoduo","hello world!")

7.2 匿名函数

匿名函数赋值给一个变量

var a string = "duoduo"

func test(b int) {
   var f func() int = func() int {
      fmt.Printf(a)
      return b
   }
   f()
}

7.3 闭包函数

func test1() func() {
   t := 10
   ff := func() {
      fmt.Println(t)
   }
   return ff
}