Go语言基础语法

---

---

---

一、注释

• 我们在写代码的时候会有这种情况时长发生，刚写完的代码，觉得逻辑很清晰，自己怎么这么厉害，过一段时间再去看这个代码，就会产牛疑问，这个代码到底TM谁写的！所以为了防止自己看不懂自己的代码，或者你想把你写的代码给别人看，这个时候，我们就需要汗释了！

注释：你可以理解为写给人看的，机器并不会去执行这行语句。

• 注释主要的功能就是为了增强代码的可读性,不参与程序的一切功能,Go语言的注释主要分成两类。

1.单行注释

package main
// 双斜杠表示单行注释，程序不会执行这行语句，这是写给自己或他人看的
import "fmt"

func main() {
	fmt.Printf("helloword!")
}

2.多行注释

package main
/*
	杠星 星杠表示多行注释，在二者之间的范围内可以换行写多行注释
*/
import "fmt"

/*
	这是一个main函数，这是go语言启动的入口
*/
func main() {
	// fmt.Printfln:打印一行内容，然后执行完成后进行换行
	fmt.Printfln("hello,word!")
}

养成写注释是一个良好的习惯，方便自己阅读，也方便他人阅读

二、变量

• 在数学概念中，变量表示没有固定值且可改变的数。比如 x=1，x= 2；
• 字面上的意思理解：变量就是会变化的量。
• 比如我定一个了一个变量叫做名字，它在Go语言中是这样表示的：这个值既可以是张三，也可以是李四，也可以是王五，也可以是你的名字。那么在这里，这个name就是变量，可以变化的量。

// 这里的等于是赋值，就是把等号右边的值，赋值给左边变量的意思
var name string = "guan"

在这里除了name之外，我们还写了其他的东西，比如 var、string 这些都是干嘛的呢，接下来就来带大家了解下go 语言中的变量的定义以及go 语言的一些数据类型（比如上面的 name 名字，它就是一个字符串类型的，我们有时候还需要表示数字，所以还会存在数字类型等，后面进一步了解）。

1.变量的定义

• Go语言是静态类型语言,就是所有的类型我们都需要明确的去定义。这里先不管其他类型,先了解string,用它来表示字符半。
• 在Go语言中,我们声明一个变量一般足使用 var关键字:

var name type

• 第一个 var 是声明变量的关键字，是固定的写法，声明一个变量，就需要一个var。
• 第二个 name，就是变量的名字，你可以按照自己的需求给它定 个名字，用来后续使用。
• 第二个 type，就是用来代表变量的类型。

举个栗子：

// 定义一个字符串变量，name
var name string
// 定义一个数字类型变量 age
var age int

如果之前学过Jva, C或者其他编程语言,第一次看到这样的操作肯人不舒服。Go语言和许多编程语言不同，它在声明变量时将变量的类型放在变量的名称之后,这样做的处就是可以避免像C语言那样合糊不清的声明形式,例如: int *a, b; 其中只有 a 是指针而b不是。如过想要这两个变量都是指针变量，则需要将分开书写。而在Go中，则可以和轻松地将们都声明为用钊类型：

var a,b *int

变量的命名规则遵循骆驼命名命法, 即首个单词小写,每个新单词的首字母大写,例如: helloWord 和 guanGuan。 .

变量定义的标准格式为

var 变量名 变量类型

变量声明以关键字 var 开头，后置变量类型，行尾无须分号。

我们有时候会批量定义变量，如果每次都单独定义比较麻烦，Go语言文持批量定义变量使用关键了 var 和括号，可以将一组变量定义放在一起。

	var (
		name string
		age  int
		addr string
	)

形式的声明语句往往是用于需要显式指定变量类型地方,或者因为变量稍后会被重新赋值而初始值大关紧要的地方。当一个变量被声明之后，如果没有显示的给他赋值，系统自动赋予它该类型的零值：

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

fmt.Printf(name, age, addr)

2.变量的初始化

变量初始化的标准格式

var 变量名 类型 = 值（表达式）

比如，我想定义guan的一些信息，我可以这么表示

var name string = "guan"
var age int = 18

