2. golang数据类型

刺骨的言语ヽ痛彻心扉 2023-06-27 12:47 16阅读 0赞

## **一、命令行运行go** ##

一个文件夹里的文件只能有一个main函数 、也就是入口函数

命令：go build xxx.go :编译   xxx.exe:运行

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA_size_16_color_FFFFFF_t_70][]

Go  run  xxx.go //不生成程序、直接运行

## **二、数据类型和命令规则** ##

1、命令规范：字母、下划线、数字

不能以数字开头、名字不能是关键字、区分大小写

2、关键字：

下面列出GO语言的关键字或保留字：

<table style="width:377.7pt;"> 
 <tbody> 
 <tr> 
 <td style="border-color:#C0C0C0;width:76.25pt;"> break </td> 
 <td style="border-color:#C0C0C0;width:80.5pt;"> default </td> 
 <td style="border-color:#C0C0C0;width:72.35pt;"> func </td> 
 <td style="border-color:#C0C0C0;width:76.6pt;"> interface </td> 
 <td style="border-color:#C0C0C0;width:72pt;"> select </td> 
 </tr> 
 <tr> 
 <td style="border-color:#C0C0C0;width:76.25pt;"> case </td> 
 <td style="width:80.5pt;"> defer </td> 
 <td style="width:72.35pt;"> go </td> 
 <td style="width:76.6pt;"> map </td> 
 <td style="width:72pt;"> struct </td> 
 </tr> 
 <tr> 
 <td style="border-color:#C0C0C0;width:76.25pt;"> chan </td> 
 <td style="width:80.5pt;"> else </td> 
 <td style="width:72.35pt;"> goto </td> 
 <td style="width:76.6pt;"> package </td> 
 <td style="width:72pt;"> switch </td> 
 </tr> 
 <tr> 
 <td style="border-color:#C0C0C0;width:76.25pt;"> const </td> 
 <td style="width:80.5pt;"> fallthrough </td> 
 <td style="width:72.35pt;"> if </td> 
 <td style="width:76.6pt;"> range </td> 
 <td style="width:72pt;"> type </td> 
 </tr> 
 <tr> 
 <td style="border-color:#C0C0C0;width:76.25pt;"> continue </td> 
 <td style="width:80.5pt;"> for </td> 
 <td style="width:72.35pt;"> import </td> 
 <td style="width:76.6pt;"> return </td> 
 <td style="width:72pt;"> var &nbsp; </td> 
 </tr> 
 </tbody> 
</table>

除了以上介绍的这些关键字，Go 语言还有 36 个预定义标识符，其中包含了基本类型的名称和一些基本的内置函数，见下表：

<table> 
 <tbody> 
 <tr> 
 <td style="border-color:#C0C0C0;width:42.8pt;"> append </td> 
 <td style="border-color:#C0C0C0;width:39.6pt;"> bool </td> 
 <td style="border-color:#C0C0C0;width:41.2pt;"> byte </td> 
 <td style="border-color:#C0C0C0;width:42.85pt;"> cap </td> 
 <td style="border-color:#C0C0C0;width:37.15pt;"> close </td> 
 <td style="border-color:#C0C0C0;width:45.55pt;"> complex </td> 
 <td style="border-color:#C0C0C0;width:53.45pt;"> complex64 </td> 
 <td style="border-color:#C0C0C0;width:57.35pt;"> complex128 </td> 
 <td style="border-color:#C0C0C0;width:40.35pt;"> uint16 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#C0C0C0;width:42.8pt;"> copy </td> 
 <td style="width:39.6pt;"> false </td> 
 <td style="width:41.2pt;"> float32 </td> 
 <td style="width:42.85pt;"> float64 </td> 
 <td style="width:37.15pt;"> imag </td> 
 <td style="width:45.55pt;"> int </td> 
 <td style="width:53.45pt;"> int8 </td> 
 <td style="width:57.35pt;"> int16 </td> 
 <td style="width:40.35pt;"> uint32 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#C0C0C0;width:42.8pt;"> int32 </td> 
 <td style="width:39.6pt;"> int64 </td> 
 <td style="width:41.2pt;"> iota </td> 
 <td style="width:42.85pt;"> len </td> 
 <td style="width:37.15pt;"> make </td> 
 <td style="width:45.55pt;"> new </td> 
 <td style="width:53.45pt;"> nil </td> 
 <td style="width:57.35pt;"> panic </td> 
 <td style="width:40.35pt;"> uint64 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#C0C0C0;width:42.8pt;"> print </td> 
 <td style="width:39.6pt;"> println </td> 
 <td style="width:41.2pt;"> real </td> 
 <td style="width:42.85pt;"> recover </td> 
 <td style="width:37.15pt;"> string </td> 
 <td style="width:45.55pt;"> true </td> 
 <td style="width:53.45pt;"> uint </td> 
 <td style="width:57.35pt;"> uint8 </td> 
 <td style="width:40.35pt;"> uintptr </td> 
 </tr> 
 </tbody> 
