GO语言学习笔记

GO语言

1.GO语言的整体

优点：不需要考虑时间片，执行多并发线程，能同时执行多个指令操作，强大的标准库机制，有高效的系统调度机制，有丰富的标准库：各种加密解密，email,引用构建，进程线程等等。语言简洁，运行速度快，编译速度快，Go是性能化语言。

适用于网络与云平台计算，在云平台、网络中比较强项、微服务框架，在网络和编译化脚本上比较删除

并且GO可以生成一个可执行，直接运行可执行也可以运行

缺点：包管理有问题，大部分的包都在github上面，甚至有很多版本和接口都是私人管理，第三方私人接口到处包的不稳定。

GO语言对换行很严格，括号的开始，必须要在上一行的结尾，在下一行开始，否则有语法错误，在导入包的时候，可以导入多个包，但是必须要写在括号里面，方便简洁

package main

import (

​    "fmt"

​    "time"

)

func main(){

​    fmt.Println("hello GO!")

​    time.Sleep(1*time.Second)

}

3.变量声明

变量的初始化值，如果什么都不给，默认是0,并且在声明后，如果没有用到的变量，最后也显示为0，在声明变量的时候，可以对字符串整体复制，也可以对整形赋值，甚至不用写变量的类型就可以直接进行复制，bool类型不赋值的话默认为false

package main

import "fmt"

func main(){

​    var a = "lihaolin"

​    var b = 123

​    var c int

​    var d bool

​    fmt.Println(a)

​    fmt.Println(b)

​    fmt.Println(c)

​    fmt.Println(d)

}

输出结果：

lihaolin
123
0
false

4.Go语言的输出的格式

fmt.Print() 默认输出

fmt.Println() 格式化输出

fmt.Printf() 默认输出换行字符‘\n’

package main
import (
	"fmt"
)
func main(){
	var a int
	fmt.Println("a=",a)
	fmt.Printf("type of a =%T\n",a)

	var b int = 100
	fmt.Println("b=",b)
	fmt.Printf("type of b =%T\n",b)

	var c = 100
	fmt.Println("c=",c)
	fmt.Printf("type of c=%T\n",c)

	var bb string = "abcd"
	fmt.Printf("bb = %s, type of bb = %T\n",bb,bb)

	var cc = "abcd"
	fmt.Printf("cc = %s, type of cc = %T\n",cc,cc)


	e:=100
	fmt.Println("e=",e)
	fmt.Printf("type of e =%T\n",e)

}

输出结果：

a= 0
type of a =int
b= 100
type of b =int
c= 100
type of c=int
bb = abcd, type of bb = string
cc = abcd, type of cc = string

冒号省略变量以及初始化声明，直接根据类型进行推断

同一个类型可以用一行进行推到，只用写一个变量就可以，局部变量的声明和全局变量的声明，局部变量的声明默认值为0,推断声明不支持全局变量，也就是不能用冒号进行声明全局变量

5.声明多个变量

package main

import "fmt"

func main(){

​    var xx,yy int = 100,200

​    fmt.Println("xx = ",xx,",yy=",yy)

​    var kk,ll = 100 ,"lhl"

​    fmt.Println("KK = ",kk,",LL=",ll)

​    //多行多变量声明

​    var(

​        vv int = 100

​        jj bool = true

​    )

​    fmt.Println("vv = ",vv,",jj=",jj)

}

多变量声明有以上几种声明方法

输出结果：

xx = 100 ,yy= 200
KK = 100 ,LL= lhl
vv = 100 ,jj= true

6.const常量标识符

常量标识符，在运行程序的时候，不会被修改，一般用来定义枚举类型

package main

import(

​    "fmt"

)

const(

​    BEIJING =iota   //BEIJING = 0

​    SHANGHAI        //SHANGHAI =1

​    SHENZHENG       //SHENZHENG = 2

)

const(

​    a,b=iota+1,iota+2

​    c,d

​    e,f

​    g,h=iota*2,iota*3

​    i,k

)

func main (){

​    const length int =10

​    fmt.Println("lenght = ",length)

​    

​    fmt.Println("Beijing = ",BEIJING)

​    fmt.Println("SHANGHAI = ",SHANGHAI)

​    fmt.Println("SHENZHENG = ",SHENZHENG)

​    fmt.Println("a = ",a,"b = ",b)

​    fmt.Println("c = ",c,"d = ",d)

​    fmt.Println("e = ",e,"f = ",f)

​    fmt.Println("f = ",f,"g = ",g)

​    fmt.Println("h = ",h,"h = ",h)

​    fmt.Println("i = ",i,"k = ",k)

​    

}

常量变量的枚举，iota第一行为0，通过算术算式 ，改变起始位置的值，这些值能够进行依次增加，iota只能配合const使用，在const上面进行累加，并且iota在累加后还能在累加的基础上进行算术

输出结果：

lenght = 10
Beijing = 0
SHANGHAI = 1
SHENZHENG = 2
a = 1 b = 2
c = 2 d = 3
e = 3 f = 4
g = 6 h = 9
i = 8 j = 12

同一个目录下面不能有个多 package main

7.函数声明以及函数的返回值

多种返回形式的写法，需要主要的地方是在有名称的返回值上，在通过付值进行返回，并且推断声明，用冒号的声明的形式，只能进行赋值一次，并且形参的初始化的默认值为0

package main

import "fmt"

func foo1(a string, b int) int {

​    fmt.Println("a = ", a)

​    fmt.Println("b = ", b)

​    c := 100

​    return c

}

func foo2(a string, b int) (int, int) {

​    fmt.Println("a = ", a)

​    fmt.Println("b = ", b)

​    return 666, 777

}

func foo3(a string, b int) (r1 int, r2 int) {

​    fmt.Println("---foo3---")

​    fmt.Println("a = ", a)

​    fmt.Println("b = ", b)

​    r1 = 1000

​    r2 = 2000

​    return

}

func foo4(a string, b int) (r1, r2 int) {

​    fmt.Println("---foo4---")

​    fmt.Println("a = ", a)

​    fmt.Println("b = ", b)

​    r1 = 3000

​    r2 = 4000

​    return

}

func main() {

​    c := foo1("abc", 555)

​    fmt.Println("c = ", c)

​    ret1, ret2 := foo2("haha", 999)

​    fmt.Println("ret1 = ", ret1, "ret2 = ", ret2)

​    ret1, ret2 = foo3("fff", 888)

​    fmt.Println("ret2 = ", ret1, "ret2 = ", ret2)

​    ret1, ret2 = foo4("aaa", 333)

​    fmt.Println("ret2 = ", ret1, "ret2 = ", ret2)

}