Go 数据类型

概述数组packagemainimport("fmt")//数组：数组是同一类型元素的集合。可以放多个值，但是类型一致，内存中连续存储//Go语言中不允许混合不同类型的元素funcmain(){//1数组的定义,数组的大小，在定义阶段就确定了，而且不能改//定义了一个大小为3的string类型 数组

package mainimport (    "fmt")//数组：数组是同一类型元素的集合。可以放多个值，但是类型一致，内存中连续存储// Go 语言中不允许混合不同类型的元素func main() {    //1 数组的定义,数组的大小，在定义阶段就确定了，而且不能改    //定义了一个大小为3的string类型数组，里面可以放3个字符串    //var names [3]string    //var ages [3]int8    //fmt.Println(ages)    //2 数组赋值    //var ages [3]int8    //ages[0]=99    //ages[2]=88    //fmt.Println(ages)    //fmt.Println(ages[1])    //3 定义并初始化,    //var ages [3]int=[3]int{1,2,3}    //var ages [3]int=[3]int{1,2}    //var ages [3]int=[3]int{}    //var ages=[3]int{}    //ages:=[3]int{1,3,4,7}  //不允许多放    //fmt.Println(ages)    //4 数组定义并初始化的其他（了解）数组只要定义，长度就固定了，。。。,后面放几个值，数组大小是多少    //var ages [9]int=[...]int{1,2,3,4,5,6,7,8}   //不支持这个    //var ages =[...]int{1,2,3,4,5,6,7,8}    //ages :=[...]int{1,2,3,4,8}    //fmt.Println(len(ages))    //5 数组的大小是类型的一部分    //var a [2]int=[2]int{1,2}    //var b [2]int=[2]int{1,3}    //b=a   //如果不是同一种类型，不允许相互赋值    //fmt.Println(b)    //6 数组是值类型    //var a [2]int=[2]int{1,2}    //fmt.Println(a)    //test5(a)  //因为数组是值类型，go函数传参，都是copy传递，如果是值类型，函数内改了，不会影响原来的    //fmt.Println(a)    //7 数组长度  len()  数组长度在定义阶段已经固定    //var a [2]int=[2]int{1,2}    //fmt.Println(len(a))    //8 数组循环    //var a =[...]int{7,4,3,5,6,7}    //fmt.Println(a[99])    //fmt.Println(len(a))    //普通循环    //for i:=0;i<len(a);i++{    //    fmt.Println(a[i])    //}    //通过range来循环  (range不是内置函数，是一个关键字，for，if，else),打印出索引    //for i:=range a{    //    fmt.Println(i)    //}    //如果用一个变量来接收，这个值是可迭代的索引    //如果用两个变量来接收，这两个变量，一个是索引，一个具体的值    //for i,value:=range a{    //    fmt.Println(i)    //    fmt.Println(value)    //}    //把数组循环打印出来    //for _,value:=range a{    //    fmt.Println(value)    //}    // 9 多维数组    //var a [3][3]int  //定义    //a[0][1]=99      //使用    //fmt.Println(a)    //定义并赋初值    //var a [3][3]int=[3][3]int{{1},{1,2,3},{4,4,4}}    //var s =[3][3]string{{"lqz","xxx","yyy"},{},{}}    //fmt.Println(s)    //    ////循环多维数组    //for _,value:=range s{    //    for _,in_value:=range value{    //        fmt.Println(in_value)    //    }    //}    //10 数组定义并指定位置初始化    //var names [100]int=[100]int{10:99,99:99}    //var names [100]int=[100]int{10,11,2,44,99:99,45:88}    //fmt.Println(names)}func test5(a [2]int)  {    a[0]=99    fmt.Println(a)}

 

切片

