go语言的基本语法

01.关键字与标识符

关键字：被赋予了特殊含义的单词，又叫保留字

Go语言中的关键字一共有25个

1.关键字和标识符

标识符定义

1. Go语言对各种变量、方法、函数等命名时使用的字符序列。
2. 由若干个字母、下划线(_)、和数字组成，且第一个字符必须是字母。

标识符声明

1. 使用标识符之前必须进行声明。
2. 声明一个标识符就是将这个标识符与常量、类型、变量、函数或者代码包绑定在一起。
3. 在同一个代码块内标识符的名称不能重复。

标识符特点

1. 标识符的命名要尽量采取简短且有意义。
2. 不能和标准库中的包名重复。
3. 为变量、函数、常量命名时采用驼峰命名法，例如 stuId、stuName。

标识符规则

预定义标识符

自身具有一些特殊含义的标识符

Go语言中的预定义标识符一共有 37 个。

标识符声明示例

var stuId int 
//声明一个int类型、名为stuId的标识符
var stuName string = “姓名“ 
//声明一个string类型、名为stuName、值为姓名的标识符

错误标识符示例

var 1num int  
//不能以数字开头
var break string 
//不能以系统保留关键字作为标识符

02.变量和常量

变量

变量的定义：
一种能够储存值或者计算结果的抽象概念。
是内存中的一个数据存储空间的标识，变量可以看做是一个内存地址，通过内存地址，我们可以找到这个地址所存储的数据。

局部变量：
函数体内声明的变量称之为局部变量，作用域只在函数体内，函数的参数和返回值变量都属于局部变量。函数调用结束后这个局部变量就会被销毁。
全局变量：
在函数体外声明的变量称之为全局变量，全局变量声明必须以 var 关键字开头，如果想要在外部包中使用全局变量的首字母必须大写。

形参变量：
在定义函数时函数名后面括号中的变量叫做形式参数变量。形式参数只在函数调用时才会生效，函数调用结束后就会被销毁。

变量标准格式声明

关键字 var 开头，后置变量类型
格式： var 变量名 变量类型
标准初始化格式： var 变量名 变量类型 = 初始化值

//示例1：
var goodsName string = "Go语言"
//示例2
var stuName string
stuName = "小明"

变量批量格式声明

存放一组变量定义

格式： var{
a 变量类型
b 变量类型
c,d 变量类型
}

//示例
var {
goodsPrice float32
goodsNum,goodsId int
}
goodsId = 123
goodsNum = 5
goodsPrice = 6.7

变量简短格式声明

定义在函数内部的显式初始化，不提供数据类型

格式：
变量名 :=变量值
变量名1，变量名2 := 变量值1,变量值2

//示例1：
goodsName :="Go语言"
//示例2
goodsSize,goodsID := "50kg","go001"

常量

常量的定义：
一种简单的标识符，在程序运行时它的值不会被改变。

标准定义格式：
const 常量名[常量类型] = 常量值
显式定义格式：
const 常量名 常量类型 = 常量值
隐式定义格式：
const 常量名 = 常量值

//示例
package main
import "fmt"
func main() {
	const a int = 1
	const b,c = 2,"C"
	fmt.Println(a)
	fmt.Println(b)
	fmt.Println(c)
}
//运行结果为：
//1
//2
//C

a是显式类型定义，即能看到数值类型。
b,c是隐式类型定义。

思考题
1.
2.

package main
import "fmt"
func main() {
        var i int 
	fmt.Println(i)
	const a int 
}
//运行结果为：?

常量与变量区别：

1.可以声明一个变量而不同时初始化它
2.常量需要初始化
（Go 无法在编译时检测到运行时错误，但常量属于编译时，因此可以更早地检测到错误）

03.数据类型

数字类型：

package main
import "fmt"
func main() {
    var num int
    fmt.Println("num=",num)
    var pai_32 float32 = 3.12345678901234567890
    var pai_64 float64 = 3.12345678901234567890
    fmt.Println("pai_32=",pai_32)
    fmt.Println("pai_64=",pai_64)
    var num1 complex64 = 1.2+3i
    var num2 =complex(1.2,3)
    fmt.Printf("num1的数据类型是：%T\n",num1)
    fmt.Printf("num2的数据类型是：%T\n",num2)
}
//运行结果为：
//num= 0
//pai_32= 3.1234567
//pai_64= 3.1234567890123457
//num1的数据类型是：complex64
//num2的数据类型是：complex128

数值类型默认值为0
float32大约可以提供小数点后6到8位的精度
float64可以提供小数点后15位的精度
Complex64分为32位实数和32位虚数
Complex128分为64位实数和64位虚数

04.运算符

算数运算符

• 两个运算数的类型必须相同并且为基本数据类型

package main
import "fmt"
func main() {
	fmt.Println("1/2 =",1/2)
}
//运算结果为：
1/2 = 0

package main
import "fmt"
func main() {
	fmt.Println("1.0/2 =",1.0/2)
}
//运算结果为：
1.0/2 = 0.5

• 自增和自减在Go语言中构成单独的语句，不是表达式

	var a int = 1
	var b int
	a++			//正确
	b = (a++)		//错误，因为自增自减只能当作一个独立的语句使用
	++a			//错误，因为自增自减只能写在变量的后面

关系运算符

逻辑运算符

位运算符

位移运算符

package main
func main() {
	var a int = 1
	var b int = 2
	println("a&b=",a<<b)
	println("a&b=",a>>b)
}
//运行结果为：
a<<b= 4
a>>b= 0

1的二进制为01，左移2位是100，转换成十进制为4。 1的二进制为01，右移2位是00，转换成十进制是0。

赋值运算符

其他运算符

go不支持三元运算符 若要实现三元运算，可以使用if-else进行实现

05.数据类型转换

定义：

valueOfTypeB = typeB(valueOfTypeA)

• Go语言所有的类型转换都必须显式的声明
• 类型转换只能在定义正确的情况下转换成功，例如从一个取值范围较小的类型转换到一个取值范围较大的类型（将 int16 转换为 int32）。
• 当从一个取值范围较大的类型转换到取值范围较小的类型时（将 int32 转换为 int16 或将 float32 转换为 int），会发生精度丢失（截断）的情况。
• 只有相同底层类型的变量之间可以进行相互转换（如将 int16 类型转换成 int32 类型），不同底层类型的变量相互转换时会引发编译错误（如将 bool 类型转换为 int 类型）

package main
import (
	"fmt"
	"reflect"
	"strconv"
)
func main() {
	// 初始化一个32位整型值
	var a int32 = 1234567890
	fmt.Printf("a的值为：%d，类型为：%s \n",a,reflect.TypeOf(a))
	b := int16(a)    //精度丢失
	fmt.Printf("b的值为：%d，类型为：%s \n",b,reflect.TypeOf(b))
	c := strconv.Itoa(int(a))
	fmt.Printf("c的值为：%s，类型为：%s \n",c,reflect.TypeOf(c))
}
//运算结果为：
a的值为：1234567890，类型为：int32
b的值为：722，类型为：int16
c的值为：1234567890，类型为：string