切片

1.什么是切片

切片本身不拥有任何数据，它们只是对现有数组的引用。

2.切片的定义

1.方式1：由数组切出来：var 变量名 []元素类型 = 数组名[开始值:结束值]
//1.定义数组
var a [8]int=[8]int{1,2,3,4,5,6,7,8}
//2.定义切片，注意[]中没有数字
var b []int=a[2:6]
fmt.Println(b) // [3 4 5 6]

//更多用法,没有步长
var a [8]int=[8]int{1,2,3,4,5,6,7,8}
b:=a[:4]
fmt.Println(b) //[1 2 3 4]

2.方式2：直接定义不赋值。 注意：切片空值是？nil类型
    var a []int
    fmt.Println(a) //[],注意：切片空值是？nil类型
    if a==nil{
        fmt.Println("我是空的")
    }
    //a[0]=10 //报错
    fmt.Println(a)

方式3：make(类型,切片长度,切片容量)
    var a []int=make([]int,3,4)
    fmt.Println(a) //[0 0 0]

    //切片的长度和容量(len     cap:容量)
    var a [8]int=[8]int{1,2,3,4,5,6,7,8}
    var b []int=a[2:6]
    fmt.Println(len(b)) //4
    fmt.Println(cap(b)) //6

    var a []int=make([]int,3,4)
    fmt.Println(a)
    fmt.Println(len(a)) //3
    fmt.Println(cap(a)) //4
3.切片的常用操作
1.切片的长度和容量(len：长度,cap:容量)
    //var a [8]int=[8]int{1,2,3,4,5,6,7,8}
    //var b []int=a[2:6]
    //fmt.Println(len(b)) //4
    //fmt.Println(cap(b)) //6

        var a []int=make([]int,3,4)
    fmt.Println(a)
    fmt.Println(len(a)) //3
    fmt.Println(cap(a)) //4

2.切片追加值:append(切片名,值1,值2)
    var a [8]int=[8]int{1,2,3,4,5,6,7,8}
    var b []int=a[2:6]
    b = append(b, 9,10)
    fmt.Println(b) //[3 4 5 6 9 10]
        fmt.Println(a) //[1 2 3 4 5 6 9 10]，数组的值也被修改为增加的值
        //当容量到顶，在添加值时
    b = append(b, 11)
    fmt.Println(b) //[3 4 5 6 9 10 11]
    fmt.Println(len(b)) //7
    fmt.Println(cap(b)) //12，容量翻倍
    fmt.Println(a) //[1 2 3 4 5 6 9 10]容量到顶在添加值数组值不在改变

3.修改值：切片名[索引] = 修改值
    var b =make([]int,3,4)
    b[0]=999
    fmt.Println(b) //[999 0 0]
       //超过容量，在修改值时
    var a [6]int=[6]int{1,2,3,4,5,6}
    var b []int=a[1:6]
    fmt.Println(a) //[1 2 3 4 5 6]
    fmt.Println(b) //[2 3 4 5 6]
    b= append(b, 7)
    a[0] = 2
    b[0] = 1
    fmt.Println(a) //[2 2 3 4 5 6]
    fmt.Println(b) //[1 3 4 5 6 7]
总结：追加和修改没超过容量时，一个变另一个跟着变。超过时数组和切片没有关系。

4.切片的函数传递
    var b =make([]int,3,4)
    test(b)
    fmt.Println(b)

 func test(b []int)  {
    b[0]=999
    fmt.Println(b)
}

5.切片的数据结构表示
    var a [][]string=make([][]string,2,3)
    fmt.Println(a) //[[] []]
    fmt.Println(a[0]) //[]

6.多维切片
var a [][]string=make([][]string,2,3)
fmt.Println(a) //[[] []]
fmt.Println(a[0]) //[]
a[0]=make([]string,2,3) //嵌套内的切片在初始化
if a[0]==nil{
   fmt.Println("xxxx")
}

7.多维切片初始化
    var a [][]string=[][]string{{"1","2"},{"3","4"}}
    fmt.Println(a) //[[1 2] [3 4]]
    fmt.Println(len(a)) //2
    fmt.Println(cap(a)) //2
    a[0][1]="999"
    fmt.Println(a) //[[1 999] [3 4]]