package mainimport "fmt"//切片:可以变长，//切片是对底层数组的引用//切片的改变会影响底层数组//底层数组的改变，会影响切片//切片的追加可能会触发扩容，一旦扩容，就不再依赖于原来的底层数组了func main() {   //var a []int   //var b [3]int   //fmt.Printf("%T",a)   //fmt.Println()   //fmt.Printf("%T",b)   //切片的初始化，从数组切出来   //var a [10]int   //b是切片   //b:=a[:]   //var b []int=a[:] //从开头切到结尾，赋值给切片b   //fmt.Println(b)   //fmt.Printf("%T",b)   //切片的修改   //b[0]=99   //a[0]=888   //fmt.Println("b-----",b)   //fmt.Println("a-----",a)   //切片的长度和容量   //var a [10]int   ////var b []int=a[3:]   //var b []int=a[3:6]   ////a[3]=999   //b[2]=222   ////fmt.Println(a)   //fmt.Println(b)   //fmt.Println(len(b)) //3   //fmt.Println(cap(b)) //7   //b[3]=999 //不可以 index out of range [3] with length 3   //var c []int=a[8:]   //fmt.Println(len(c)) //3   //fmt.Println(cap(c))   //切片定义的第二种方式，通过make创建   //创建了一个长度为2，容量为4的切片   //var a []int=make([]int,2,4)   //等同于   //b:=[4]int{0,0,0,0}   //a:=b[0:2]   //fmt.Println(len(a))   //fmt.Println(cap(a))   //创建了一个长度为2，容量为2的切片   //var a []int=make([]int,2)   //fmt.Println(len(a))   //fmt.Println(cap(a))   //扩容，追加切片   //var a []int=make([]int,2,4)   //a[0]=111   //a[1]=222   //fmt.Println(a)   ////使用内置函数append   //a=append(a,333,444)   //fmt.Println(a)   //fmt.Println(len(a))   //fmt.Println(cap(a))   //临界点到了   //a=append(a,555)   //fmt.Println(a)  //111 222 333 444 555   //fmt.Println(len(a)) //5   //fmt.Println(cap(a)) //8,自动扩容，在原来容量的基础上扩一倍   ////切片超过了最大容量，底层数组重新创建，重新指向新的数组   //a=append(a,666,777,888,999)   //fmt.Println(a)  //   //fmt.Println(len(a)) //9   //fmt.Println(cap(a)) //16   //切片超过了最大容量，底层数组重新创建，重新指向新的数组   //var a [10]int   //b:=a[8:]   //fmt.Println(b)   //fmt.Println(len(b))   //fmt.Println(cap(b))   //a[9]=999   //fmt.Println(a)   //fmt.Println(b)   //b[0]=888   //b=append(b,666)   //fmt.Println("aaaa",a)   //   //fmt.Println("------")   //fmt.Println(b)   //fmt.Println(len(b))   //fmt.Println(cap(b))   ////改掉数组的最后一个值   //a[9]=1234   //fmt.Println(b)   //b[0]=666   //fmt.Println("----------------")   //fmt.Println(b)   //fmt.Println(a)   //切片的函数传递,切片是引用类型，引用类型的空值是nil   //所有引用类型的空置都是nil   //var a[]int=[]int{1,2,3}   ////长度是3，容量是3   //fmt.Println(len(a))   //fmt.Println(cap(a))   ////fmt.Println(a) //   //if a==nil{   // fmt.Println("空的")   //}else {   // fmt.Println("不是空")   //}   //var a[]int=[]int{1,2,3}   //test(a)   //fmt.Println(a) // 999 2 3  影响原来的   //多维切片   //var a [][]string=[][]string{{"lqz","egon"},{"zs"},{}}   //第一层的切片：长度是3 ，容量是3   //第二层的切片：不确定，根据初始化的情况判断   //fmt.Println(len(a[2]))   //fmt.Println(cap(a[2]))   //var a [][]string=make([][]string,3,4)   //fmt.Println(a)   //if a[2]==nil{   // fmt.Println("空")   //}   //a[2]=make([]string,3,4)   //fmt.Println(a[2][0])   //copy 内置函数   //var a [10000]int   //b:=a[:2]   //b[0]=111   //b[1]=222   //   //var c []int=make([]int,1,4)   ////把b  copy到c身上   //copy(c,b)   //fmt.Println(c)   var c []int=[]int{3,4,5,6,7,8,9,9}   //for i:=0;i<len(c);i++{   // fmt.Println(c[i])   //}   for _,v:=range c{      fmt.Println(v)   }}func test(a []int)  {   a[0]=999   fmt.Println(a)// 999 2 3   a=append(a,777) //如果扩容了，以后再改的，不会影响原来的，如果没扩容，修改会影响原来的   fmt.Println(a) // 999 2 3 777   a[0]=444   fmt.Println(a)// 444 2 3 777}

 

字符串

package main//字符串import (    "fmt")//len字符串看到的是字节长度func printBytes(s string) {    for i:= 0; i < len(s); i++ {        //fmt.Printf("%x ", s[i])        fmt.Println(s[i])    }}func main() {    //name := "Hello World"    //name := "中国"    ////printBytes(name)    //runeLen(name)}func runeLen(s string)  {    //字符长度    //res:=utf8.RuneCountInString(s)    //fmt.Println(res)    //for i:=0;i<utf8.RuneCountInString(s);i++{    //    fmt.Println((s[i]))    //}}

 

maps

