有兴趣的小伙伴可以+vx一起学习：lmomo7205

Go 学习笔记

Go语言变量和常量

1. 标识符

在变成语言中标识符就是程序员定义的具有特殊意义的词，比如变量名、常量名、函数名等等。Go语言中标识符由字母数字和_下划线组成，并且只能以字母和_开头，比如abc、_、_123、a123

2. 关键字

关键字是指变成语言中预先定义好的具有特殊含义的标识符。关键字和保留字都不建议用做变量名。

1. Go语言中有25个关键字

       break        default      func         interface    select
       case         defer        go           map          struct
       chan         else         goto         package      switch
       const        fallthrough  if           range        type
       continue     for          import       return       var
   

2. 37个保留字段

      Constants:    true  false  iota  nil
   
           Types:    int  int8  int16  int32  int64  
                     uint  uint8  uint16  uint32  uint64  uintptr
                     float32  float64  complex128  complex64
                     bool  byte  rune  string  error
   
       Functions:   make  len  cap  new  append  copy  close  delete
                    complex  real  imag
                    panic  recover
   

3.变量

程序运行过程中的数据都是保存在内存中，我们想要在代码中操作某个数据时就需要去内存上找到这个变量，但是如果我们直接在代码中通过内存地址去操作变量的话，代码的可读性会非常差而且还容易出错，所以我们就利用变量将这个数据的内存地址保存起来，以后直接通过这个变量就能找到内存上对应的数据了。
***
Go语言中变量必须声明后才能使用，同意作用域内不支持重复声明，并且变量声明后必须使用，不然会报错

1. 变量标准声明

   每声明一个变量就要使用一个var

   var 变量名 变量类型 = var name string
   

2. 批量声明

   批量声明可以使用一个var

   var (
   name string
   age int
   money float32
   )
   

3. 变量的初始化

   Go语言在声明变量的时候，会自动对变量对应的内存区域进行初始化操作，每个变量会被初始化成其类型的默认值，例如：int和float类型的变量初始值为0，string的初始值为 空字符串，布尔类型默认值为 false，切片、函数、指针变量的默认值为nil

   // 在声明变量的时候可以指定初始值如下
   var 变量名 类型 = 表达式 = var name string = "Lmomo"
   // 一次是初始化多个变量，有两种方式
   1. var name,age ="Lmomo",20 //此种声明会进行推导类型
   2. var (
    name string = "lmomo"
       age int = 20
   )
   

4. 类型推导

   声明变量的时候可以省略类型，此时Go语言会根据=号右边的值进行推导类型

   var name ="Lmomo" // name类型为string
   

5. 短变量声明

   短变量声明只能在局部变量中使用，可以使用:=方式声明并初始化变量

   var m = 100 //全局变量
   func main(){
    n:=10
    m:=200 //此处为局部变量
   }
   

6. 匿名变量

   使用多重赋值时，如果需要忽略某一个值，可以使用匿名变量（anonymous variable）。匿名变量用一个下划线_表示，匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。（在Lua等变成语言中，匿名比那里也被称作哑元变量）

   package main
   func foo()(int,string){ //无入参，返回int和string类型的两个参数
    return 10,"Lmomo"
   }
   func main(){
    x,_:=foo() //值为10和空
    _,x:=foo() //值为空和Lmomo
   }
   

7. 注意事项

   1. 函数外的每个语句都必须以关键字开始（var、const、func等）
   2. :=不能在函数外使用，只做局部变量
   3. _多用于占位，表示忽略值

4.常量

对比变量声明方式基本一致只是var换成了const，并且声明必须赋值，而且在程序运行过冲中不能修改

// 几种定义常量的方式
const name string ="Lmomo"
const name ="Lmomo"
const (
    name string = "Lmomo"
)
const(
    name ="Lmomo"
)
const(
    name ="Lmomo"
    name1 
    name2
    name3
    // name-name3值均为Lmomo
)

1. iota

   iota是go语言的常量计算器，只能在常量的表达式中使用。

   iota在const关键字中出现的时候将被重置为0，重复使用后以第一次使用时为准

   const(
    number = iota //0
    number1 //1
    number2 //2
    number3 //3
   )
   const(
    number = iota //0
    number1 //1
    number2 = iota //2
    number3 //3
   )
   const(
    number = iota //0
    number1 = 100 //100
    number2 = iota //2
    number3 //3
   )
   const(
    number = iota //0
    number1 = 100 //100
    _
    number3 //2
   )
   

Go语言基本数据类型

整数

整型分为以下两个大类： 按长度分为：int8、int16、int32、int64 对应的无符号整型：uint8、uint16、uint32、uint64