8.copy函数：copy(源,目标)
    var a =make([]int,3,10000)
    a[1]=99
    a[2]=888
    fmt.Println(a) //[0 99 888]
    var b =make([]int,2,4)
    fmt.Println(b) //[0 0]
    copy(b,a)
    fmt.Println(b) //[0 99]

3.打散和循环

1.打散       var a =[]int{1,2,4,}
    test1(1,2,3,4)
    test1(a...) //变量名...:相当于打散了
    veggies := []string{"potatoes", "tomatoes", "brinjal"}
    fruits := []string{"oranges", "apples"}
    food := append(veggies, fruits...)
    fmt.Println("food:",food)
func test1(a ...int)  {
    fmt.Println(a)
    fmt.Printf("%T",a)

}

2.循环

//循环多维切片pls := [][]string {   {"C", "C++"},   {"JavaScript"},   {"Go", "Rust"},}fmt.Println(pls)for _,v:=range pls {   for _,v1:=range v{      fmt.Println(v1)   }}

map

1.什么是map

类似于python中的字典，map 是在 Go 中将值（value）与键（key）关联的内置类型。通过相应的键可以获取到值。

2.map的定义和常用方法

1.方式1：var 变量名 map[键值类型]value值类型
        var a map[int]string
    fmt.Println(a) //map[]map的空值是nil类型
        //执行下列if语句
    if a==nil{
        fmt.Println("xxxx")
    }
2. map的初始化
        var a map[int]string=make(map[int]string)
    fmt.Println(a) //map[]此时不是nil类型注意区分
        //不执行下列语句
    if a==nil{
        fmt.Println("xxxxx")
    }
3.赋值：变量名[k] = v,取值：变量名[k],取一个不存在的key值会？返回value值类型的空值
    var a map[int]string=make(map[int]string)
    fmt.Println(a) //map[]
    if a==nil{
        fmt.Println("xxxxx")
    }
        // 赋值
    a[1]="100"
    a[2]="888"
    fmt.Println(a) //map[1:100 2:888]
        //取值
    fmt.Println(a[1]) //100
取值补充：
值,ok:=变量名[k] =>k存在ok为ture,反之为false
    if v,ok:=a[9];ok{
        fmt.Println("=-====",v)
    }else {
        fmt.Println("该值不存在")
    }
4.方式2：定义和初始化
    var a =map[int]string{1:"10",2:"100"}
    fmt.Println(a[1])
5.字典删除元素，内置函数：delete(变量名,k)
    var a =map[int]string{1:"10",2:"100"}
    delete(a,2)
    fmt.Println(a)
6.长度:len(变量名)
var a =map[int]string{1:"10",2:"100"}
fmt.Println(len(a))
7.map循环
var a =map[int]string{1:"10",0:"100",10:"999"}
//map是无序的
    for k,v:=range a{
        fmt.Println(k)
        fmt.Println(v)
    }
8.map的相等性：map 之间不能使用 == 操作符判断，== 只能用来检查 map 是否为 nil，判断两个 map 是否相等的方法是遍历比较两个 map 中的每个元素。我建议你写一段这样的程序实现这个功能
    map1 := map[string]int{
        "one": 1,
        "two": 2,
    }

    map2 := map1

    if map1 == map2 {  //报错
    }

字符串

1.什么是字符串

Go 语言中的字符串是一个字节切片。把内容放在双引号""之间，我们可以创建一个字符串。让我们来看一个创建并打印字符串

2.字符串常用方式

1.统计字节数：len(变量名)。统计字符串长度;utf8.RuneCountInString(变量名)
在go种string类型都是utf-8编码
    name := "Hello World刘清政"
    fmt.Println(len(name)) //20
    fmt.Println(utf8.RuneCountInString(name)) //14

2.字符串循环
方式1：按字节循环
    name := "name刘"
    for i:=0;i<len(name);i++{
        fmt.Println(string(name[i]))
        fmt.Printf("%T",name[i])
        fmt.Println()
    }
方式2：按字符循环
        name := "name刘"
    for _,v:=range name{
        fmt.Println(string(v))
        fmt.Printf("%T",v)
        fmt.Println()
    }

原文地址：https://www.cnblogs.com/tfzz/p/12026617.html