Go 基础入门

1. 变量

Go 语言是静态类型语言，由于编译时，编译器会检查变量的类型，所以要求所有的变量都要有明确的类型
。

变量在使用前，需要先声明。声明类型，就约定了你这个变量只能赋该类型的值。

1.1 变量声明

格式：var 变量名 类型 = 值

声明方式大概有四种，若声明时没有初始化，那么其默认值为该数据类型的 0 值，比如： string 类型就初始化为空字符串，int 类型就初始化为0，float 就初始化为 0.0，bool 类型就初始化为 false，指针类型就初始化为 nil：

1、一行声明一个变量，并初始化值

var name string = "变量"

2、一次声明多个变量

var (
		age int
		gender string
	)

3、声明和初始化一个变量

使用 :=（让编译器自动根据右侧的值推测出左侧的变量数据类型），这种方法只能用于函数内部

name := "Go 变量"

// 等同
var name string = "Go 变量"

4、声明和初始化多个变量

name, age := "rose", 18

// 可以用来做变量交换
var a int = 100
var b int = 200
b, a = a, b

1.2 全局变量和局部变量

根据变量位置可将变量划分为全局变量和全局变量，Go 变量有作用域之分，每个大括号就是一个作用域，每个作用域都可以有相应的局部变量。

全局变量

全局可使用

package main

import "fmt"

// 声明全局变量
var country = "中国"

func main() {
    fmt.Println(country)
    country = "China"
    fmt.Println(country)
}

输出：

中国
China

注意：全局变量首字母小写，只能用于当前包中，大写可用于其他包文件，即外部可使用

局部变量

仅对应作用域可使用

package main

import "fmt"

func main() {
    // 声明局部变量，在当前函数中使用
    var country = "China"
    fmt.Println(country)

    if true {
        // 声明局部变量，仅在 if 中使用
        var age = 18
        fmt.Println(age)
        fmt.Println(country)
    }

    // age 不能在 if 作用域外使用
    // fmt.Println(age)

}

输出：

China
18
China

country 可在当前函数作用域中使用，但 age 不能在 if 作用域外使用。

1.3 指针变量

变量分为两种：

• 普通变量：存储的为数据本身
• 指针变量：存储的为数据/内存地址

指针变量声明可以使用 new 函数，也可以使用 &普通变量：

package main

import "fmt"

func main() {
	// 指针变量，方法一
	var name string = "rose"
	var ptr = &name		// & 后面接变量名，表示取出该变量的内存地址

	fmt.Println(name)	// rose
	fmt.Println(ptr)	// 0xc00005e270
	
	// 指针变量，方法二 new 函数
	ptr2 := new(int)
	fmt.Println(ptr2)	// 0xc0000a6090
	fmt.Println(*ptr2)	// * 指针变量名，表示从内存中取出值、0
}

使用表达式 new(Type) 将创建一个Type类型的匿名变量，初始化为Type类型的零值，然后返回变量地址，返回的指针类型为*Type。

1.4 匿名变量

常量和变量都只能声明一次，声明多次就会编译报错，匿名变量除外，它有如下优点：

• 不分配内存，不占用内存空间
• 不需要你为命名无用的变量名而纠结
• 多次声明不会有任何问题

一般可以用来接收必须接收，但又用不到的值：

func GetData() (int, int) {
    return 100, 200
}
func main(){
    a, _ := GetData()
    _, b := GetData()
    fmt.Println(a, b)
}

2. 常量

常量即不可被修改的变量，支持的类型：数字型（整型、浮点型和复数）、字符串型、布尔型，如：

// 声明变量
var name = "rose"

// 声明常量
var age = 18
const age1 = 18

2.1 因式分解

const (
    v1 = 123  
    v2 = 456
    v3 = 789
    v4 = 101112
)

2.2 iota

特殊变量，可以认为是一个可修改的常量，在 const 关键字出现时被重置为 0 （const 内部的第一行之前），const 每新增一行，常量声明将使 iota 计数一次，可理解为 const 语句块中的行索引。

const (
    v1 = iota
    v2 = iota
    v3 = iota
)

v1 = 0，v2、v3 分别为 1、2，可简写如下：