</table>

3、变量：程序运行期间、可以改变的量。

Var  a  int    声明格式：  var   变量名  类型、

变量声明必须要使用

只是声明没有初始化的变量、默认值为0

同一个大括号里、声明的变量名是唯一的

4、变量初始化：声明变量同时赋值 var b int = 10

5、自动推导：自动推导类型、必须初始化、通过初始化的值确定类型

c:=20  fmt.Printf(“c type is %T\\n”, c)

:= 、自动推导、先声明变量b、再给b赋值20

6、Printf和Println区别

a  := 10

fmt.Println(“a=”,a) //一段一段处理、自动加换行

fmt.Printf(“a=%d\\n”,a)//格式化输出、把a的内容放在%d的位置 \\n代表换行符

7、多重赋值和匿名变量

a,b := 10,20
    
             a,b = b,a //交换2个变量的值
    
             fmt.Printf(“a = %d,b = %d\n”, a,b)//多重赋值
    
             i = 10
    
             j = 20
    
             tmp,_ = i,j
    
             fmt.Println(“tmp=”,tmp) //匿名变量

8、常量：程序运行期间、不可以改变的量、关键字const

Const a int = 20 //常量不可以修改
    
    Const b = 10 //没有使用:= 、可以自动推导类型
    
    fmt.Printf(“b type is %T\n”, b)
    
    fmt.Println(“b=”,b)

9、多个变量或常量定义：

package main
    
    import "fmt"
    
    func main() {
    
        //不同类型变量可常量声明
    
        //    var a int = 1
    
        //    var b float64 = 3.33
    
        var (
    
            a int     = 2
    
            b float64 = 9.9
    
        )
    
    
    
        fmt.Println("a=", a)
    
        fmt.Println("b=", b)
    
    
    
        //    const i int = 10
    
        //    const j float64 = 9.83
    
        const (//可以去掉int float64、会自动推导类型
    
            i int     = 20
    
            j float64 = 8.88
    
        )
    
        fmt.Println("i=", i)
    
        fmt.Println("j=", j)
    
    }

10、枚举\_iota

package main
    import "fmt"
    func main() {
        //1、iota常量自动生成器、每个一行、自动累加1
        //2、iota给量赋值使用
        const (
            a = iota //0
            b = iota //1
            c = iota //2
        )
        fmt.Printf("a=%d, b= %d, c = %d\n", a, b, c)
        //显示：a=0, b= 1, c = 2
        //3、iota遇到const、重置为0
        const d = iota
        fmt.Printf("d = %d\n", d) //显示d = 0
    
        //4、可以只写一处iota
        const (
            a1 = iota //0
            b1
            c1
        )
        fmt.Printf("a1=%d,b1=%d,c1 = %d\n", a1, b1, c1)
        //显示:a1=0,b1=1,c1 = 2
    
        //5、如果是同一行、值 都是一样的
        const (
            i          = iota
            j1, j2, j3 = iota, iota, iota
            k          = iota
        )
        fmt.Printf("i=%d,j1=%d,j2=%d,j3=%d,k=%d\n", i, j1, j2, j3, k)
        //显示：i=0,j1=1,j2=1,j3=1,k=2
    }

## **三、数据类型：基本数据类型和复合数据类型** ##

1、基础数据类型：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA_size_16_color_FFFFFF_t_70 1][]

2、Bool 布尔类型：

