Go基础笔记（一）【注释、常量、变量】

前言

简单概括下go语言的几大特点：

• 高效的执行速度、编译速度、开发速度

• 除了应用开发，还可以做嵌入式开发

• 设计之初，就是为了方便，容易上手

• 天然支持高并发

go中不需要逗号，分号

注释

• 单行注释

• 多行注释

  //单行注释
  /*
   多行注释
  */
  

变量

• 声明变量用var关键字

  • 第一个：var是声明变量的关键字
  • 第二个：是变量的名字
  • 第三个：变量的类型

  name变量对应的内存地址空间，存放的是…

**注意：**只有main方法可以直接执行，其他方法需要调用来执行

//输入
package main

import "fmt"

func main() {
    //定义一个string类型的name变量
	var name string = "whl"
	fmt.Println(name)
}

//输出
whl

修改为wyf

//输出
package main

import "fmt"

func main() {
	var name string = "whl"
	name = "wyf"
	fmt.Println(name)
}

//输出
wyf

• Go语言是静态类型语言，首先要显示的声明变量类型

  package main
  
  import "fmt"
  
  func main() {
  	var name string = "whl"
  	var age int = 18
  	name = "wyf"
  	fmt.Println(name, age)
  }
  

  //输出
  wyf 18
  

• 同时定义多个变量，使用var()

  package main
  
  import "fmt"
  
  func main() {
  	var (
  		name string
  		age  int
  		addr string
  	)
  	//打印默认值
  	//string默认值为空,  int默认值为0
  	fmt.Println(name, age, addr)
  }
  

  //输出
  0
  

  • 整数、浮点数的默认值为：0，0.0
  • 字符串的默认值为空字符串
  • 布尔类型的默认值为false
  • 切片，函数、指针变量的默认值为null

• 变量遵循驼峰命名，首字母小写，后面单词的首字母大写

• 变量的初始化

  • 先声明，再赋值

  • 声明的同时，赋值

    • 符号":="自动推导**（快速赋值）**

    package main
    
    import "fmt"
    
    func main() {
    	name := "whl"
    	age := 24
    
    	fmt.Println(name, age)
    	//查看变量类型,注意是printf函数
    	fmt.Printf("%T,%T", name, age)
    
    }
    

    //输出
    whl 24
    string,int
    

    **注意：**声明后不能再使用":="来赋值，就不是同一个变量了，会报错

• 打印内存地址

  取地址符：&变量名

  package main
  
  import "fmt"
  
  func main() {
  	var num int
  	num = 100
  	fmt.Printf("num:%d,内存地址：%p", num, &num)
  }
  

  //输出
  num:100,内存地址：0xc0000a6058
  

  **注意：**重新赋值，地址值不会变；但是每一次重启运行，分配的地址会不一样。而且，再次赋值不能是其他类型，因为go语言是根据变量类型来开辟内存空间的。

  package main
  
  import "fmt"
  
  func main() {
  	var num int
  	num = 100
  	fmt.Printf("num:%d,内存地址：%p", num, &num)
  	fmt.Println()
  	num = 200
  	fmt.Printf("num:%d,内存地址：%p", num, &num)
  }
  

  //输出
  num:100,内存地址：0xc00001c0a8
  num:200,内存地址：0xc00001c0a8
  

• 变量交换

  其他语言的变量交换一般是设一个中间变量，用下方式子来解决

  temp = b;
  b = a;
  a = temp;
  

  go中的实现会简单很多

  package main
  
  import "fmt"
  
  /*
  变量交换
  */
  func main() {
  	var a int = 100
  	var b int = 200
  	fmt.Println(a, b)
  	a, b = b, a
  	fmt.Println(a, b)
  
  }
  

  //输出
  100 200
  200 100
  

• 匿名变量

  可以接收多个值，不需要的话可以用"_"废弃掉

  package main
  
  import "fmt"
  
  func test() (int, int) {
  	return 100, 200
  }
  
  func main() {
  	a, _ := test()
  	fmt.Println(a)
  }
  

  //输出
  100
  

  匿名变量不会占用内存空间，不会分配内存。匿名变量之间也不会因为多次声明而无法使用

• 变量的作用域

  • 局部变量：只能在定义的函数内使用
  • 全局变量：没有函数包裹的

  注意：局部变量和全局变量可以使用同一个名字，但是会根据就近原则打印输出

  package main
  
  import "fmt"
  
  var name string = "wyf"
  
  func main() {
  	var name string = "whl"
  	fmt.Println(name)
  }
  

  //输出
  whl
  

常量

不能被修改。常量的数据类型只能是布尔型、数字型（整数型、浮点数型、复数）、字符串型。

• 显示定义

• 隐式定义

  package main
  
  import "fmt"
  
  func main() {
  	const name string = "wyf" //显示定义
  	const male = "female"     //隐式定义
  
  	fmt.Println(name, male)
  
  }
  

  //输出
  wyf female
  

iota（了解，开发中用的不多）

特殊常量，是go语言中的常量计数器。

在const关键字出现时将被重置为0，每新增一行常量声明，将使iota计数一次

package main

import "fmt"

func main() {
	const (
		a = iota
		b
		c
		d = "ok"
		e
		f = 100
		g = iota
	)
	const (
		h = iota
		i
	)

	fmt.Println(a, b, c, d, e, f, g, h, i)
}

0 1 2 ok ok 100 6 0 1