fmt.Printf("name:%s,age:%d", name, age)

这里的 name 和 age 就是变量名，name 的类型为 string， age 的类型为 int。他们的值分别为 guan 和 18

短变量声明并初始化

name := "guanGuan"
age :=18

fmt.Printf("name:%s,age:%d", name, age)

这是Go语言的推导声明写法，编译器会自动根据右值类型推断出左值的对应类型。它可以自动的推导出一些类型，但是使用也是有限制的；

• 定义变量，同时显式初始化。
• 不能提供数据类型。
• 只能用在函数内部。不能随便到处定义

因为简洁和灵活的特点，简短变量声明被广泛用于大部分的局部变量的声明和初始化。

注意：由于使用了：=，而不是赋值的=，因此推导声明写法的左值变量必须是没有被定义过的变量。若定义过，将会发生编译错误。

// 定义变量 name
var name string
// 定义变量 name，并赋值为"guanGuan"
name := "guanGuan"

编译会报错，信息如下：no new variables on left side of :=意思是，在“：=”的左边没有新变量出现，意思就是“：=”的左边变量已经被声明了。

3.理解变量（内存地址）

	var num int
	num = 1000
	fmt.Printf("num的值：%d,内存地址:%p\n", num, &num)
	num = 2000
	fmt.Printf("num的值：%d,内存地址:%p\n", num, &num)

4.变量交换

package main

import "fmt"

func main() {
	/*
		在编程中，最简单的算法就是变量的交换，但是一般常见的方式就是定义中间变量
		var a int = 100
		var b int = 2oo
		var t int

		t = a
		a = b
		a = t

		fmt.Println(a,b)
	*/

	var a int = 100
	var b int = 200
	fmt.Printf("交换前的变量a=%d,b=%d\n", a, b)
	// 在Go语言中，可以直接用这样的方式实现值得交换，无需中间变量
	b, a = a, b
	fmt.Printf("交换后的变量a=%d,b=%d", a, b)

}

输出

5.匿名变量

匿名变量的特点是一个下画线””，““本身就是一个特殊的标识符，被称为空白标识符。它可以像其他标识符那样用于变量的声明或赋值（任何类型都可以赋值给它），但任何赋给这个标识符的值都将被抛弃，因此这些值不能在后续的代码中使用，也不可以使用这个标识符作为变量对其它变量进行赋值或运算。使用匿名变量时,只需要在变量声明的地方使用下画线替换即可。

例如:

package main

import "fmt"
/*
定义一个test函数，它会返回两个int类型的值，每次调用将会返叵 100 和 200 两个数值、这里我们先不只管 函数的定义，后面会讲解。89我们用这个函数来理解这个匿名变量。
*/
func test()(int, int) {
	return 100, 200
}
func main(){
	a,_:= test()
	_, b := test()
	fmt.Println(a, b) //输出的结果100,200
	// 在第一行代码巾，我们只需要获取第一个返叵值，所以第二个返回值定义为匿名交量
	// 在第二行代码巾，我们只需要获取第二个返叵值，所以第一个返回值定义为匿名变量
}

• 在编译过程中,可能会遇到没有名称的变量、类型或方法。虽然这不是必须的,但有时候这样做可以极大地增强代巧的灵活性,这些变量被统称为匿名变量。
• 匿名变量不占用内存空间，不会分配内存。匿名变量与匿名变量之间也不会因为多次声明而无法使用。

6.变量的作用域

一个变量（常量、类型或函数）在程序中都有一定的作用范围，称之为作用域。

了解变量的作用域对我们学习Go语言来说足比较重要的，因为Go语言会在编译时检查每个变量足否使用过，一旦出现未使用的变量，就会报编译错误。如果不能埋解变量的作用域,就有可能会带来一些不明所以的编译错误。

局部变量

在函数体内声明的变量称之为局部变量,它们的作用域只在函数体内,函数的参数和返回值变量都属于局部变量。

package main

import "fmt"

// 全局变量
var name string = "guanGuan"

func main() {
	//局部变量
	var age int = 18
	var name string = "Guan"

	fmt.Println(name, age)

}

func test() {
	fmt.Println(name)

}