package main
    
    import "fmt"
    func main() {
        //1、声明变量、没有初始化、初始值为false
        var a bool
        fmt.Println("a1 = ", a) //显示：a1 =  false
    
        a = true
        fmt.Println("a =", a) //显示：a = true
    
        //2、自动推导类型
        var b = false
        fmt.Println("b =", b) //显示 b = false
    
        c := false
        fmt.Println("c = ", c) //显示 c =  false
    }

3、整型：

Var  I  int32//声明变量
    
    I = 123
    
    Fmt.Println(“I = ”,i)
    
    J := 64 //自动推导
    
    Fmt.Println(“j =”,j)

4、浮点型：

package main
    
    import "fmt"
    
    func main() {
        //1、声明变量
        var f1 float32
        f1 = 3.1415926
        fmt.Println("f1 = ", f1) //显示：f1 =  3.1415925
    
        //2、自动推导类型 、float64比float32更准确
        f2 := 3.141592612
        fmt.Printf("f2 type is %T\n", f2) //显示：f2 type is float64
        fmt.Println("f2 =", f2)           //显示：f2 = 3.141592612
    }

5、字符类型：

package main
    
    
    
    import "fmt"
    
    
    
    func main() {
    
        var str byte
    
        str = 97
    
        fmt.Println("str = ", str)      //显示：str =  97
    
        fmt.Printf("%c,%d\n", str, str) //显示：a,97
    
        //格式化输出、%c以字符方式打印、%d以整型方式打印
    
    
    
        str = 'a'                        //字符、单引号
    
        fmt.Printf("%c, %d\n", str, str) //显示：a, 97
    
    
    
        //大小写转换
    
        fmt.Printf("大写：%d, 小写： %d\n", 'A', 'a')
    
        fmt.Printf("大写转小写：%c\n", 'A'+32)
    
        fmt.Printf("小写转大写：%c\n", 'a'-32)
    
    //    大写：65, 小写： 97
    
    //    大写转小写：a
    
    //    小写转大写：A
    
    }

6、字符串类型：

package main
    
    import "fmt"
    
    func main() {
        var str string //声明变量
        str = "This is a String"
        fmt.Println("str=", str) //显示：str= This is a String
    
        //自动推导类型
        str1 := "This is a str"
        fmt.Printf("Str类型是%T\n", str1) //显示：Str类型是string
    
        //内建函数、len()字符串长度、包括空格
        fmt.Println("len测试长度：", len(str1))//显示：len测试长度： 13
    }

7、字符和字符串区别：

这个和java定义是一样的。

字符：是由单个字符给成。单引号

字符串：多个字符、双引号、隐藏了一个结束符：’\\0’

Var str string = “a”  //由’a’和’\\0’组成了一个字符串

package main
    
    import "fmt"
    
    func main() {
        var ch byte
        var str string
    
        ch = 'a'
        str = "a"
        fmt.Println("ch=", ch)//ch= 97
        fmt.Println("str=", str)//str= a
    
        str = "abcde"//如果想取出字符串的摸个字符、从0开始操作
    fmt.Printf("str[0]= %c, str[1]= %c\n", str[0], str[1])
    //str[0]= a, str[1]= b
    }

8、复数类型：

package main
    
    import "fmt"
    
    func main() {
        var t complex128       //声明
        t = 2.2 + 9.99i        //赋值
        fmt.Println("t = ", t) //显示：t =  (2.2+9.99i)
    
        //自动推导类型
        t2 := 4.4 + 9.99i
        
        //通过内建函数、取实部和虚部
        fmt.Println("real(t2) = ", real(t2), "imag(t2)", imag(t2))
        //显示：real(t2) =  4.4 imag(t2) 9.99
    }

9、格式化：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA_size_16_color_FFFFFF_t_70 2][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA_size_16_color_FFFFFF_t_70 3][]

10、变量的输入：

package main
    
    import "fmt"
    
    func main() {
        var a int //声明变量
        fmt.Printf("请输入变量a:")
    
        //阻塞等待用户的输入
        //fmt.Scanf("%d", &a)
        fmt.Scan(&a) //简写
        fmt.Println("a=", a)
    }
    //    请输入变量a:444
    
    //    a= 444

11、类型转换：

