go 语言（二）相关基础学习

朱雀 2022-12-10 04:58 163阅读 0赞

1、go语言main函数的了解

> `把程序比作商场 -- 需要入口函数 1）go语言以包作为管理单位 2）每个文件必须先声明包 3）程序必须有一个main包（重要） 一个文件夹只能有一个main函数 fmt.Println("23") // go语言语句结尾没有分号 命令行编译 go build xxx.go 编译go代码，生成一个可执行程序.exe go run xxx.go 不生成程序，直接运行，不过一般都是直接go run`

2、变量相关

（1）声明格式 var 变量名 类型 变量声明也必须要用

（2）只是声明，没有初始化的变量，默认值是0

（3）同一个() 里，声明的变量是唯一的

> `变量的初始化，声明变量时，同时赋值 var d int = 10 // 初始化，声明变量时，同时赋值（一步到位） d = 20 // 赋值，先声明，后赋值 fmt.Println("d = ", d)`

> `自动推导类型，必须初始化，通过初始化的值确定类型（常用） e := 30 // %T打印变量所属的类型 fmt.Printf("e type is %T\n", e) // e type is int`

> `格式化输出，printf和println p := 10 q := 20 fmt.Println("p = ", p, ",q = ", q) // p = 10, q = 20 fmt.Printf("p = %d, q = %d\n", p, q) // p = 10, q = 20`

> `多重赋值，变量交换 i, j := 10, 20 i, j = j, i fmt.Printf("i = %d, j = %d\n", i, j) // i = 20, j = 10`

3、匿名变量的使用

package main
    
    import "fmt" // 导入包，必须要使用
    
    // go函数的定义： 函数可以返回多个值
    func test() (a, b, c int) {
    	return 1, 2, 3
    }
    
    func main() {
    	var tmp int
    	i, j := 10, 20
    	// _匿名变量，丢弃数据不处理，_匿名变量配合函数返回值使用，才有优势
    	tmp, _ = i, j
    	fmt.Println("tmp = ", tmp)
    
    	var c, d, e int
    	c, d, e = test() // return 1,2,3
    	fmt.Printf("c = %d, d = %d, e = %d\n", c, d, e)
    
    	_, d, e = test() //return 1,2,3
    	fmt.Printf("d = %d, e = %d\n", d, e)
    }

其中主要注意的是函数的定义，函数的调用，匿名变量\_ 的使用

4、常量的使用

> 常量，程序运行期间，不可以改变的量，常量声明需要const  
>     // 变量，程序运行期间，可以改变值，变量声明需要var  
>     // 常量，程序运行期间，不可以改变的量，常量声明需要const
> 
>     const a int = 10  
>     fmt.Println("a = ", a)
> 
>     const b = 11.2 // 没有使用：=  
>     fmt.Printf("b type is %T\\n", b)  
>     fmt.Println("b = ", b)

5、多个变量或者常量定义

多个变量定义，初始时不进行声明

> `var ( a int b float64 ) a, b = 10, 3.14 fmt.Println("a = ", a) fmt.Println("b = ", b)`

多个常量定义，初始时进行赋值声明(需要注意浮点型的精度问题)

> `const ( i int = 10 j float64 = 3.14 ) fmt.Println("i = ", i) // i = 10 fmt.Println("j = ", j) // j = 3.14 fmt.Printf("i = %d, j = %f\n", i, j) // i = 10, j = 3.140000`

6、iota 枚举

// 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) // 0,1,2
    
    	// 3、iota 遇到const，重置为0
    	const d = iota
    	fmt.Printf("d = %d\n", d) // 0
    
    	// 4、可以只写一个iota
    	const (
    		a1 = iota // 0
    		a2
    		a3
    	)
    	fmt.Printf("a1 = %d, a2 = %d, a3 = %d\n", a1, a2, a3) // 0,1,2
    
    	// 5、如果是同一行，值都一样
    	const (
    		i1     = iota       // 0
    		i2, j1 = iota, iota // 同一行的值相同
    		i3     = iota
    	)
    	fmt.Printf("i1 = %d,i2 = %d, i3 = %d, j1 = %d\n", i1, i2, i3, j1) // 0,1,2,1

7、格式化输出

此处需要注意浮点型的判断，%f 小数位和 %v 小数位的不同