全局变量

在函数休外声明的变量称之为全局变量,全局变量只需要在一个源文件中定义,就可以在所有源文件中使用,当然,不包含这个全局变量的源文件需要使用"import"关键它引入全局变量所在的源文件之后才能使用这个全局变量。

全局变量声明必须以var关键字开头,如果想要在外部包中使用全局变量的首字母必须大写。

//声明全局变量
var c int 
func main(){
	//声明局部变量
	var a,b int
	初始化参数
	a = 3
	b = 4
	c = a + b
	fmt.printf("a = %d,b = %d,c = %d\n",a,b,c) //a = 3, b = 4, c = 7
}

Go语言程序中全局变量与局部变量名称可以相同，但是函数体内的局部变量会被优先考虑。

package main
import "fmt"
//声明全局变量
var a float32 = 3.14
func main(){
	//声明局部变量
	var a int = 3
	fmt.Printf("a = %d\n", a) // a = 3
}

三、常量

1.常量的定义： const

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

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

const identifier [type] = value

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

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

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

const c_name1, c_name2 = value1, value2

以下实例演示了常量的应用：

package main

func main() {
	// 常量不能被修改的量，否则会报错
	const URL string = "www.baidu.com"
	URL = "www.guan.com"
}

输出

package main

import "fmt"

func main() {
	const URL1 string = "www.baidu.com" // 显式定义
	const URL2 = "www.guan.com" // 隐式定义
	const a,b,c = 3.14,"guanGuan",true //同时定义多个常量
	fmt.Println(URL1)
	fmt.Println(URL2)
	fmt.Println(a,b,c)
}

输出

2.iota（特殊常量）

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

• iota在const关键字出现时将被重置为0(const内部的第一行之前), const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。

iota 可以被用作枚举值：

const (
a = iota
b = iota
c= iota
)

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

package main

import "fmt"

func main() {
	const (
		// 一组常量中，如果某个常量没有初始值，默认和上一行一致
		a = iota         //iota=0
		b                //iota=1
		c                //iota=2
		d = "hello,guan" // hello,guan  iota=3
		e                // hello,guan  iota=4
		f = 100          // 100 iota=5
		g                // 100 iota=6
		h = iota         //iota=7
		i                //iota=8
	)
	const (
		j = iota // iota=0
		k = iota // iota=1
	)
	fmt.Println(a, b, c, d, e, f, g, h, i, j, k)
}

四、基本数据类型

Go语言是一种静态类型的编程语言,在Go编程语言中,数据类型用于声明函数和变量。数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要川大数据的时候才需要申请大内存，就可以充分利川内存。编译器在讲行编译的时候，就要知道每个值的类型，这样编译器就知道要为这个值分配多少内存,并且知道这段分配的内存表示什么.

1.布尔类型

布尔型的值只可以是常量 true 或者 false。举一个简单的栗子：

package main

import "fmt"

func main() {
	// var 变量名 数据类型
	// bool： true false
	var isFlag bool
	var b1 bool = true
	var b2 bool = false

	fmt.Println(isFlag) //如果不进行初始赋值，则默认值为false
	fmt.Printf("%T,%t\n", b1, b1)
	fmt.Printf("%T,%t\n", b2, b2)
}

2.数值型

整型int和浮点型loat32、 foat64, Go语言支持整型和浮点型数字,并且支持复数,其中位的运算采用补码。

Go 也有基于架构的类型，例如：uint 无符号、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)

package main

import "fmt"

func main() {
	// 定义一个整型
	// byte uint8
	// rune int32
	// int int64
	
	var age int = -100
	var i1 int8
	var i2 uint8
	i1 = 66
	i2 = 188

	fmt.Printf("%T,%d\n",age,age)
	fmt.Println(i1)
	fmt.Println(i2)
}

浮点型

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

package main

import "fmt"

func main() {
	var f1 float32
	f1 = 3.14
	var f2 float64
	f2 = 5.12
	// %f 默认保留小数点后6位，.2f%就是保留2位，.3f%就是保留3位
	fmt.Printf("%T,%.3f\n", f1, f1)
	fmt.Printf("%T,%f\n", f2, f2)
}