package main
    
    import "fmt"
    
    func main() {
    
        //注：不兼容类型是不能相互转换的
        var ch byte
        ch = 'a' //字符类型
        var t int
        t = int(ch)          //字符转换、把ch的值取出来、转成int再给t赋值
        fmt.Println("t=", t) //显示：t= 97
    }

12、类型别名：

package main
    
    import "fmt"
    
    func main() {
    
        type bigInt int64
        var a bigInt
        fmt.Printf("a type is %T\n", a) //显示： type is main.bigInt
    
        type (
            long int64
            char byte
        )
        var b long = 119
        var chr char = 'b'
        fmt.Printf("b=%d, chr = %c\n", b, chr)
        //显示：b=119, chr = b
    }

13、运算符：

算术运算符：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA_size_16_color_FFFFFF_t_70 4][]

![2020010621182756.png][]

关系运算符：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA_size_16_color_FFFFFF_t_70 5][]

逻辑运算符：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA_size_16_color_FFFFFF_t_70 6][]

位运算符：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA_size_16_color_FFFFFF_t_70 7][]

赋值运算符：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA_size_16_color_FFFFFF_t_70 8][]

其他运算符：

![20200106211832235.png][]

运算符优先级：

Go语言中：一元运算符拥有最高优先级、二元运算符的运算方向均从左向右

![2020010621183284.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA_size_16_color_FFFFFF_t_70 9][]

14、流程控制：

格式：if支持一个初始化语句（也可以不写在这）、初始化后面就条件

If  a:=10; a == 10\{

\}else if a>10\{

\}else\{

Switch  num := 1;num \{//支持一个初始化语句

case 1:

fmt.Println()

break;//不写默认就包含

fallthrough //不跳出switch语句、后面的无条件执行

case 2:

fmt.Println()

break;//不写默认就包含

fallthrough //不跳出switch语句、后面的无条件执行

case 3:

fmt.Println()

break;//不写默认就包含

fallthrough //不跳出switch语句、后面的无条件执行

default:

fmt.Println()

score :=80
    
    switch {
    
             case score > 90;
    
             fmt.Println()
    
             case score > 80;
    
             fmt.Println()
    
             case score > 70;
    
             fmt.Println()
    
             default:
    
             fmt.Println()
    
    }

for 初始化条件;  判断条件; 条件变化\{

15、迭代：range

package main
 
 import "fmt"
 
 func main() {
     str := "abcd"
     //通过for打印每个字符
     for i := 0; i < len(str); i++ {
         fmt.Printf("str[%d]=%c\n", i, str[i])
     }
     //    str[0]=a
     //    str[1]=b
     //    str[2]=c
     //    str[3]=d
 
     //迭代打印每个元素、默认返回2个值、一个是元素的位置、一个是元素本身
     for i, data := range str {
         fmt.Printf("str[%d] = %c\n", i, data)
     }
     //    str[0] = a
     //    str[1] = b
     //    str[2] = c
     //    str[3] = d
 
     for i := range str {
         fmt.Printf("str[%d] = %c\n", i, str[i])
     }
     //    str[0] = a
     //    str[1] = b
     //    str[2] = c
     //    str[3] = d
 
     for i, _ := range str {
         fmt.Printf("str[%d] = %c\n", i, str[i])
     }
     //    str[0] = a
     //    str[1] = b
     //    str[2] = c
     //    str[3] = d
 }

16、Break和continue

Break用于for、switch、select 而continue仅能用于for循环

Break:跳出循环、如果嵌套多个、跳出最近的那个内循环

Continue:路出本次循环、下一次继续

17、goto

goto end//goto 无条件跳转到标签end

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200106211831848.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200106211825834.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200106211833573.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200106211832614.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200106211832130.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA==,size_16,color_FFFFFF,t_70
[2020010621182756.png]: https://img-blog.csdnimg.cn/2020010621182756.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200106211825441.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200106211827174.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200106211832543.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200106211832624.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA==,size_16,color_FFFFFF,t_70
[20200106211832235.png]: https://img-blog.csdnimg.cn/20200106211832235.png
[2020010621183284.png]: https://img-blog.csdnimg.cn/2020010621183284.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20200106211832236.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nzd3F6eA==,size_16,color_FFFFFF,t_70