a := 10
    	b := "abc"
    	c := 'a'
    	d := 3.14
    
    	fmt.Printf("%T, %T, %T, %T\n", a, b, c, d) //int, string, int32, float64
    
    	// %d整形格式 %s字符串格式 %c字符格式 %f浮点型格式
    	fmt.Printf("a=%d, b=%s, c=%c, d=%f\n", a, b, c, d) //a=10, b=abc, c=a, d=3.140000
    
    	// %v自动匹配格式输出
    	fmt.Printf("a=%v, b=%v, c=%v, d=%v\n", a, b, c, d) //a=10, b=abc, c=97, d=3.14
    
    	fmt.Println("Hello, World!")

8、输入的使用

var a int // 声明变量
    	fmt.Printf("请输入变量a：")
    
    	// 阻塞等待用户的输入
    	fmt.Scanf("%d", &a)
    	//fmt.Scan(&a)
    
    	fmt.Println("a = ", a)

9、类型别名

由于一些语言使用习惯的问题，如果java或者c语言使用者过渡到go语言，可以在此处进行字段类型的别名替换

// 给int64 起一个别名叫bigint
    	type bigint int64
    	
    	var a bigint // 等价于var a int64
    	
    	type {
    		longint int64
    		char byte
    	}
    	
    	var b longint = 11
    	var c char = 'a'
    	
    	fmt.Println("b = %d, c = %c\n",b,c)

10、条件判断的使用 if-else

s := "success"
    
    	if s == "error" {
    		fmt.Println("继续努力！")
    	} else {
    		fmt.Println("恭喜您答对了！")
    	}
    
    	// if 支持1个初始化语句，初始化语句和判断条件以分号分隔
    	if a := 10; a == 10 {
    		fmt.Println("a == 10")
    	}

11、switch和case的使用

第一种使用：

var num int
    	fmt.Printf("请按下楼层：")
    	fmt.Scan(&num)
    
    	//	switch a:=10,a {}
    
    	switch num { // switch 后面写的是变量本身
    
    	case 1:
    		fmt.Println("按下的是1层")
    		// break // go语言保留了break关键字，跳出switch语言，不写，默认包含
    		fallthrough // 不跳出switch语句，后面的无条件执行
    	case 2:
    		fmt.Println("按下的是2层")
    	case 3:
    		fmt.Println("按下的是3层")
    	case 4:
    		fmt.Println("按下的是4层")
    	case 5, 6, 7, 8, 9, 10:
    		fmt.Println("这些楼层不停")
    	default:
    		fmt.Println("按下的是xxx楼")
    	}

第二种使用：

switch 可以没有条件，将条件放到case后面

score := 85
    	switch { // 可以没有条件
    	case score > 90: // case后面可以放条件
    		fmt.Println("优秀")
    	case score > 80:
    		fmt.Println("一般")
    	case score > 70:
    		fmt.Println("不及格")
    	default:
    		fmt.Println("其他 ")
    	}

12、for循环的使用

// for 初始化条件 ; 判断条件; 条件变化  {
    
    	// 计算 1 + 2 + 3 + ... + 100
    	sum := 0
    	for num := 1; num <= 100; num++ {
    		sum += num
    	}
    	fmt.Println("sum = ", sum)

13、range 迭代的使用

迭代比较重要，切片、通道都能用的上

str := "abc"
    
    	// 通过for打印每个字符
    	for i := 0; i < len(str); i++ {
    		fmt.Printf("str[%d]=%c\n", i, str[i])
    	}
    
    	// 迭代打印每个元素，默认返回2个值： 一个是元素的位置，一个是元素本身
    	for i, data := range str {
    		fmt.Printf("str[%d]=%c\n", i, data)
    	}
    
    	for i := range str {
    		// 第二个返回值，默认丢弃，返回元素的位置（下标）
    		fmt.Printf("str[%d]=%c\n", i, str[i])
    	}
    
    	for i, _ := range str {
    		// 第二个返回值，默认丢弃，返回元素的位置（下标）
    		fmt.Printf("str[%d]=%c\n", i, str[i])
    	}
    	//str[0]=a
    	//str[1]=b
    	//str[2]=c

14、goto 和 time的使用

import "fmt"
    import "time"
    func main() {
    
      fmt.Println("1111111")
      
      time.Sleep(time.Second)  // 延时1s
    
      fmt.Println("1111111")
      goto End // goto是关键字，End是用户起的名字，叫做标签
      fmt.Println("2222222")
    
    End:
      fmt.Println("3333333")
    }