输出

1、关于浮点数在机器中存放形式的简单说明，浮点=符号位+指数位+尾数位

2、尾数位部分可能会丢失，造成精度损失。-123.0000901

package main

import "fmt"

func main() {
	// float64 尽量使用 float64 来定义浮点类型的小数
	var num1 float32 = -123.1234567
	var num2 float64 = -123.1234567
	fmt.Println("num1=", num1, "num2=", num2)

}

• 说明：float64的精度要比float32的要准确
• 说明：如果我们要保存一个精度高的数，则应该选择float64

3、浮点型的存储分为二部分：符号位+指数位+尾数位，在存储过程中，精度会有丢失、

4、golang的浮点型默认为float64类型

5、通常情况下，应该使用float64，因为它比float32更精确

以下列出了其他更多的数字类型：

序号	类型和描述
1	byte 类似 uint8
2	rune 类似 int32
3	uint 32 或 64 位
4	int 与 uint 一样大小
5	uintptr 无符号整型，用于存放一个指针

3.字符串型

import "fmt"

func main() {

	var str string
	str = "helloWorld!"
	fmt.Printf("%T,%s\n", str, str)

	//单引号 字符 ，整型-ASCII字符码
	
	x1 := 'A'
	x2 := "A"
	x3 := '关'
	
	// 拓展
	// 编码表 ASCII 字符码
	// 所有的中国字的编码表：GBK
	// 全世界的编码表：Unicode 编码表
	
	fmt.Printf("%T,%d\n", x1, x1)
	fmt.Printf("%T,%s\n", x2, x2)
	fmt.Printf("%T,%s\n", x3, x3)
}

package main

import "fmt"

func main() {

	var str1, str2, str3 string
	str1 = "hello"
	str2 = "guan"
	str3 = ","
	// 字符串的连接 用 + 号
	fmt.Println(str1 + str3 + str2)
	// 转义字符 \
	fmt.Println("hello\\guan")
	fmt.Println("hello\"guan")
	fmt.Println("hello\nguan") // \n 换行
	fmt.Println("hello\tguan") // \t 制表符
}

输出

4.数据类型的转换

在必要以及可行的情况下,一个类型的值可以被转换成另一种类型的值。由于Go语言不存在隐式类型转换，因此所有的类型转换都必须显式的声明：

valueofTypeA = typeA (valueofTypeB)

类型 A 的值=类型 A(类型 B的值)

func main() {
	a := 5.0 //  float64
	b := 8   // int

	//需求：将int类型的 b 转化为 float64 类型
	c := float64(b)
	d := int(a)

	// 整型不能转换为bool类型
	//e := bool(b)

	//fmt.Printf("%T,%f\n", e, e)
	fmt.Printf("%T,%f\n", c, c)
	fmt.Printf("%T,%d\n", d, d)

}

输出

类型转换只能在定义正确的情况下转换成功，例如从一个取值范围较小的类型转换到一个取值范围较大的类型（将int16 转换为 int32).当从取值范围较大的类型转换到取伯范围较小的类型时(将int32转换为int16或将float32转换为int) ,会发生精度丢失(截断)的情况。

五、运算符

1.算术运算符

下表列出了所有Go语言的算术运算符。假定A值为1, B值为2。

运算符	描述	实例
+	相加	A+B 输出结果 3
-	相减	A-B 输出结果 -1
*	相乘	A*B 输出结果 2
/	相除	A/B 偷出结果 0
%	求余	A % B 输山结果 1
++	自增	A++ 输出结果2
–	自减	A–输出结果 1

package main

import "fmt"

func main() {
	var a int = 1
	var b int = 2

	// + - * / % ++ --

	fmt.Println(a + b)
	fmt.Println(a - b)
	fmt.Println(a * b)
	fmt.Println(a / b)
	fmt.Println(a % b)
	a++
	fmt.Println(a)
	a--
	fmt.Println(a)

}

输出

2.关系运算符

下表列出了所有Go语言的关系运算符。假定A值为1, B值为2.