其中，uint8就是我们熟知的byte型，int16对应C语言中的short型，int64对应C语言中的long型。

类型	描述
uint8	无符号 8位整型 (0 到 255)
uint16	无符号 16位整型 (0 到 65535)
uint32	无符号 32位整型 (0 到 4294967295)
uint64	无符号 64位整型 (0 到 18446744073709551615)
int8	有符号 8位整型 (-128 到 127)
int16	有符号 16位整型 (-32768 到 32767)
int32	有符号 32位整型 (-2147483648 到 2147483647)
int64	有符号 64位整型 (-9223372036854775808 到 9223372036854775807)

特殊整数型

类型	描述
uint	32位操作系统上就是uint32，64位操作系统上就是uint64
int	32位操作系统上就是int32，64位操作系统上就是int64
uintptr	无符号整型，用于存放一个指针

注意： 在使用int和 uint类型时，不能假定它是32位或64位的整型，而是考虑int和uint可能在不同平台上的差异。

注意事项 获取对象的长度的内建len()函数返回的长度可以根据不同平台的字节长度进行变化。实际使用中，切片或 map 的元素数量等都可以用int来表示。在涉及到二进制传输、读写文件的结构描述时，为了保持文件的结构不会受到不同编译目标平台字节长度的影响，不要使用int和 uint。

浮点型

Go语言支持两种浮点型数：float32和float64。这两种浮点型数据格式遵循IEEE 754标准： float32 的浮点数的最大范围约为 3.4e38，可以使用常量定义：math.MaxFloat32。 float64 的浮点数的最大范围约为 1.8e308，可以使用一个常量定义：math.MaxFloat64。

复数

complex64和complex128

var c1 complex64
c1 = 1 + 2i
var c2 complex128
c2 = 2 + 3i
fmt.Println(c1)
fmt.Println(c2)

复数有实部和虚部，complex64的实部和虚部为32位，complex128的实部和虚部为64位。

布尔值

Go语言中以bool类型进行声明布尔型数据，布尔型数据只有true（真）和false（假）两个值。

注意：

1. 布尔类型变量的默认值为false。
2. Go 语言中不允许将整型强制转换为布尔型.
3. 布尔型无法参与数值运算，也无法与其他类型进行转换。

字符串

