什么是Go语言

* 高性能、高并发；语法简单、学习曲线平缓；丰富的标准库；完善的工具链；静态链接；快速编译；跨平台；垃圾回收

字节为什么全面拥抱Go语言

* 性能比较好；部署简单、学习成本低；内部RPC和HTTP框架的推广

Go入门

基础语法-helloworld

package main

import  "fmt"

func main(){
    fmt.Println("hello world")
}

发现一个大大的问题Go中没有“;”

基础语法

变量

变量的定义初始化只是格式的不同，而且不需要指明类型，会直接自动识别

var a="inital"    //字符串初始化
var b,c int =1,2  //多个整型初始化
var d=true        //bool值初始化
var e float64     //浮点类型初始化

package main

import(
    "fmt"
    "math"
)

func main(){
    var a="inital"    //字符串初始化
    var b,c int =1,2  //多个整型初始化
    var d=true        //bool值初始化
    var e float64     //浮点类型初始化
    f :=float32(e)    //赋值
    g :=a + "foo"     //赋值
    fmt.Println(a,b,c,d,e,f) //inital 1 2 true 0 0
    fmt.Println(g)           //initialapple
    
    const s string="constant" 
    const h=50000000
    const i=3e20 /h
    fmt.Println(s,h,l,math.Sin(h),math.Sin(i))
    }

if else

package main
import "fmt"
func main()
{

    if 7%2 {
        fmt.Println("7 is even")
    } else {
        fmt.Println("7 is odd")
    }
    if num :=9;num<0 {
        fmt.Println(num,"is negative")
    }
    else if num<10 {
        fmt.Println(num,"has 1 digit")
    } else {
        fmt.Println(num,"has multiple digits")
    }
}

语法格式都是类似于c和c++的，if，if else，还有if中的嵌套和c/c++的区别是：if语句后面不用带括号，而且可以初始化新的变量if num :=9;num<0

循环

package main
import "fmt"
func main()
{
    i :=1
    for{
        fmt.Println("loop")
        break
    }
    for j :=7;j<9;j++{
        if n :=0;n<5;n++{
            continue
        }   
        fmt.Println(i)
    }
    for i<=3{
        fmt.Println(i)
        i=i+1
    }
}

switch

基本格式和C语言一致，就是少去了括号还有break，在switch分支后面还可以不加条件，直接加在case的后面，变成更加高阶的if else语句

package main
import "fmt"
func main()
{
    a :=2
    switch a{
    case 1:
        fmt.Println("one")
    case 2:
        fmt.Println("two")
    case 3:
        fmt.Println("three")
    case 4,5:
        fmt.Println("four or five")
    default:
        fmt.Println("other")
    }
    
    t :=time.Now()
    switch {
    case t.Hour() < 12:
        fmt.Println("It is before noon")
    default:
        fmt.Println("It is after noon")
    }
}

数组

主要区别还是在于格式的不同，写起来不是很顺畅

    package main
    import "fmt"
    func main()
    {
        var a [5]int
        a[4] = 100
        fmt.Println(a[4], len(a))
        
        b :=[5]int{1,2,3,4,5}
        fmt.Println(b)
        
        var twoD [2][3]int
        for i :=0; i<2 ; i++{
            for j :=0;j<3; j+={
                twoD[i][j]=i+j
            }
        }
        fmt.Println("sd: ",twoD)
    }

切片

切片语法感觉很类似之前所学过的python，给定一个范围，取该范围内的值

    package main
    import "fmt"
    func main()
    {
        s :=make([]string, 3)
        s[0]="a"
        s[1]="b"
        s[2]="c"
        fmt.Println("get",s[2])     //c
        fmt.Println("len",len(s))   //3
        
        s = append(s,"d")          //添加d元素
        s = append(a,"e","f")      //添加e，f元素
        fmt.Println(s)             //[a b c d e f]
        c :=make([]string,len(s))
        copy(c,s)
        fmt.Println(s[2:5])        //[c d e]
        fmt.Println(s[:5])         //[a b c d e]
        fmt.Println(s[2:])         //[c d e f]
        good :=[]string{"g","o","o","d"}
        fmt .Println(good)         //[g o o d]
    }

map

map里面有一个键值对，第一个值是标识的关键码，第二个值是所存储的值

package main
import "fmt"
func main()
{
    m :=make(map[string]int)
    m["one"]=1
    m["two"]=2
    fmt.Println(m)           //map[one:1 two:2]
    fmt.Println(len(m))      //2
    fmt.Println(m["one"])    //1
    fmt.Println(m["unknow"]) //0
    
    r,ok :=["unknow"]
    fmt.Println(r,ok)       //0 false
    
    delete(m,"one")
    
    m2 :=map[string]int{"one":1,"two":2}
    var m3=map[string]int{"one "}
}

range

用来快速遍历，使代码更加简洁，range遍历的时候，对于数组会返回两个值，一个是索引，一个是值，也就是一个键值对。

for k,v :=range m{
    fmt.Println(k,v)
}

函数

函数返回时会返回两个值：1.真正的结果 2.错误信息

指针

主要用途：

对于传入参数进行修改。对值修改时需要使用指针，才能起作用，因为函数中所传入的值只是进行的一个拷贝，而指针类型才能达到对于值本身的改变

结构体

可以用结构体名称去初始化一个结构体变量，构造的时候需要传入每个字段的初始值

结构体方法

比较类似类成员函数，实现方法：1.带指针（对成员本身进行修改）3.不带指针（只进行值的修改）

错误处理

在函数里，可以在函数的返回值后面加一个error，就代表这个函数可能会返回错误

return &u,error.New("not found")

字符串操作

*contains 判断一个字符串里是否还包含另一个字符串 *count 字符串计数 *index 查找某个字符串的位置 *join 连接多个字符串 *repeat 重复多个字符串 *replace 替换字符串

Go---基础语法