运算符	描述	实例
==	检查两个值是否相等，如果相等返回True，否则返回 False	(A == B) 为 False
!=	检查两个值是否个相等,如果不相等返回True否则返回 False	(A!=B)为True
>	检查左边值是否大于右边值，如果是返回 True，否则返回 False	(A > B) 为 False
<	检查左边值是否小于右边值,如果是返回True，否则返回False	(A < B) 为 True
>=	检查左边值是否大于等于右边的值，如果是返回 True，否则返回 False	(A > B) 为 False
<=	检查左边值是否小于右边值,如果是返回True，否则返回False	（A<=B）为 True

package main

import "fmt"

func main() {
	var a int = 1
	var b int = 2

	// ==等于  =赋值
	// 关系运算符 返回结果都是 bool值
	fmt.Println(a == b)
	fmt.Println(a != b)
	fmt.Println(a > b)
	fmt.Println(a < b)
	fmt.Println(a >= b)
	fmt.Println(a <= b)

}

输出结果

3.逻辑运算符

下表列出了所有Go语言的逻辑运算符。假设A值为True, B值为False。

运算符	描述	实例
&&	逻辑 AND 运算符。如果两边的操作数都是 True，则条件 True，否则为 False	(A && B) 为 False
||	逻辑 OR 运算符。如果两边的操作数有一个 True，则条件 True，否则为 False。	(A || B)为True
!	逻辑 NOT 运算符。如果条件为 True，则逻辑 NOT 条件 False，否则为 True。	!(A && B) 为True

package main

import "fmt"

func main() {
	var a bool = true
	var b bool = false

	// 逻辑与 && 要左右两边的表达式同时为真，才执行，结果才为真，否则为假
	// 关系运算符 返回结果都是 bool值
	fmt.Println(a && b)

	// 逻辑或 || 只要其中有一个为真，则为真，全为假则为假
	fmt.Println(a || b)
	
	// !为逻辑非，即取反，结果相反
	// a = true
	// b = false
	fmt.Println(!a) 
	fmt.Println(!b)

}

输出结果

4.位运算符

Go语言文持的位运算符如下表所示。倭定A为60, B为13:

运算符	描述	实例
&	按位与运算符"&"是双目运算符。都足1结果为1，否则足0	（A & B） 结果为 12，二进制为0000 1100
|	按位或运算符"|"是双月运算符。都是0结果为0,否则是1	（A|B）结果为 61，二进制为 0011 1101
^	按位异或运算符"^"是双目运算符。不同则为1，机同为0	(A^B)结果为49，二进制为 0011 0001
&^	位清空,a&^b，对于b上的每个数值，如果为0,则取a对应位上的数值,如果为1,则取0	(A &^ B) 结果为 48，二进制为 0011 0000
<<	左移运算符"<<“是双目运算符。左移n位就是乘以2的n次方。其功能把”<<“左边的运算数的各二进位全部左移若干位,由”<<"右边的数指定移动的位数,高位丢弃,低位补0	A<<2 结果为 240，二进制为 1111 0000
>>	右移认算符">>“是双目运算符。右移n位就是除以2的n次方。其功能是把”>>“左边的运算数的各二进制文全部右移若干位，”>>"右边的数指定移动的位数	A >> 2 结果为 15，二进制为0000 1111

package main

import "fmt"

func main() {
	// 二进制 0 1 逢二进一
	// 位运算：二进制上的 0 false 、 1 true
	// 逻辑运算符： && 只要有一个为假，则为假、 || 只要有一个为真，则为真
	// a 60 0011 1100
	// b 13 0000 1101
	// --------------------------
	// & 0000 1100 同时满足
	// | 0011 1101 一个满足就行
	// ^ 0011 0001 不同为1，相同为0
	// << 2
	// >> 2

	var a uint = 60
	var b uint = 13

	// 位运算
	var c uint = 0
	c = a & b                       //位运算
	fmt.Printf("%d,二进制%b", c, c) // 0000 1100
	fmt.Println()
	c = a | b                       //位运算
	fmt.Printf("%d,二进制%b", c, c) // 0011 1101
	fmt.Println()
	c = a ^ b                       //位运算
	fmt.Printf("%d,二进制%b", c, c) // 0011 0001
	fmt.Println()
	
	// 60 0011 1100
	c = a << 2
	fmt.Printf("%d,二进制%b", c, c) //
	fmt.Println()

	a = 60
	c = a >> 2
	fmt.Printf("%d,二进制%b", c, c) //
}

