一、基础语法

1、fmt

fmt.Print & fmt. Println：可以传递若干个参数，逗号隔开，参数可以是字符串、数字、数学表达式。

fmt.Printf ：格式化打印，Printf的第一个参数必须是字符串

rune   %c  打印字符而不是数字

2、常量和变量

Const : 声明常量

Var ：声明变量

3、rand

rand 包 生成伪随机数     

rand 路径是 math/rand

rand.Intn (生成随机数范围)

4、Boolean 类型

只有true 和flase

5、if语句

func main() {

    var a = "true"

    if a == "true" {

        fmt.Println("true")
        
        } else if a == "true" {

        fmt.Println("true")

    } else {
    
        fmt.Println("flase")
    }

}

6、Switch case

func main() {

    var a = "abcd"

    switch a {

    case "abc":

        fmt.Println("true")

    case "abcde", "abcddd", "abcd":

        fmt.Println("truee")

//fallthrough 关键字 执行下一个case的body部分
        fallthrough //只能衔接上一个

    case "sdfjdfjs":

        fmt.Println("jdfjs")

    default:

        fmt.Println("flase")

    }

7、实数

绝对值： (math.Abs(a-b)<0.0001)

8、超大的数

Big包： big.NewInt()

9、字符串

Atoi函数

字符串 转 整数： Strconv.Itoa         

整数转换成字符串： Strconv.ParseBool

字符串大小写转换 及strings.replace用法： string.Replace(s,old,new string, n int )

返回s 将old字符串替换为new字符串，n<0则无限替换

10 、 函数

函数：

func ktoc(k kelvin) celsius

函数名（函数接收者 接收者类型 ）函数类型 

返回值：函数类型（函数接收者）

函数调用：函数名（函数接收者）

方法 ：

func (k kelvin) fahrenheit() fahrenheit    

(方法接收者 接收者类型) 方法()方法类型  方法返回类型

返回值：函数类型（函数接收者）

方法调用： 变量.方法（）

例子：摄氏度 华氏度 开氏度 转换

func KToS(k float64) float64 {

    k -= 273.15

    return k

}

// celsiusToFahrenheit

func sToF(c float64) float64 {

    c = (c * 9.0 / 5.0) + 32

    return c

}

func kToF(d float64) float64 {

    d = KToS(d)

    d = sToF(d)

    return d

}

func main() {

    kelvin := 294.0

    celsius := KToS(kelvin)

    fahrenheit := sToF(kelvin)

    ke := 0.0

    fah := kToF(ke)

    fmt.Println(kelvin, "°k", " answer is", celsius, "°c")

    fmt.Println(celsius, "°c", " answer is", fahrenheit, "°F")

    fmt.Println(ke, "°k", " answer is", fah, "°F")

}

匿名函数

func main() {

    func() {

        fmt.Println("我是f3函数")

    }()

    r1 := func(a, b int) int {

        return a + b

        // fmt.Println(a, b)

    }(1, 2)

    fmt.Println(r1)
}

高阶函数  ：回调函数，可以将一个函数作为另一个函数的参数

11、println底层逻辑   ...可变参数

func getsums(number ...int) {}

12、值传递&引用传递

值传递：只是拷贝数据而非地址，a复制b，修改a不会影响b

Int   string  bool float64 array

引用传递：传递的是地址，a，b指向同一个地址

Slice map chan

值传递：

func a(arr2 [5]int) {

    arr2[0] = 100

    fmt.Println(arr2)

func main() {

    arr1 := [5]int{1, 2, 3, 4, 5}

    fmt.Println(arr1)

    a(arr1)

    fmt.Println(arr1)
}

引用传递：

func update(arr2 []int) {

    fmt.Println(arr2)

    arr2[0] = 88

    fmt.Println(arr2)
}

func main() {

    arr := []int{1, 2, 3, 4}

    fmt.Println("arr默认的数据", arr)

    update(arr)
}

13、闭包

一个外层函数中，有内层函数，该内层函数中，会操作外层函数的局部变量并且该外层函数的返回值就是这个内层函数。这个内层函数和外层函数的局部变量，统称为闭包结构。

局部变量的生命周期就会发生改变，正常的局部变量会随着函数的调用而创建，随着函数的结束而销毁， 但是闭包结构中的外层函数的局部变量并不会随着外层函数的结束而销毁，因为内层函数还在继续使用

14、切片(Slice)

切片是对数组的抽象。

数组的长度不可改变，在特定场景中这样的集合就不太适用，Go 中提供了一种灵活，功能强悍的内置类型切片("动态数组")，与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

定义切片

声明一个未指定大小的数组来定义切片：

var identifier []type

切片不需要说明长度。

使用 make()  函数来创建切片:

var slice1 []type = make([]type, len)

也可以简写为

slice1 := make([]type, len)

也可以指定容量，其中 capacity 为可选参数。

make([]T, length, capacity)

15、Map（集合）  

创建一个空的 Map

m := make(map[string]int)

创建一个初始容量为 10 的 Map

m := make(map[string]int, 10)

16、结构体（struct）

type child struct{

    name string
    
    age  int
    
}

访问:结构体.成员名(child.name)

二、总结

最后总结了golang的一些优点：

• 自带gc。
• 静态编译，编译好后，扔服务器直接运行。
• 简单的思想，没有继承，多态，类等。
• 丰富的库和详细的开发文档。
• 语法层支持并发，和拥有同步并发的channel类型，使并发开发变得非常方便。
• 简洁的语法，提高开发效率，同时提高代码的阅读性和可维护性。
• 超级简单的交叉编译，仅需更改环境变量