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() // 接收输入
}
输出