输出

5.赋值运算符

下表列出了所有Go语言的赋值认算符。

运算符	描述	实例
=	简单的赋值运算符,将一个表达式的值赋给一个左值	C=A+B将 A+B表达式结果赋值给C
+=	相加后赋值	B+=A等于B=B+A
-=	相减后再赋值	B-=A 等于 B=B-A
*=	相乘后再赋值	C*=A等于C=C*A
/=	相除后由赋值	C/=A等于C= C/A
%=	求余后再赋值	C%=A 等于 C= C % A
<<=	左移后赋值	C<<=2等于C=C<<2
>>=	右移后赋值	C>>=2等于C=C>>2
&=	按位与后赋值	C&=2 等于C=C&2
٨=	按位异或后赋值	C^=2 等于C=C^2
| =	按位或后赋值	C|=2等于 C = C|2

package main

import "fmt"

func main() {
	var a int = 21
	var c int
	//  将等号右边的值，赋值给左边
	c = a
	fmt.Printf("第 1 行  = 运算符实例,c 值为 = %d\n", c)
	c += a
	fmt.Printf("第 2 行  += 运算符实例,c 值为 = %d\n", c)
	c -= a
	fmt.Printf("第 3 行  -= 运算符实例,c 值为 = %d\n", c)
	c *= a
	fmt.Printf("第 4 行  *= 运算府实例,c 值为 = %d\n", c)
	c /= a
	fmt.Printf("第 5 行  /= 运算符实例,c 值为 = %d\n", c)
	c = 200
	c <<= 2
	fmt.Printf("第 6行  <<= 运算符实例,c值为 = %d\n", c)
	c >>= 2
	fmt.Printf("第 7 行 >>= 运算符实例,c 值为 = %d\n", c)
	c &= 2
	fmt.Printf("第 8 行  &= 运算符实例,c  值为 = %d\n", c)
	c ^= 2
	fmt.Printf("第 9 行  ^= 运算符实例,c 值为 = %d\n", c)
	c |= 2
	fmt.Printf("第 10 行 |= 运算符实例,c 值为 =%d\n", c)
}

输出

6.其他运算符

下表列出了Go语言的其他运算符

运算符	描述	实例
&	返回变量存储地址	&a；将给出变量的实际地址
*	指针变量	*a；是一个指针变量

package main

import "fmt"

func main() {
	var a int = 6
	var b int32
	var c float32
	var ptr *int

	/* 运算符实例 */
	fmt.Printf("第 1 行 a 变量类型为 = %T\n", a)
	fmt.Printf("第 2 行 b 变量类型为 = %T\n", b)
	fmt.Printf("第 3 行 c 变量类型为 = %T\n", c)

	/* & 和 * 运算符实例 */
	ptr = &a /* 'ptr' 包含了 'a' 变量的地址 */
	fmt.Printf("a 的值为 = %d\n", a)
	fmt.Printf("ptr 的值为 = %p\n", ptr)
	fmt.Printf("ptr 的值为 = %d\n", *ptr)

}

输出

六、键盘的输入和输出

package main

import "fmt"

func main() {
	var name string
	var phoneNumber string

	// 定义了两个变量，想用键盘来输入这两个变量
	//fmt.Println()  //打印并换行
	//fmt.Printf()  //格式化输出
	//fmt.Print()  //打印输出

	fmt.Println("请输入姓名和手机号码：")

	// 变量去地址 &变量
	// 指针、地址来修改和操作变量
	// Scanln 阻塞等待从键盘输入
	fmt.Scanln(&name, &phoneNumber)
	fmt.Println("name:", name)
	fmt.Println("phoneNumber:", phoneNumber)
	// fmt.Scanln() //接收输入并换行
	// fmt.Scanf()  // 接收输入，格式化输入
	// fmt.Scan()   // 接收输入

}

输出

---