前言

文章假设用户已经掌握一门编程语言，如Java，C。

变量

• 全局变量：定义在函数外的变量
• 局部变量：定义在{}中的变量
• Go的变量由字母、数字、下划线组成，其中首个字符不能为数字
• 变量申明一般为var关键字，且为强类型变量。
• 变量首字母的大小写来确定访问的权限。无论是方法名、常量、变量名还是结构体的名称，如果首字母大写，则可以被其他的包访问；如果首字母小写，则只能在本包中使用

变量的使用步骤

package main
import "fmt"
func main(){
    // 1.变量的声明
    var age int
    // 2.变量的赋值
    age = 18
    // 3.变量的使用
    fmt.Println("age=",age)
    // 4.设声明和赋值可合成一句
    var age int = 19
    // 5.不可以在赋值的时候给不匹配的类型
    var num int = 12.54   // 这种方式就是错误的
}

变量的4种使用方式

package main
import "fmt"
func main(){
    // 第一种：变量的使用方式
    var num int = 18
    fmt.Println(num)
    // 第二种：指定变量的类型，但不是赋值，使用默认值
    var num2 int
    fmt.Println(num2)
    // 第三种：如果没有写变量的类型，会根据等号后面的值进行判定变量的类型。（自动类型推断)
    var num3 = 10  // var num3 = 10.23 var num3 = "10.23"
    fmt.Println(num3)
    // 第四种：省略var,注意:=,不能写为=
    sex := "男"
}

一次可声明多个变量

package main
import "fmt"

var n7 = 100
var n8 = 9.7

// 设计者认为上面的全局变量写法太麻烦。可以一次性声明
var {
    n9 = 500
    n10 = "Jack"
}

func main(){
    var n1,n2,n3 int
    fmt.Println(n1)
    fmt.Println(n2)
    fmt.Println(n3)

    var n4,name,n5 = 10,"Tom",7.8
    fmt.Println(n4)
    fmt.Println(name)
    fmt.Println(n5)

    n6,height := 6.9,123.6
    fmt.Println(n6)
    fmt.Println(height)

    fmt.Println(n7)
    fmt.Println(n8)

    fmt.Println(n9)
    fmt.Println(n10)
}

数据类型

Go中的数据类型分为基本数据类型和派生数据类型

基本数据类型

1. 数值型
   • 整数类型（int,int8,int16,int32,int64,uint,uint8,uint16,uint32,uint64,byte）
   • 浮点类型
2. 字符型
   没有单独的字符类型，使用byte来保存单个字母字符
3. 布尔型（bool)
4. 字符串(string)

派生数据类型或复杂数据类型

1.指针
2.数组
3.结构体
4.管道
5.函数
6.切片
7.接口
8.map

指针

&:获取内存地址
*:取内存地址的值
1.可以通过指针改变指向值
2.指针变量接收的一定是地址值
3.指针变量的地址不可以不匹配
4.基本数据类型都有对应的指针类型，形式为*数据类型，如int，*int

package main
import "fmt"
func main(){
    var age int = 18
    //&符号+变量就可以获取这个变量内存的地址
    fmt.Println(&age)
   
    // 定义一个指针变量
    // var代表要声明一个变量
    // ptr 指针变量的名字
    // ptr对应的类型是：*int 是一个指针类型（可以理解为 指向int类型的指针）
    var ptr *int = &age
    fmt.Println(ptr)
    fmt.Println("ptr本身存储空间的地址为：",&ptr)

    //获取ptr这个指针指向的数据
    fmt.Printf("ptr指向的数值为%v", *ptr)


    var num int = 10
    fmt.Println(num)

    var ptr *int = &num
    *ptr = 20
    fmt.Println(num)  // 这时候发现值发生了改变
    

}

关键字

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

预定义标识符：一共有36个

运算符

1. 算数运算符

+ 代表正数、相加操作、字符串拼接

var n1 int = +10
var n2 int = 4 + 7
var n3 string = "abc" + "def"

/ 两个int类型数据计算结果已定位整数类型，浮点类型运算结果为浮点类型

fmt.Println(10/3)
fmt.Println(10.0/3)

%取余，等价公式：a%b = a-a/b*b

fmt.Println(10%3)   ====> 10-10/3*3  10/3为int类型，因此得值为3，10-3*3=1
fmt.Println(-10%3)
fmt.Println(10%-3)
fmt.Println(-10%-3)

++ 自增，+1操作

var a int  = 10
a++

-- 自减 同自增，-1操作
在go语言里，++和--操作简单，与Java不一样，只能单独使用，不能参与运算中。且只能写在变量后面，不能写在变量前面。

--a 这是错误的写法。

2. 赋值运算符

赋值运算符指的是：=,+=,-=,*=,/=,%=

3. 关系运算符

关系运算符指的是：==,!=,>,<,>=,<=
他们的返回结果都是bool类型。

4. 逻辑运算符

与: &&
或: ||
非: !

5. 位运算符

位运算符指的是：&,|,^,>>,<<
是对整数的二进制进行的运算。

A = 0010 1000
B = 0001 1101

-----------------

A&B = 0000 1000

A|B = 0011 1101

A^B = 0011 0101

A<<2 = 1010 0000

A>>2 = 0000 1010

6. 其他运算符

&：返回变量的存储地址
*：取指针变量对应的数值

7. 运算符优先级

为了提高优先级，可以直接加括号

8. 获取用户终端输入

录入数据的类型一定要匹配。底层会判定类型
方式一：

package main
import "fmt"
func main(){
	//实现功能：键盘录入学生的年龄、姓名、成绩，是否是VIP
	//方式1：Scanln
	var age int
	fmt.Println("请录入学生的年龄：")
	//传入age的地址的目的：在Scanln函数中，对地址的值进行改变的时候，实际外面的age也被影响了。
	fmt.Scanln(&age)

	var name string
	fmt.Println("请录入学生的姓名：")
	fmt.Scanln(&name)

	var score float32
	fmt.Println("请录入学生的成绩：")
	fmt.Scanln(&score)

	var isVIP bool
	fmt.Println("请录入学生是否为VIP：")
	fmt.Scanln(&isVIP)

	//将上述数据在控制台打印输出：
	fmt.Printf("学生的年龄为：%v,姓名为：%v，成绩为：%v，是否为VIP：%v",age,name,score,isVIP)

}

方式二：

package main
import "fmt"
func main() {
	//实现功能：键盘录入学生的年龄、姓名、成绩，是否是VIP
	//方式1：Scanln
	var age int
	var name int
	var score float32
	var isVIP bool
	fmt.Println("学生的年龄 姓名 成绩 是否为VIP")
	fmt.Scanf("%d %s %f %t", &age, &name, &score, &isVIP)
}