Go语言中的字符串以原生数据类型出现，使用字符串就像使用其他原生数据类型（int、bool、float32、float64 等）一样。 Go 语言里的字符串的内部实现使用UTF-8编码。 字符串的值为双引号(")中的内容，可以在Go语言的源码中直接添加非ASCII码字符，例如：

字符转义符

Go 语言的字符串常见转义符包含回车、换行、单双引号、制表符等，如下表所示。

转义符	含义
\r	回车符（返回行首）
\n	换行符（直接跳到下一行的同列位置）
\t	制表符
\'	单引号
\"	双引号
\\	反斜杠

多行字符串

Go语言中要定义一个多行字符串时，就必须使用反引号字符：

s1 := `第一行
第二行
第三行
`
fmt.Println(s1)

反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出。

字符串的常用操作

方法	介绍
len(str)	求长度
+或fmt.Sprintf	拼接字符串
strings.Split	分割
strings.contains	判断是否包含
strings.HasPrefix,strings.HasSuffix	前缀/后缀判断
strings.Index(),strings.LastIndex()	子串出现的位置
strings.Join(a[]string, sep string)	join操作

byte和rune类型

组成每个字符串的元素叫做“字符”，可以通过遍历或者单个获取字符串元素获得字符。 字符用单引号（’）包裹起来，如：

var a := '中'
var b := 'x'

Go 语言的字符有以下两种：

1. uint8类型，或者叫 byte 型，代表了ASCII码的一个字符。
2. rune类型，代表一个 UTF-8字符。

当需要处理中文、日文或者其他复合字符时，则需要用到rune类型。rune类型实际是一个int32。

Go 使用了特殊的 rune 类型来处理 Unicode，让基于 Unicode 的文本处理更为方便，也可以使用 byte 型进行默认字符串处理，性能和扩展性都有照顾。

// 遍历字符串
func traversalString() {
    s := "hello沙河"
    for i := 0; i < len(s); i++ { //byte
        fmt.Printf("%v(%c) ", s[i], s[i])
    }
    fmt.Println()
    for _, r := range s { //rune
        fmt.Printf("%v(%c) ", r, r)
    }
    fmt.Println()
}

输出：

104(h) 101(e) 108(l) 108(l) 111(o) 230(æ) 178(²) 153() 230(æ) 178(²) 179(³) 
104(h) 101(e) 108(l) 108(l) 111(o) 27801(沙) 27827(河) 

因为UTF8编码下一个中文汉字由3~4个字节组成，所以我们不能简单的按照字节去遍历一个包含中文的字符串，否则就会出现上面输出中第一行的结果。

字符串底层是一个byte数组，所以可以和[]byte类型相互转换。字符串是不能修改的 字符串是由byte字节组成，所以字符串的长度是byte字节的长度。 rune类型用来表示utf8字符，一个rune字符由一个或多个byte组成。

修改字符串

要修改字符串，需要先将其转换成[]rune或[]byte，完成后再转换为string。无论哪种转换，都会重新分配内存，并复制字节数组。

func changeString() {
    s1 := "big"
    // 强制类型转换
    byteS1 := []byte(s1)
    byteS1[0] = 'p'
    fmt.Println(string(byteS1))

    s2 := "白萝卜"
    runeS2 := []rune(s2)
    runeS2[0] = '红'
    fmt.Println(string(runeS2))
}

类型转换

Go语言中只有强制类型转换，没有隐式类型转换。该语法只能在两个类型之间支持相互转换的时候使用。

强制类型转换的基本语法如下：

T(表达式)

其中，T表示要转换的类型。表达式包括变量、复杂算子和函数返回值等.

比如计算直角三角形的斜边长时使用math包的Sqrt()函数，该函数接收的是float64类型的参数，而变量a和b都是int类型的，这个时候就需要将a和b强制类型转换为float64类型。

func sqrtDemo() {
    var a, b = 3, 4
    var c int
    // math.Sqrt()接收的参数是float64类型，需要强制转换
    c = int(math.Sqrt(float64(a*a + b*b)))
    fmt.Println(c)
}

Go语言基础之运算符

运算符用于程序执行时的数学或逻辑运算

运算符

Go语言内置的运算符有：

1.算数运算符
2.关系运算符
3.逻辑运算符
4.位运算符
5.赋值运算符

1.算数运算符

运算符	描述
+	相加
-	相减
*	相乘
/	相除
%	求余

注意： ++（自增）和--（自减）在Go语言中是单独的语句，并不是运算符。

package main
import "fmt"
func main(){
    a:=10
    b:=20
    fmt.Println(a+b) //30
    fmt.Println(a-b) //-10
    fmt.Println(a*b) //200
    fmt.Println(a/b) //0
    fmt.Println(a%b) //10
    a--
    fmt.Println(9)
    a++
    fmt.Println(11)
}

2.关系运算符

运算符	描述
==	检查两个值是否相等，如果相等返回 True 否则返回 False。
!=	检查两个值是否不相等，如果不相等返回 True 否则返回 False。
>	检查左边值是否大于右边值，如果是返回 True 否则返回 False。
>=	检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。
<	检查左边值是否小于右边值，如果是返回 True 否则返回 False。
<=	检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。

package main
import "fmt"
func main(){
    fmt.Println(10 > 2) // true
    fmt.Println(10 < 2) // false
    fmt.Println(10 != 2) // true
    fmt.Println(4 <= 5) //true
    fmt.Println(1 == 1) //true
    fmt.Println(1 != 2) //true
    fmt.Println(2 >= 2) //true
}

3.逻辑运算符

运算符	描述
&&	逻辑 AND 运算符。 如果两边的操作数都是 True，则为 True，否则为 False。
||	逻辑 OR 运算符。 如果两边的操作数有一个 True，则为 True，否则为 False。
!	逻辑 NOT 运算符。 如果条件为 True，则为 False，否则为 True。

package main
import "fmt"
func main(){
    fmt.Println(10>5 && 5<7) // true
    fmt.Println(10>5 || 5>7) //true ,满足其中一个即为true
    fmt.Println(!(10>5)) //false
}

4.位运算符

位运算符对整数在内存中的二进制进行操作

运算符	描述
&	参与运算的两数各对应的二进位相与。 （两位均为1才为1）
|	参与运算的两数各对应的二进位相或。 （两位有一个为1就为1）
^	参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。 （两位不一样则为1）
<<	左移n位就是乘以2的n次方。 “a<<b”是把a的各二进位全部左移b位，高位丢弃，低位补0。
>>	右移n位就是除以2的n次方。 “a>>b”是把a的各二进位全部右移b位。

5.赋值运算符

字面意思理解

运算符	描述
=	简单的赋值运算符，将一个表达式的值赋给一个左值
+=	相加后再赋值
-=	相减后再赋值
*=	相乘后再赋值
/=	相除后再赋值
%=	求余后再赋值
<<=	左移后赋值
>>=	右移后赋值
&=	按位与后赋值
|=	按位或后赋值
^=	按位异或后赋值