变量知识点

• 定义以及初始化变量

     // 1.定义一个变量

     var num int
     num = 666
     // 注意点: 在Go语言中, 输出整型只能使用%d, 不能使用%i
     fmt.Printf("%d\n", num)


     // 2.先定义再初始化
    var num int
    num = 888
    fmt.Printf("%d\n", num)
    var num int
    num = 10
    fmt.Printf("%d\n",num)

    // 3.定义的同时初始化
    var num int = 999
    fmt.Printf("%d", num)
    var num int = 10
    fmt.Printf("%d\n",num)

    // 4.定义的同时初始化, 并省略数据类型
    var num  = 999
    fmt.Printf("%d\n", num)
    // 在Go语言中, 可以利用%T输出变量的数据类型
    fmt.Printf("%T\n", num)
    var num = 10
    fmt.Printf("%d\n",num)

    // 5.定义的同时初始化, 并省略数据类型和var
    :=做了两件事情 , 1.会先定义一个变量 2.给定义的变量赋值
    在Go语言开发中非常非常非常常用
    num := 666
    fmt.Printf("%d\n", num)
    num := 10
    fmt.Printf("%d\n",num)

    // 6.:=注意点
    var num := 666 // 语法错误
    num int := 666 // 语法错误
    fmt.Printf("%d\n", num)

    var num int = 666
    // var num int
    // num = 888
    num := 888 // 重复定义
    fmt.Printf("%d\n", num)

• 变量的连续定义

     // 1.通过逗号定义多个变量

     var a, b, c int
     a = 123
     b = 456
     c = 789
     fmt.Printf("%d,%d,%d\n", a, b, c)


     // 2.通过变量组定义多个变量

     var(
        a int
        b int
        c int
     )
    a = 123
    b = 456
    c = 789
    fmt.Printf("%d,%d,%d\n", a, b, c)


     // 3.同时定义多个变量, 并且同时初始化
     var a, b, c int = 10, 20, 30
     var a, b, c = 10, 20, 30
    a, b, c := 10, 20, 30
    fmt.Printf("%d,%d,%d\n", a, b, c)


    // 4.同时定义多个变量, 并且同时初始化
    var(
        a int = 10
        b int = 20
        c int = 30
    )

    var(
        a  = 10
        b  = 20
        c  = 30
    )
    fmt.Printf("%d,%d,%d\n", a, b, c)

• 局部变量与全局变量的关系

  • 1.什么是局部变量?
    1.1在C语言中写在{}中或者函数中或者函数的形参, 就是局部变量
    1.2Go语言中的局部变量和C语言一样

  • 2.什么是全局变量?
    2.1在C语言中写在函数外面的就是全局变量
    2.2Go语言中的全局变量和C语言一样

  • 3.局部变量和全局变量的作用域
    3.1在C语言中局部变量的作用域是从定义的那一行开始, 直到遇到}结束或者遇到return为止
    3.2Go语言中局部变量的作用域和C语言一样
    3.3在C语言中全部变量的作用域是从定义的那一行开始, 直到文件末尾为止
    3.4Go语言中的全局变量, 只要定义了, 在定义之前和定义之后都可以使用

  • 4.局部变量和全局变量的生命周期
    4.1在C语言中局部变量, 只有执行了才会分配存储空间, 只要离开作用域就会自动释放, C语言的局部变量存储在栈区
    4.2Go语言局部变量的生命周期和C语言一样
    4.3在C语言中全局变量, 只要程序一启动就会分配存储空间, 只有程序关闭才会释放存储空间, C语言的全局变量存储在静态区(数据区)
    4.4Go语言全局变量的生命周期和C语言一样

  • 5.局部变量和全局变量的注意点
    5.1在C语言中相同的作用域内, 不能出现同名的局部变量
    5.2Go语言和C语言一样, 相同的作用域内, 不能出现同名的局部变量
    5.3在C语言中相同的作用域内, 可以出现同名的全局变量
    5.4在Go语言中相同的作用域内, 不能出现同名的全局变量

  • 6.特殊点
    6.1在C语言中局部变量没有初始化存储的是垃圾数据, 在Go语言中局部变量没有初始化, 会默认初始化为0
    6.2在C语言中全局变量没有初始化存储的是0, Go语言和C语言一样
    6.3在Go语言中, 如果定义了一个局部变量, 但是没有使用这个局部变量, 编译会报错
    6.4在Go语言中, 如果定义了一个全局变量, 但是没有使用这个全局变量, 编译不会报错

