golang学习-前置知识

声明变量

Go语言中的变量需要声明后才能使用，在同一个作用域内不支持声明重复变量。并且Go语言要求变量声明后必须使用。
声明变量语法

var name type

var：声明变量关键字

name：变量名

type：变量类型

---

声明单个变量

package main

func main() {
	var name string
	var age int
	var isResult bool
}

---

声明多个变量

package main

func main() {
	var (
		name string
		age int
		isResult bool
	)
}

---

变量的初始化

Go语言在声明变量的时候，会自动对变量对应的内存区域及进行初始化操作。每个变量都会被初始化成其类型的默认值。例如：整形和浮点型变量的默认值为0；字符串变量的默认值为""；布尔型变量默认值为false；切片、函数、指针变量的默认值为nil。
变量初始化语法

var 变量名 类型= 表达式

例如

var name string = "ljy"
var age int = 23

---

类型推导

我们在声明变量时，可以根据初始化值进行类型推岛，从而省略变量类型。
例如

package main

func main() {
	var name = "ljy"
	var age = 23
}

---

短变量声明

在函数内部，可以使用:=运算符对变量进行声明和初始化。
例如

package main
func main() {
	name := "ljy"
	age := "23"
}

在函数外部不能使用:=进行变量声明及初始化！

---

匿名变量

如果我们接收到多个变量，有一些变量使用不到，可以使用下划线_表示变量名称，这种变量叫做匿名变量。例如：

package main
func getAccess() (string , int) {
	return "ljy",23
}
func main() {
	name , _ := getAccess();
	fmt.Print("name: %v\n" , name)
}

语言常量

常量，就是在程序编译阶段就确定下来的值，而程序在运行时则无法改变该值。在Go程序中，常量可以时数值类型、布尔类型、字符串类型等。

定义常量的语法

定义一个常量使用const关键字，语法格式如下：

const constName type = value

const：定义常量关键字

constName：常量名称

type：常量类型

value：常量的值

例如

package main

func main() {
    const PI float64 = 3.14
    //PI = 55.5 cannot assign to PI 常量在声明后不能对其重新赋值
    const PI2 = 3.14 // 定义时可以省略类型
    
    const (
    	name = "ljy"
        age = 23
    )
}

---

const与iota搭配

const不单单作为声明常量的关键字，同样可以作为定义枚举类型来用，在定义枚举类型时，搭配iota一起使用。

package main

import "fmt"

const(
	// 可以在const()中添加iota关键字，每行的iota都会累加1，第一行的iota默认值为0
	BEIJING = 10 * iota // 0
	SHANGHAI			// 10
	SHENZHEN			// 20
)

const(
	a , b  = iota + 1 , iota + 2 // iota = 0 ; a = iota + 1 , b = iota + 2
	c , d						 // iota = 1 ; c = iota + 1 , d = iota + 2
	e , f						 // iota = 2 ; e = iota + 1 , f = iota + 2

	g , h = iota * 2 , iota * 3 // iota = 3 ; g = iota * 2 , h = iota * 3
	i , k						// iota = 4 , i = iota * 2 , k = iota * 3
)

func main() {
	fmt.Println(BEIJING)
	fmt.Println(SHANGHAI)
	fmt.Println(SHENZHEN)

	fmt.Println("a = " , a)
	fmt.Println("b = " , b)
	fmt.Println("c = " , c)
	fmt.Println("d = " , d)
	fmt.Println("e = " , e)
	fmt.Println("f = " , f)

	// iota只能配合const()一起使用，iota只有在const()中才起到累加效果
	//var a int = iota

}

输出语句

Go中的输出语句主要有两种，分别是Printf和Println，它们都是fmt包中的公共方法。

Printf

Printf()打印需要格式化的字符串，可以输出字符串类型的变量，不可以输出整形变量和整形；

例如

package main
	
import(
	"fmt"
	
)
	
func main(){

	name := "ljy"
	age := 12

	fmt.Printf("haha\n")
	fmt.Printf(name)
	fmt.Printf("\n")

	//fmt.Printf(12) (untyped int constant) as string value in argument to fmt.Printf
	//fmt.Printf(age) (variable of type int) as type string in argument to fmt.Printf
}

可以看到，在使用Printf()方法时，只能输出字符串类型的变量，当试图输出整形变量和整形时，将会报错。

而当我们试图采用Printf()方法输出变量age的值时，可以采用

fmt.Printf("%v\n" , age)

%v：默认方式打印变量的值

\n：换行

而在Printf()方法中常用的占位符也就是%T，%v两种方式，因为每种数据类型对应的占位符不同，因此所有类型都用%v即可。

%T：相应值的类型

例如

package main

import "fmt"

func main() {
    age := 23
    
    fmt.Printf("%T" , age) // sout:int
}

Println

Go中的Println()方法和Java中的println方法十分类似。可以打印字符串或变量。

package main
	
import(
	"fmt"
	
)
	
func main(){

	name := "ljy"
	age := 12

	fmt.Println(name)
	fmt.Println(age)
	fmt.Println("haha")

	/* 
	但是需要注意，在Go中的字符串拼接，不像Java直接用+号拼接，而是采用，拼接
	*/
	//fmt.Println(name + age) invalid operation: name + age (mismatched types string and int)
	fmt.Println(name , age , "haha")
}