变量

变量、储存数据的一种容器

变量的声明方式有几种？

有 三种 第三种、是Go语言在类型推断的基础上增加了一点语法糖、并且第三种只能在 函数内部使用

package main
import "fmt"
func main() {
    // 声明1 指定变量类型
    var name string
    // 声明2 类型推断
    var age = 20
    // 声明3 类型推断
    sex := "男"
    fmt.Println("name: ", name)
    fmt.Println("age: ", age)
    fmt.Println("sex: ", sex)
}

类型推断可以带来哪些好处 ？

不显示的指定变量类型、可以使变量被赋予任何类型的值、 也就是说 变量在初始化时、值和类型由其它程序动态确定

package main
import (
    "flag"
    "fmt"
)
func main() {
    var name = getTheFlag()
    flag.Parse()
    fmt.Printf("Hello, %v!\n", *name)
}
func getTheFlag() *string {
    return flag.String("name", "everyone", "The greeting object.")
}

变量的重声明是什么意思 ？

重声明指的是 对已经声明的变量、重新声明、重新声明是有条件的

1. 由于变量的类型在初始化的时候就已经确定了、所以再次声明时 赋值的类型必须是和原来类型相同
2. 变量的重声明 只会发生在某一个代码块中、否则就是其他情况了
3. 变量的重声明 只会发生在以下情况、其他情况是无法通过编译的
4. 被声明并赋值的变量必须是多个、至少要有一个新的变量、这时候才是重声明

var err error
n, err := io.WriteString(os.Stdout, "Hello, go!\n")

如果一个变量 与其外层代码中的变量 重名了会出现什么状况？

以下代码是可以运行的、原因如下:

1. 使用变量时、会优先查找当前代码块的那个变量、不包含任何子块
2. 如果当前代码块没有这个变量、则会向上层代码块一层层的寻找
3. 如果还是找不到则 编译器会报错

package main
import "fmt"
var block = "package"
func main() {
    block := "function"
    {
        block := "inner"
        fmt.Printf("The block is %s.\n", block)
    }
    fmt.Printf("The block is %s.\n", block)
}
/**
Output:
The block is inner.
The block is function.
*/

怎么判断一个变量的类型 ？

断言判断

package main
import (
    "fmt"
)
func main() {
    var names = []string{"11"}
    if value, ok := interface{}(names).([]string); ok {
        fmt.Println("value: ", value)
    }
}

各基础类型互转

package main
import (
    "fmt"
    "strconv"
)
func main() {
    var i = 10
    fmt.Println("int to string: ", fmt.Sprintf("%d", i))
    i, _ = strconv.Atoi("1000")
    fmt.Println("string to int: ", i)
    var i64 int64 = 100
    tempStr := strconv.FormatInt(i64, 10)
    fmt.Println("int64 to string: ", tempStr)
    i64, _ = strconv.ParseInt("10000", 10, 64)
    fmt.Println("string to int64: ", i64)
    fStr := strconv.FormatFloat(1.27, 'E', -1, 32)
    fmt.Println("float32 to string: ", fStr)
    fStr = strconv.FormatFloat(3.14, 'E', -1, 64)
    fmt.Println("float64 to string: ", fStr)
    // 字符串转 float32时会有问题、所以一般不用float32
    f32, _ := strconv.ParseFloat("3.13", 32)
    fmt.Println("string to float32: ", f32)
    f64, _ := strconv.ParseFloat("3.1416726", 64)
    fmt.Println("string to float64: ", f64)
    fmt.Println("rune to string: ", string([]rune{'\u4F60', '\u597D'}))
    str := string([]byte{'\xe4', '\xbd', '\xa0', '\xe5', '\xa5', '\xbd'})
    fmt.Println("byte to string: ", str)
    fmt.Println("string to byte: ", []byte(str))
}

什么是 别名类型？什么是潜在类型？