package mainimport "fmt"//maps 字典,存储key value的的数据结构func main() {    //1 定义    //int是key值类型，string是value类型    //引用类型，空值是nil    //var m map[int]string    //if m==nil{    //    fmt.Println("空")    //}    //定义并初始化    //var m map[int]string= map[int]string{1:"lqz",2:"egon"}    //var m = map[int]string{1:"lqz",2:"egon"}    m:=map[int]string{199:"lqz",200:"egon"}    fmt.Println(m)    //添加元素    m[1]="zhangsan"    fmt.Println(m)    //获取元素    //fmt.Println(m[199])    //获取的元素不在map中，结果取决于value值的类型    //fmt.Println(m[2])    //m1:=map[int]int{1:1}    //fmt.Println(m1[2])    //判断元素是否再map中    //m1:=map[int]int{1:111}    ////value是key对应的值，如果不存在，为value的空值    ////flag 是个bool值，如果不存在，是false，如果存在是true    //value,flag:=m1[1]    //fmt.Println(value)    //fmt.Println(flag)    // 循环map （python字典有序？3.6以后有序了）    /*    python字典的底层结构：https://www.cnblogs.com/xiaoyuanqujing/articles/12008689.HTML    在Python 3.5（含）以前，字典是不能保证顺序的，键值对A先插入字典，键值对B后插入字典，但是当你打印字典的Keys列表时，你会发现B可能在A的前面。    但是从Python 3.6开始，字典是变成有顺序的了。你先插入键值对A，后插入键值对B，那么当你打印Keys列表的时候，你就会发现B在A的后面    [key,key,key]     */    //go语言的map是无序的    //m1:=map[int]int{1:111,4:444,8:888}    //m1[5]=999    //m1[3]=888    //for k,v:=range m1{    //    fmt.Println("k是",k,"v是",v)    //}    //删除元素    //m1:=map[int]int{1:111,4:444,8:888}    //delete(m1,4)    //fmt.Println(m1)    //map的长度    //fmt.Println(len(m1))    //fmt.Println(cap(m1))    //使用make初始化map,数字不用填，这个数字其实是底层数组的大小    //m2:=make(map[int]int)    //m2[1]=11    //m2[2]=222    //m2[3]=333    //m2[4]=444    //m2[5]=555    //fmt.Println(m2)    //map 是引用类型    //m2:=make(map[int]int)    //m2[1]=11    //m2[2]=222    //m2[3]=333    //m2[4]=444    //    //test6(m2)    //fmt.Println(m2)    //map 之间不能使用 ==  *** 作符判断，== 只能用来检查 map 是否为 nil    //m2:=make(map[int]int)    //m2[1]=11    //    //m3:=make(map[int]int)    //m3[1]=11    //    ////两个map之间不允许直接比较    //if m2==nil{    //    //}}func test6(m map[int]int)  {    m[1]=999}

 

指针

package mainimport "fmt"//指针：变量，存内存地址//指针是一种存储变量内存地址的变量。//取地址符号 &  ，写在一个变量前，表示取该变量的地址//* 放在类型前，表示该类型的指针//* 放在变量前，表示解引用（取该地址对应的值）func main() {   //var a int=10   ////指针类型的变量   ////b:= &a   //var b *int=&a   ////fmt.Println(b)   //   ////c:=&b   //var c **int=&b   //   //var d ***int=&c   //fmt.Println(d)   //   //fmt.Println(***d)   //指针的0值：<nil>，引用类型   //var a *int   //fmt.Println(a)   //指针的解引用   //s:="lqz"   ////s_p:=&s   //var s_p *string=&s   //fmt.Println(*s_p)   //向函数传递指针参数   //var a =10   //test2(&a)   //fmt.Println(a)   //s:="lqz"   //test3(&s)   //fmt.Println(s)   //不要向函数传递数组的指针，而应该使用切片   //var a=[4]int{6,8,9}  //6,8,9,0   //test4(&a)  //取了数组的地址，传入了test4   //fmt.Println("-----",a)   //   //test5(a[:])   //fmt.Println("-----",a)   //指针不支持运算（c语言指针支持运算）   //var a =[3]int{9,7,6}   //b:=&a   ////b++  //不支持   //fmt.Println(b)   //  指针数组和数组指针   var a *[3]int    //指向数组的指针  指向这种数组的指针[3]int       a=&[3]int{1,2,43}   fmt.Println(a)   var b [3]*int  //大小为3，内部放int类型的指针      a1,a2,a3:=10,20,30   b[0]=&a1   b[1]=&a2   b[2]=&a3   fmt.Println(b)}func test4(a *[4]int)  {   //(*a)[0]=999   //解引用，改值   a[0]=999   //等同于上面，数组的指针不需要解引用再通过索引取值，直接通过索引取值即可   fmt.Println(a)}func test5(a []int)  {   a[0]=999   fmt.Println(a)}func test2(a *int)  {   fmt.Println(a)//地址   fmt.Println(*a) //解引用   10   *a=100}func test3(a *string)  {   fmt.Println(*a)   *a="ssssss"}

 

 

 

 

 

 

 

 

 

  总结

以上是内存溢出为你收集整理的Go 数据类型全部内容，希望文章能够帮你解决Go 数据类型所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。