const (
    v1 = iota
    v2
    v3
)

示例一

package main

import "fmt"


func main() {
    const (
        v1 = iota + 2
        v2
        v3
    )
    fmt.Println(v1, v2, v3)

    const (
        v4 = iota + 2
        _
        v5
        v6
    )
    fmt.Println(v4, v5, v6)
}

输出：

2 3 4
2 4 5

示例二

package main

import "fmt"


func main() {
    const (
        i=1<<iota
        j=3<<iota
        k
        l
    )
    fmt.Println(i, j, k, l)
}

// 输出：1、6、12.24

• <<：表示左移
• iota 初始为 0，i 左移 0 位，值不变仍为 1
• j 左移 1 位，变为二进制 110，即 6
• k 左移 2 为，变为二进制：1100，即 12
• l 左移 3 为，变为二进制：11000，即 24

注意：<<n==*(2^n)

3. 输入

接收输入的有三个函数，分别为：

• fmt.Scan：从标准输入扫描用户输入的数据，将以空白符分隔的数据分别存入指定的函数
• fmt.Scanln：遇到换行时才停止扫描，最后一个数据后面必须有换行或者到达结束位置
• fmt.Scanf：按指定格式扫描输入的数据

3.1 Scan

从标准输入扫描文本，读取由空白符分隔的值保存到传递给本函数的参数中，换行符视为空白符。

本函数返回成功扫描的数据格式和遇到的任务错误，若读取的数据个数比提供的参数少，会返回一个错误报告原因。

1、接收一个参数：

package main

import "fmt"


func main() {
    var name string
    fmt.Println("请输入用户名：")
    fmt.Scan(&name)
    fmt.Printf(name)
}

输出：

[root@localhost test]# go run test.go 
请输入用户名：
rose
rose

2、接收两个参数：

package main

import "fmt"

func main() {
	var name string
	var age int

	fmt.Println("请输入用户名：")
	_, err := fmt.Scan(&name, &age)
	if err == nil {
		fmt.Println(name, age)
	} else {
		fmt.Println("用户输入数据错误", err)
	}
}

运行结果：

请输入用户名：
rose 18
rose 18

3.2 Scanln

类似 Scan，遇到换行时才停止扫描，最后一个数据后面必须有换行或者到达结束位置。

返回成功扫描的数据个数和遇到的任何错误。

package main

import "fmt"

func main() {
	var (
		name string
		age int
		gender string
	)
	fmt.Println("请输入参数：")
	fmt.Scanln(&name, &age, &gender)
	fmt.Println(name, age, gender)
}

运行结果：

// 空格不会停止扫描
请输入参数：
rose 19 female
rose 19 female

// 回车会停止扫描
请输入参数：
rose
rose 0 

3.3 Scanf

从标准输入扫描文本，根据 format 参数指定的格式去读取由空白符分隔的值保存到传递给本函数的参数中。

返回成功扫描的数据个数和遇到的任何错误。

package main

import "fmt"

func main() {
	var (
		name string
		age int
	)
	fmt.Println("请输入参数：")
	_, _ = fmt.Scanf("我叫：%s 今年：%d 岁", &name, &age)
	fmt.Println(name, age)
}

fmt.Scanf 不能以简单的空格符作为输入数据的分隔符，它指定了具体的输入格式，只有按照格式输入数据才会被扫描并存入对应变量，否则不能正确扫描到输入的数据。

3.4 读取一整行

fmt.Scan 以空白符区分输入的参数，若输入的是一整行，且单次之间相互有空格，那么使用 fmt.Scan 就会报错，若想读取一整行可以使用：

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	// line 从 stdin 中读取一行的数据，字节集合，转换为字符串
	line, _, _ := reader.ReadLine()
	data := string(line)
	fmt.Println(data)
}

运行结果：

// 输入的数据
格式化输入输出的用法请参考 aaaa fff gghh arr

// 打印的数据
格式化输入输出的用法请参考 aaaa fff gghh arr

reader 默认一次能读取 4096 个字节，一次性读完：isPrefix=false，先读一部分：isPrefix=true，再去读取：isPrefix=false。