• 变量的一些注意点

  • 1.相同的作用域内, 无论是全局变量还是局部变量, 都不能出现同名的变量
    2.变量离开作用域就不能使用
    3.局部变量如果没有使用, 编译会报错, 全局变量如果没有使用, 编译不会报错
    4.:=只能用于局部变量, 不能用于全局变量
    5.:=如果用于同时定义多个变量, 会有退化赋值现象

//退化赋值
num := 123
// 如果通过:=定义多个变量, 但是多个变量中有的变量已经在前面定义过了, 那么只会对没有定义过的变量执行:=
// 而定义过的变量只执行=操作
num, value := 456, 789
fmt.Printf("%d, %d", num, value)

数据类型转换

• 在 GO 语言中,数据类型转换只有显示类型转换

    // 1.没有隐式转换, 会报错
    var num int = 3.14

    // 2.不能对一个常量进行强制转换
    var num int = int(3.14)

    // 3.正确的做法
    var num float64 = 3.14
    var value int = int(num)
    fmt.Printf("%d\n", value)

    // 4.注意点:
    // 4.1在Go语言中数据类型必须一模一样, 才能直接赋值
   var num int32 = 666
   var value int64 = int64(num)
   //var value int32 = num
   fmt.Printf("%d\n", value)

   // 4.2特殊情况
   byte --> uint8
   var ch byte = 'a'
   var num uint8 = ch
   fmt.Printf("%c\n", num)

   // rune --> int32
   var ch rune = '李'
   var num int32 = ch
   fmt.Printf("%c\n", num)

   // 4.3bool类型不能强制转换为整型
   var flag bool = false
   var num int = int(flag)
   fmt.Printf("%d\n", num)

   // 5.整型也可以通过T(v)转换为字符串类型, 但是在企业开发中不要这么干
   var num int = 97
   var str string = string(num)
   fmt.Printf("%s\n", str)

• 数值类型转换为字符串类型,2种方式: 1) strconv.FormatXxx() ; 2) strconv.Itoa
  1.strconv.FormatXxx()

      var num int = 9
     //第一个参数: 需要转换的整数, 必须是int64类型的
     //第二个参数: 转换为多少进制的字符串
     var str string = strconv.FormatInt(int64(num), 10) //  "9"
     var str string = strconv.FormatInt(int64(num), 2)  // "1001"
     fmt.Printf("%s\n", str)

     var num float32 = 3.1234567890123456789
     // 第一个参数: 需要转换的小数, 必须是float64类型的
     // 第二个参数: 按照什么格式转换 'f'小数格式 'e' 指数的格式
     // 第三个参数: 保留多少位小数, 传入-1按照原始类型的精度保留
     // 第四个参数: 原始类型的标志  float32 --> 32  float64 --> 64
     var str string = strconv.FormatFloat(float64(num), 'f', -1, 32) // "3.1234567"
     var str string = strconv.FormatFloat(float64(num), 'f', -1, 64) // "3.123456789012345"
    var str string = strconv.FormatFloat(float64(num), 'f', 2, 32)  // "3.12"
    fmt.Printf("%s\n", str)

    var flag bool = false
    var str string = strconv.FormatBool(flag) // "false"
    fmt.Printf("%s\n", str)

2.strconv.Itoa

    var num int = 1001
    var str string = strconv.Itoa(int(num))
    fmt.Printf("%s\n", str)

