GO语言02 注释 程序如何运行 变量 数据类型 常量 函数

注释

程序如何运行

方式1：窗口中
1.编译：go build 文件名
2.执行：文件名

方式2：窗口中
编译并执行：go run 文件名

方式3：直接右键执行

变量

1.什么是变量

变量指定了某存储单元（Memory Location）的名称，该存储单元会存储特定类型的值。在 Go 中，有多种语法用于声明变量。

2.声明变量

方式1完整写法：
var关键字 变量名  变量类型 = 值
var a int=10   //定义了一个int类型的a ，把10赋值给他

方式2类型推导：
var关键字 变量名  = 值
var a =10

方式3简略声明：
变量名:  = 值
a:=10

方式4：同时定义多个变量

//var a =10
//var b=100
//var a,b int
//var a,b int=10,20
//var a,b=10,20
//var a,b=10,"lqz"
//a,b:=10,20
//a,b:=10,"lqz"
//fmt.Println(a)
//fmt.Println(b)
var (
   name   = "naveen"
   age    = 29
   height int
)

拓展1：定义不赋初值  :int 类型默认值是0  string 类型默认值是空字符串
var a int
//a=10
var b string
//b="lqz"

声明注意点

1.变量不能用var重复定义
var a int=10
var a =10 // 报错不能重复定义

2.类型是固定的,可以更改变量的值但值的类型要一致
var a =10
a=100 // 可以更改
b:="lqz" // 报错值的类型不一致

数据类型

https://www.cnblogs.com/xiaoyuanqujing/articles/11676016.html

1.数字类型

1.int类型：表示整数,int8   int16  int32  int64。
计算机最小计量单位：bit位  int8 是 8个比特位=1个字节，表示的范围是：正负2的7次方减1

2.在32位机器上int 就是int32 ，在64位机器上int就是int64
    uint类型：表示正整数 uint8 uint16...
    float类型：表示小数只有float32和float64
    complex64类型：复数
    byte: uint8的别名
    rune:int32的别名
    //var a int=-10
    //fmt.Println(a)
    //var a int =100000
    //fmt.Println(a)
    //var a uint8=100
    //fmt.Println(a)
    //var a float32=2.33
    //fmt.Println(a)

2.字符串

1.必须用双引号（单行）,反引号是python中的三引号（多行）
2.示例

var a string="lqz"
var c string=`阿斯蒂芬a
手动阀afd阿斯蒂芬
安抚
asfd阿萨德f`

3.布尔类型

1.bool类型 值为true或false,0值是false
2.示例：
var b bool =true
//var b =true
//b:=true
//var b bool //默认为false

4.查看值的类型

查看类型： "%T"
b:='a'
fmt.Printf("%T",b) 

常量

1.什么是常量

值的是恒定不变的量

2.常量的定义

https://www.cnblogs.com/xiaoyuanqujing/articles/11676022.html

1.定义常量
const 名 = 值

2.常量赋值不能更改

3.示例：
package main
func main() {  
    const a = 55 // 允许
    a = 89       // 不允许重新赋值
}

函数

1.什么是函数

函数是一块执行特定任务的代码。一个函数是在输入源基础上，通过执行一系列的算法，生成预期的输出。

2.函数定义语法

func关键字 函数名(参数1 类型，参数2 类型) (返回值类型1，返回值类型2){函数体}

示例：

1.无参数，无返回值
func test()  {
    fmt.Println("xxx")

}

2.有两个int类型的参数
func test(a int,b int)  {}
func test(a ,b int)  {}
func test(a ,b int,c string)  {
    fmt.Println(a+b)
}

3.有一个数字类型返回值,一定要指定返回值类型
func test(a,b int) int {
    return a+b
}
func test(a,b int) string {
    return "lqz"
}

返回多个值
func test(a,b int) (int,string)  {
    return a+b,"成功"
}

4.命名返回值
func test(a,b int) (c int, d string)  {
    c=10
    d="成功"
    return
}

5.在go中没有位置参数和关键字参数，都是位置参数,也没有默认参数
func test(a,b int) int {
    return a+b
}

6.不定长参数
func test(a ...interface{})  {
    fmt.Println(a)

}

3.函数是一等民

1.go语言中，函数是一等公民，可以把函数赋值给一个变量，函数就是一等公民

2.函数也是有类型的：除了函数的名字和函数体，把参数和返回值原封不动的拿过来就是一个函数的类型

3.示例：
func test(a int) (int,int) {
    fmt.Println("xxx")
    return 1,2

}

func main() {
    var a func(a int)(int,int)
    //var a =test
    a=test
    a(1)
}

4.闭包函数和内层函数

1.简介和注意点

1.闭包函数：定义在函数内部，对外部作用域有引用。

2.内层函数：定义在函数内部的函数。

3.go中函数内部定义的函数是不能有名的，需要定义匿名函数:没有名字

2.示例

1.内层函数示例：
func test(a int)  {
    func() {
        fmt.Println("我是内层函数")
    }() // 加括号匿名函数会自调用，也可不加括号把匿名函数返回出去，在调用
}

2.闭包函数
func test(a int) (func()) {
    //var c int =100
    b:=func() {
        fmt.Println(a) // 引用了外部函数作用域，所以是闭包函数
        fmt.Println("我是闭包函数")
    }
    return b  // 返回匿名函数，可在外部接收使用
}

3.定义一个函数，传入函数，返回函数
func test(a func()) func()  {
    b:= func() {
        fmt.Println("我先执行")
        a()
        fmt.Println("函数执行完了")
    }
    return b
}
func test2()  {
    fmt.Println("xxxx")

}

5.给类型起别名

1.语法：
type 别名  类型
2.示例：
type MyFunc  func(a int,b int) func()

type MyInt int