三天掌握Go语言入门知识之第一天

第一个程序

package main

import "fmt"

func main() {
    fmt.Prinfln("Hello,World!")
}

注释

• 单行注释

  // 单行注释
  

• 多行注释

  /*
  *	多行注释
  */
  

变量

变量的定义

Go语言中，变量的定义是使用var关键字进行定义，表明这是一个变量，其变量定义有单个变量定义，和多个变量定义

• 单个变量定义

  var name type = ...
  

• 多个变量

  var(
  	name1 type = ...
      name2 type = ...
      ...
      name type = ...
  )
  

变量的定义：

1. var 声明变量
2. name 变量名
3. type 变量类型
4. 变量赋值

变量的初始化

变量的初始化通过”=“和”:=“进行初始化

• ”=“

  使用”=“进行赋值需要用var关键字进行声明而且需要加上变量类型（注：变量类型是为了规范代码而加上，实际编译不写变量类型也可以，编译器会自动识别）

• “:=”

  使用“:=”进行赋值无需用var变量进行声明，编译器会自动识别并推导出变量以及变量类型

  name := ...
  

各种变量类型未初始化的默认值：

• int—0
• double—0.0
• string—空串
• bool值—false

变量的内存地址

使用fmt.Printf( )方法可以显示变量的类型以及地址

• %T 显示变量的类型

  var name string = "张三"
  fmt.Printf("type:%T", name)
  

• %p 显示变量的内存地址

  var name string = "张三"
  fmt.Printf("内存地址:%p", &name)
  

变量值交换

在Go语言中，两种类型相同的变量有种简单有效的交换变量值的方法

	var name string = "张三"
	var name1 string = "李四"
	name, name1 = name1, name

匿名变量

在Go种当一个函数返回多个值时，如果只需要用其中一个变量，那么就需要使用匿名变量 “_”

package main

import "fmt"

func main() {
	a, _ := test()
	fmt.Println(a)
}
func test() (int, int) {
	return 10, 20
}

常量

常量是一个简单值的标识符，在程序运行时，不会被修改的量。

常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

常量的定义格式：

const identifier [type] = value

你可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。

• 显式类型定义： const b string = "abc"
• 隐式类型定义： const b = "abc"

多个相同类型的声明可以简写为：

const c_name1, c_name2 = value1, value2

iota

iota，特殊常量，可以认为是一个可以被编译器修改的常量。

在每一个const关键字出现时，被重置为0，然后再下一个const出现之前，每出现一次iota，其所代表的数字会自动增加1

iota 可以被用作枚举值：

const (    
    a = iota    
    b = iota    
    c = iota
)	// a=0,b=1,c=2

第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；所以 a=0, b=1, c=2 可以简写为如下形式：

const (    
    a = iota    
    b    
    c
)	// a=0,b=1,c=2

基本数据类型

数值类型

整型 int 和浮点型 float，Go 语言支持整型和浮点型数字，并且原生支持复数，其中位的运算采用补码

对比其他语言，Go语言的浮点数值类型不在分单精度float和双精度double

• 整型 int

  序号	类型和描述
  1	uint8 无符号 8 位整型 (0 到 255)
  2	uint16 无符号 16 位整型 (0 到 65535)
  3	uint32 无符号 32 位整型 (0 到 4294967295)
  4	uint64 无符号 64 位整型 (0 到 18446744073709551615)
  5	int8 有符号 8 位整型 (-128 到 127)
  6	int16 有符号 16 位整型 (-32768 到 32767)
  7	int32 有符号 32 位整型 (-2147483648 到 2147483647)
  8	int64 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)

  var num uint16
  var num int8
  var num int64
  ...
  

• 浮点型 float

  序号	类型和描述
  1	float32 IEEE-754 32位浮点型数
  2	float64 IEEE-754 64位浮点型数
  3	complex64 32 位实数和虚数
  4	complex128 64 位实数和虚数

  var num float32
  var num float64
  var num complex64
  ...
  

布尔类型

Go语言中，布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true

var isTrue bool = true
var isTrue bool = false

注：当一个布尔类型的值没有初始化，默认是false

字符串类型

字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。Go语言的字符串的字节使用UTF-8编码标识Unicode文本

var str string = ...

结构体

Go语言中，没有类这一个概念，需要使用类时，往往是通过结构体和函数的结合方法实现

type student struct {
	name string
	age  int
}

结构体中也可以定义其他结构体或者一些结构体数组与结构体切片

type Teacher struct {
	name     string
	age      int
	students []Student	//切片
}
type Student struct {
	name string
	age  int
}

指针类型（Pointer）

Go语言的指针类型同C语言一样，可以指向其他任何类型

package main

import "fmt"

type student struct {
	name string
	age  int
}

func main() {
	//数值类型指针
	var num *int
	numPointer := 123
	num = &numPoint
	fmt.Println(num, &num)
	fmt.Println(&numPointer)
	//字符串指针
	var strPointer *int
	str := 123
	strPointer = &str
	fmt.Println(str, &str)
	fmt.Println(strPointer)
	//结构体指针
	var stuPointer *student
	st := student{name: "halley", age: 22}
	stuPointer = &st
	fmt.Println(st, &st)
	fmt.Println(stuPointer)
}

条件语句

Go语言中，if语句和if…else…同C语言和Java一样，因此跳过

注：在Go语言中，if和if…else中，判断表达式的小括号可以不用加，但是就算只有一条语句执行，都需要加入花括号，格式如下：

func main() {
	a := 0
	if a == 0 {
		a++
	} else {
		a--
	}
	fmt.Println(a)
}

switch语句

switch语句的作用同C语言和Java一样，只需记住其语法格式

switch var1 {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}

注：Go语言的switch语句中每一个case后面不需要加上break中断，在switch语句中的，表达式不写switch默认为True

例如：

func main() {
	x := 0
	switch x {
	case 0:
		fmt.Println(0)
		fallthrough
	case 1:
        break
		fmt.Println(1)
	case 2:
		fmt.Println(2)
	default:
		fmt.Println(-1)
	}
}

在上面代码中出现了fallthrough关键字，其意思是贯穿，因为在Go语言中，switch语句每次默认只会选一个case进行执行，因此当我们想要让switch语句继续执行，那么必须使用fallthrough关键字，但是该关键字每次只能贯穿一次，如果想要终止那么可以使用 break 结束

循环语句

如果你还在到底是选择for语句还是while语句中苦苦挣扎，那么学习Go就会拜托这个烦恼，因为Go压根就不存在while语句

在Go语言中的循环语句只有for，其语法格式有多种

• 不写表达式或者写bool型的表达式（可以实现无限循环）

  for{
      ...
  }
  

• 写表达式

  for i:=0;i<0;i++{
      ...
  }
  

• 搭配range使用，遍历容器

  var nums = []int{1，2，3，4，5}
  for i, num := range nums {
  	...
  }
  

  range能够返回两个值

  1. 表示当前元素在容器中的下标
  2. 表示当前元素的值