• 字符串类型转换为数值类型: 1) strconv.ParseXxx() ; 2) strconv.Atoi()
  1.strconv.ParseXxx()

     var str string = "1001"
     // 第一个参数: 需要转换的字符串
     // 第二个参数: 被转换的字符串保存的整数是多少进制的
     // 第三个参数: 期望转换为多少位的整数(不一定准确), 换句话说就是要转换为多少位整数
     // 注意点: 如果被转换的字符串超出了指定的长度会报错
     // 返回值:
     // 返回值的第一个: 转换之后的数值, 是int64类型
     // 返回值的第二个: 如果转换成功返回nil, 如果转换失败就不是nil
     // int8   -128~127
     //num, err := strconv.ParseInt(str, 10, 8)
     num, err := strconv.ParseInt(str, 2, 8)
     if err != nil{
        fmt.Printf("转换失败\n")
     }else{
        fmt.Printf("%d\n", num)
        fmt.Printf("%T\n", num)
     }

    var str string = "3.1234567890123456789"
    // 第一个参数: 需要转换的字符串
    // 第二个参数: 要将字符串中的小数转换为单精度还是双精度, 单精度传入32, 双精度传入64
    // 返回值:
    // 第一个返回值: 转换之后的小数, float64类型
    // 第二个返回值: 转换成功返回nil, 转换失败不为nil
    //num, err := strconv.ParseFloat(str, 32)
    num, err := strconv.ParseFloat(str, 64)
    if err != nil{
        fmt.Printf("转换失败\n")
    }else{
        //fmt.Printf("%f\n", num)
        fmt.Println(num)
        fmt.Printf("%T\n", num)
    }

     var str string = "false"
     flag, err := strconv.ParseBool(str)
    if err != nil{
        fmt.Printf("转换失败\n")
    }else{
        // 注意点: 在Go语言中%t输出布尔类型
        fmt.Printf("%t\n", flag)
        fmt.Printf("%T\n", flag)
    }

2.strconv.Atoi()

    var str string = "1001"
    num, err := strconv.Atoi(str)
    if err != nil{
        fmt.Printf("转换失败\n")
    }else {
        fmt.Printf("%d\n", num)
    }

常量知识点

• 1.在C语言中可以通过const来定义常量
• 2.在Go语言中一样
• 3.格式:
  const 变量名称 数据类型 = 值;
• 注意点:
  • 1. 数据类型可以省略, 但是const不能省略

  • 2.定义常量不能使用 := , := 是专门用于定义局部变量的

  • 3.定义局部变量没有使用, 编译会报错, 定义全局变量和常量没有使用, 不会报错

  • 4.在Go语言中可以连续定义多个变量, 所以也可以连续定义多个常量

格式:
    const 变量名称1, 变量名称2 数据类型 = 值1, 值2;
    const(
      变量名称1 数据类型 = 值1
      变量名称2 数据类型 = 值2
    )

• 在常量组中, 如果常量没有赋值, 那么默认值就是上一行的取值

    const num1,num2,num3 = 1,2,3
    const(
        num5 = 4
        num4 = 5
        num6 = 6
    )
    fmt.Println(num5,num4,num6)
     // 1.定义单个常量
    const num int  =  666
    const num  =  666
    const num  =  666
    //num = 789
    fmt.Printf("%d\n", num)

    // 2.定义多个常量
    const a, b, c int  = 10, 20, 30
    const a, b, c  = 10, 20, 30
    a = 666
    b = 777
    c = 888
    
    //3.常量组的注意点
    //在常量组中, 如果常量没有赋值, 那么默认值就是上一行的取值
    const(
        a  = 666
        b  = 789
        c
    )
    fmt.Printf("%d, %d, %d", a, b, c)

• 枚举常量: 定义方式是使用 const

  • 1.C语言中的枚举本质就是一个整数
    enum　枚举名　{ 枚举元素1 = 值, 枚举元素2 = 值, …… };

  • 2.Go语句中没有明确枚举的固定写法, 但是在企业开发中一般都会常量组的形式来表示枚举
    const( 枚举元素 = 值 枚举元素 = 值 )

    // 1.iota迭代器, 默认会从0开始递增

    const(
        male = iota
        female = iota
        yao = iota
    )
    // 2.只要常量组中出现了iota, 该常量组中后续的常量都会一次递增1
    const(
        male = iota
        female
        yao
    )
    // 3.如果常量组中的iota被打断了, 那么就不会继续递增了, 会按照常量组的默认方式处理(上一行的值)
    const(
        male = iota
        female = 666
        yao
    )

    // 4.如果常量组中的iota被打断了, 但是后续又被回复了, 那么前面有多少行就会递增多少
    const(
        male = iota
        female = 666
        yao = iota
    )

输入输出函数

• 与 C 语言类似,不做赘述.