GO语言学习笔记

最新推荐文章于 2024-05-10 07:30:27 发布

蓝焰鱼

最新推荐文章于 2024-05-10 07:30:27 发布

阅读量1.3k

点赞数

分类专栏：编程学习笔记文章标签： go语言 golang 开发语言

本文链接：https://blog.csdn.net/weixin_43488742/article/details/119375452

版权

GO语言学习笔记

编译命令：go build xxx.go

运行命令：go run xxx.go

格式化命令：gofmt xxx.go

格式化后重写入文件命令：gofmt -w xxx.go

第一章、GO程序开发的注意事项

1、严格区分大小写

2、每个语句后不需要加分号

3、一行只能写一条语句

4、定义的变量或import的包如果没有使用到，代码不能编译通过

5、大括号是成对出现的，缺一不可

第二章、GO语言的转义字符

1、\t：一个制表符，通常用于排版

2、\n ：换行符

3、\ ：一个\

4、" ：一个"

5、 \r ：一个回车

第三章、GO语言变量

变量 = 变量名 + 值 + 数据类型

3.1 定义变量

package main
import "fmt"
func main(){
   
    //定义变量/声明变量
    var i int //变量名在前，变量类型在后
    //给i赋值
    i = 10
    //使用变量
    fmt.Println("i=",i)
}

3.2 单变量的三种使用方式

package main
import "fmt"
func main(){
   
    //第一种：指定变量类型，声明后若不赋值，使用默认值
    //int 的默认值是0，其他类型的默认值后续会介绍
    var i int
    fmt.Println("i=",i)
    
    //第二种：根据值自行判定变量类型(类型推导)
    var num = 10.11
    fmt.Println("num=",i)
    
    //第三种：省略 var, 注意 :=左侧的变量不应该是已经声明过的，否则会导致编译错误
    //下面的方式等价 var name string   name = "tom"
    // :=的 :不能省略，否则错误
    name :="tom"
    fmt.Println("name=",i)
}

3.3 多变量的三种使用方式

package main
import "fmt"
func main(){
   
    //第一种：一次性声明同类型多个变量
    var n1,n2,n3 int
    fmt.Println("n1=",n1, "n2=",n2, "n3=",n3)

    //第二种：一次性声明不同类型多个变量
    var a1,a2,a3 =100, "tom", 88.8
    fmt.Println("a1=",a1, "a2=",a2, "a3=",a3)

    //第三种：一次性声明不同类型多个变量(类型推导)
    b1,b2,b3 :=100, "tom", 88.8
    fmt.Println("b1=",b1, "b2=",b2, "b3=",b3)
}

3.4 全局变量

package main
import "fmt"

//定义全局变量
var n1 = 100
var n2 = 8.8
var n3 = "jiho"

//上面的声明方式也可以改写成一次性声明
var(
    n4 = 200
    n5 = 9.9
    n6 = "hello"
)

func main(){
   
    fmt.Println("n1=",n1, "n2=",n2, "n3=",n3)
    fmt.Println("n4=",n4, "n5=",n5, "n6=",n6)
}

3.5 程序中 + 号的使用

1)当左右两边都是数值型时，则做加法运算

当左右两边都是字符串，则做字符串拼接

3.6 数据类型的基本介绍

请添加图片描述

3.6.1 整型

类型	有无符号	占用存储空间	表数范围
int8	有	1字节	-128~127
int16	有	2字节	-2^15~215-1
int32	有	4字节	-2^31~231-1
int64	有	8字节	-2^63~263-1

类型	有无符号	占用存储空间	表数范围
uint8	无	1字节	0~255
uint16	无	2字节	0~2^16-1
uint32	无	4字节	0~2^32-1
uint64	无	8字节	0~2^64-1

类型	有无符号	占用存储空间	表数范围	备注
int	有	32位系统4个字节 64位系统8个字节	-2^31~231-1 -2^63~263-1
uint	无	32位系统4个字节 64位系统8个字节	0~2^32-1 0~2^64-1
rune	有	与int32一样	-2^31~231-1	等价int32，表示一个Unicode码
byte	无	与uint8等价	0~255	当要存储字符时选用byte

3.6.2 整型的使用细节

Golang 各整数类型分：有符号和无符号，int uint 的大小和系统有关。
Golang 的整型默认声明为 int 型
如何在程序查看某个变量的字节大小和数据类型（使用较多）

package main
//包导入方式一
//import "fmt"
//import "unsafe"
//包导入方式二（专业级）
import (
	"fmt"
    "unsafe"
)

func main(){
   
    var a int64 =10
    //fmt.Printf：用于做格式化输出
    //Sizeof(a)：是unsafe包的一个函数，用于返回a变量占用的字节数
    //%T：查看具体数据类型；%d：查看数值大小
    fmt.Printf("a的类型%T a占用的字节数是%d",a,unsafe.Sizeof(a))
}

4)Golang 程序中整型变量在使用时，遵守保小不保大的原则，即：在保证程序正确运行下，尽量

使用占用空间小的数据类型。【如：年龄】

bit: 计算机中的最小存储单位。byte:计算机中基本存储单元。

3.7 浮点型

3.7.1 浮点型

浮点数=符号位+指数位+尾数位

类型	占用存储空间	表数范围
单精度float32	4字节	-3.403E38 ~ 3.403E38
双精度float64	8字节	-1.798E308 ~ 1.798E308

1)float64 的精度比 float32 的要准确.

2)如果我们要保存一个精度高的数，则应该选用 float6。

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

3.7.2 浮点型的使用细节

Golang 浮点类型有固定的范围和字段长度，不受具体 OS(操作系统)的影响。
Golang 的浮点型默认声明为 float64 类型。
浮点型常量有两种表示形式

十进制数形式：如：5.12 .512 (必须有小数点，等价于0.512）

科学计数法形式:如：5.1234e2 等价于 5.12 * 10 的 2 次方 5.12e-2 = 5.12 / 10 的 2 次方

5.1234E2 等价于 5.12 * 10 的 2 次方 5.12E-2 = 5.12 / 10 的 2 次方

通常情况下，应该使用 float64 ，因为它比 float32 更精确。[开发中，推荐使用 float64]

3.8 字符型

3.8.1 字符型

Golang 中没有专门的字符类型，如果要存储单个字符(字母)，一般使用 byte 来保存。
字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。也

就是说对于传统的字符串是由字符组成的，而 Go 的字符串不同，它是由字节组成的。

package main
import "fmt"

func main(){
   
    var a1 byte = 'a'
    var a2 byte = '0'

    //当我们直接输出byte值时，就是直接输出了对应的字符的码值
    fmt.Println("a1=",a1,"a2=",a2)

    //若要输出对应的字符，则需要使用格式化输出
    fmt.Printf("a1=%c a2=%c\n",a1,a2)

    //var a3 byte = '北'    //overflow溢出
    var a3 int = '北'    //改用存储空间更大的int即可
    fmt.Printf("a3=%c a3对应的码值=%d\n",a3,a3)
}

3.8.2 字符型的使用细节

字符常量是用单引号(’’)括起来的单个字符。例如：var c1 byte = ‘a’

var c2 int = ‘中’

var c3 byte = ‘9’

Go 中允许使用转义字符 '\’来将其后的字符转变为特殊字符型常量。例如：var c3 char = ‘\n’

// '\n’表示换行符

Go 语言的字符使用 UTF-8 编码，如果想查询字符对应的 utf8 码值 http://www.mytju.com/classcode/tools/encode_utf8.asp

英文字母-1 个字节汉字-3 个字节

在 Go 中，字符的本质是一个整数，直接输出时，是该字符对应的 UTF-8 编码的码值。
可以直接给某个变量赋一个数字，然后按格式化输出时%c，会输出该数字对应的 unicode 字符。
字符类型是可以进行运算的，相当于一个整数，因为它都对应有 Unicode 码.。

3.8.3 字符型的本质

字符型存储到计算机中，需要将字符对应的码值（整数）找出来。

存储：字符—>对应码值---->二进制–>存储

读取：二进制----> 码值 ----> 字符 --> 读取

字符和码值的对应关系是通过字符编码表决定的(是规定好) 。
Go 语言的编码都统一成了 utf-8。非常的方便，很统一，再也没有编码乱码的困扰了。

3.9 布尔型

3.9.1 布尔类型

布尔类型也叫 bool 类型，在GO中只能取值 true 或 false
bool 类型占 1 个字节。

package main
import (
    "fmt"
    "unsafe"
)
func main(){
   
    var b = false
    fmt.Println("b=",b)
    fmt.Println("b 的占用空间 =",unsafe.Sizeof(b))
}

bool 类型适于逻辑运算，一般用于程序流程控制

if 条件控制语句；
for 循环控制语句

3.10 字符串类型

3.10.1 字符串类型

字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本

package main
import (
    "fmt"
)

func main(){
   
    var s string = "北京欢迎您！"
    fmt.Println(s)
}

3.10.2 字符串类型的使用细节

Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本，这样 Golang 统一使用 UTF-8 编码,中文

乱码问题不会再困扰程序员。

字符串一旦赋值了，字符串就不能修改了：在 Go 中字符串是不可变的。

请添加图片描述

字符串的两种表示形式

(1) ""双引号, 会识别转义字符

(2) ``反引号，以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击、输出源代码等效果

func main(){
   
    var s string = `
    package main
    import "fmt"
    func main(){
        //定义变量/声明变量
        var i int //变量名在前，变量类型在后
        //给i赋值
        i = 10
        //使用变量
        fmt.Println("i=",i)
    }`
    fmt.Println(s)
}

字符串拼接方式

func main(){
   
    var str string = "hello" + "world"
    str += "yy"
    fmt.Println(str)
}

当一行字符串太长时，需要使用到多行字符串，可以如下处理

func main(){
   
    //将 + 号留在上一行
    var str string = "hello" + "world" +
     "hello" + "world" +
     "hello" + "world" +
     "hello" + "world"

    fmt.Println(str)
}

3.11 基本数据类型默认值

数据类型	默认值
整型	0
浮点型	0
字符串	…
	false

func main(){
   
    var a int 
    var b float32
    var c float64
    var d bool
    var e string
    //%v：按照变量的值输出
    fmt.Printf("a=%d b=%v c=%v d=%v e=%v",a,b,c,d,e)
}

3.12 数据类型的相互转换

Golang 和 java / c 不同，Go 在不同类型的变量之间赋值时需要显式转换。也就是说 Golang 中数据类型不能自动转换。

3.12.1 基本语法

表达式=T(v) //将值 v 转换为类型 T

T: 就是数据类型，比如 int32，int64，float32 等等

v: 就是需要转换的变量

func main(){
   
   var i int32 = 100
   var n1 float32 = float32(i) //将 i => float类型
   var n2 int8 = int8(i)       //高精度 -> 低精度
   var n3 int64 = int64(i)     //低精度 -> 高精度
   fmt.Printf("i=%v n1=%v n2=%v n3=%v",i ,n1,n2,n3)
}

3.12.2 注意事项

Go 中，数据类型的转换可以是从表示范围小–>表示范围大，也可以范围大—>范围小
被转换的是变量存储的数据(即值)，变量本身的数据类型并没有变化！
在转换中，比如将 int64 转成 int8 【-128—127】，编译时 不会报错 ，只是转换的结果是按

溢出处理，和我们希望的结果不一样。因此在转换时，需要考虑范围.

func main(){
   
    var n1 int32 = 12
    var n2 int8
    //var n3 int8
    n2 = int8(n1) + 127 //编译通过，但是 结果 不是127+12 ，按溢出处理
    //n3 = int8(n1) + 128 //编译不过
    fmt.Println(n2)
    //fmt.Printf(n3)
}

3.12.3 基本数据类型转string

方式 1：fmt.Sprintf("%参数", 表达式) 【个人习惯这个，灵活】

func main(){
     
   var num1 int = 99
   var num2 float64 = 23.234
   var b bool = true
   var mychar byte = 'h'
   var str string   //空的str

   str = fmt.Sprintf("%d",num1)
   fmt.Printf("str type %T str=%q\n", str, str)
   str = fmt.Sprintf("%f",num2)
   fmt.Printf("str type %T str=%q\n", str, str)
   str = fmt.Sprintf("%t",b)
   fmt.Printf("str type %T str=%q\n", str, str)
   str = fmt.Sprintf("%c",mychar)
   fmt.Printf("str type %T str=%q\n", str, str)
}

方式 2：使用 strconv 包的函数
请添加图片描述

func main(){
       
   var num1 int = 99
   var num2 float64 = 23.234
   var b bool = true
   var str string   //空的str

   str = strconv.FormatInt(int64(num1),10)  //10：十进制
   fmt.Printf("str type %T str=%q\n", str, str)
   str = strconv.FormatFloat(num2, 'f', 10, 64) //'f'：格式 10：表示小数位保留10位  64：表示这个小数是float64
   fmt.Printf("str type %T str=%q\n", str, str)
   str = strconv.FormatBool(b)
   fmt.Printf("str type %T str=%q\n", str, str)
}

3.12.4 string转基本数据类型

使用时 strconv 包的函数

请添加图片描述

func main(){
   
    var str string = "true"
    var b bool
    // b, _ = strconv.ParseBool(str) 说明
    // 1. strconv.ParseBool(str)函数会返回两个值 (value bool, err error)
    // 2. 因为我只想获取到 value bool ,不想获取 err 所以我使用 _ 忽略
    b, _  = strconv.ParseBool(str)
    fmt.Printf("b type %T b=%v\n", b, b)

    var str2 string = "123456"
    var n1 int64
    var n2 int
    n1, _ = strconv.ParseInt(str2, 10, 64)
    n2 = int(n1)
    fmt.Printf("n1 type %T n1=%v\n", n1, n1)
    fmt.Printf("n2 type %T n2=%v\n", n2, n2)

    var str3 string = "123.456"
    var f1 float64
    f1, _ = strconv.ParseFloat(str3, 64)
    fmt.Printf("f1 type %T f1=%v\n", f1, f1)
}

3.12.5 string转基本数据类型的注意事项

在将 String 类型转成基本数据类型时，要确保 String 类型能够转成有效的数据，比如我们可以

把 “123” , 转成一个整数，但是不能把 “hello” 转成一个整数，如果这样做，Golang 直接将其转成 0（默认值），其它类型也是一样的道理. float => 0 bool => false

3.13 指针

3.13.1 基本介绍

基本数据类型，变量存的就是值，也叫值类型
获取变量的地址，用&，比如： var num int, 获取 num 的地址：&num

分析一下基本数据类型在内存的布局

请添加图片描述

指针类型，指针变量存的是一个地址，这个地址指向的空间存的才是值

比如：var ptr *int = &num

举例说明：指针在内存的布局.

请添加图片描述

获取指针类型所指向的值，使用：*，比如：var ptr int, 使用ptr 获取 ptr 指向的值

func main(){
   
    //基本数据类型在内存布局
    var i int = 10
    // i 的地址是什么，&i
    fmt.Println("i的地址=", &i)

    //下面的 var ptr *int = &i
    //1. ptr 是一个指针变量
    //2. ptr 的类型 *int
    //3. ptr 本身的值&i
    var ptr *int = &i
    fmt.Printf("ptr=%v\n", ptr)
    fmt.Printf("ptr 的地址=%v\n", &ptr)
    fmt.Printf("ptr 指向的值=%v\n", *ptr)
}

5)一个案例再说明

请添加图片描述

3.13.2 通过指针修改值

写一个程序，获取一个 int 变量 num 的地址，并显示到终端
将 num 的地址赋给指针 ptr , 并通过 ptr 去修改 num 的值

func main(){
   
    var num int = 10
    var ptrx *int = &num
    fmt.Printf("num的值=%v\n", num)
    fmt.Printf("num的地址=%v\n", ptrx)

    var ptr *int = &num
    *ptr = 11
    fmt.Printf("num现在的值=%v\n", num)
    fmt.Printf("ptr的地址=%v\n", &ptr)
    fmt.Printf("ptr的值=%v\n", ptr)
    fmt.Printf("ptr指向的值=%v\n", *ptr)

}

3.13.3 指针的使用细节

值类型，都有对应的指针类型，形式为 *数据类型 ，比如 int 的对应的指针就是 *int, float32 对应的指针类型就是 *float32, 依次类推。
值类型包括：基本数据类型 int 系列, float系列, bool, string 、数组 和 结构体 struct。

3.14 值类型和引用类型

值类型：基本数据类型 int 系列, float系列, bool, string 、数组 和 结构体 struct。

引用类型：指针、slice 切片、map、管道 chan、interface 等都是引用类型。

3,14,1 值类型

值类型：变量直接存储值，内存通常在栈中分配

示意图：

3.14.2 引用类型

引用类型：变量存储的是一个地址，这个地址对应的空间才真正存储数据(值)，内存通常在堆上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾，由 GC 来回收

示意图：

3.14.3 内存的栈区和堆区

示意图

3.15 标识符的命名规范

Golang 对各种变量、方法、函数等命名时使用的字符序列称为标识符

凡是自己可以起名字的地方都叫标识符

3.15.1 命名规则

由 26 个英文字母大小写，0-9 ，_ 组成。
数字不可以开头。

var num int //√
var 3num int //×

Golang 中严格区分大小写。

var num int 
var Num int

说明：在 golang 中，num 和 Num 是两个不同的变量

标识符不能包含空格。
下划线"_"本身在 Go 中是一个特殊的标识符，称为空标识符。可以代表任何其它的标识符，但是它对应的值会被忽略(比如：忽略某个返回值)。所以仅能被作为占位符使用，不能作为标识符使用。

var _ int = 10  //×
var a_1 int = 10//√
fmt.Println(_)  //×
fmt.Println(a_1)//√

不能以系统保留关键字作为标识符（一共有 25 个），比如 break，if 等等…

3.15.2 注意事项

包名：保持 package 的名字和目录保持一致，尽量采取有意义的包名，简短，有意义，不要和标准库（fmt）冲突

变量名、函数名、常量名：采用驼峰法

举例：

var stuName string = “tom”

形式: xxxYyyyyZzzz …

var goodPrice float32 = 1234.5

如果变量名、函数名、常量名首字母大写，则可以被其他的包访问；如果首字母小写，则只能在本包中使用 ( 注：可以简单的理解成，首字母大写是公开的，首字母小写是私有的) ,在 golang 没有 public , private 等关键字。

3.16 系统保留关键字

在GO中，为了简化代码编译过程中对代码的解析，其定义的保留关键字 只有25个。

break	default	func	interface	select
case	defer	go	map	struct
chan	else	goto	package	switch
const	fallthrough	if	range	type
continue	for	import	return	var

3.17 系统的预定义标识符

除了保留关键字外，GO还提供了36个预定的标识符，其包括基础数据类型和系统內嵌函数。

append	bool	byte	cap	close	complex
complex64	complex128	uint16	copy	false	float32
float64	imag	int	int8	int16	uint32
int32	int64	iota	len	make	new
nil	panic	uint64	print	println	real
recover	string	true	uint	uint8	uintprt

第四章、运算符

4.1 算术运算符

算术运算符是对数值类型的变量进行运算的，比如：加减乘除。在 Go 程序中使用的非常多

GO语言明确不支持三元运算符

func main(){
      
    var i int = 10
    var j int = 20
    var n int
    //传统的三元运算
    //n = i > j ? i : j
    if i > j {
      
        n = i
    }else{
      
        n = j
    }
    fmt.Println("n=",n)
}

4.1.1 算术运算符表

运算	正号	负号	加	减	乘	除	取模（取余）	自增	自减	字符串相加
运算符	+	-	+	-	*	/	%	++	–	+

自增，自减的使用

func main(){
     
    var a int = 13
    a--;
    fmt.Println(a);
}

4.1.2 注意事项

对于除号 “/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。例如： x := 19/5 ,结果是 3
当对一个数取模时，可以等价 a%b=a-a/b*b ，这样我们可以看到取模的一个本质运算。
Golang 的自增自减只能当做一个独立语言使用时，不能这样使用。

请添加图片描述

Golang 的++ 和 – 只能写在变量的后面，不能写在变量的前面，即：只有 a++ a-- 没有 ++a --a

请添加图片描述

Golang 的设计者去掉 c / java 中的自增自减的容易混淆的写法，让 Golang 更加简洁，统一。(强制性的)

4.2 关系运算符(比较运算符)

关系运算符的结果都是 bool 型，也就是要么是 true，要么是 false

关系表达式经常用在 if 结构的条件中或循环结构的条件中

4.2.1 关系运算符表

运算符	运算	范例	结果
==	相等于	4==3	false
!=	不等于	4！=3	true
<	小于	4<3	false
>	大于	4>3	true
<=	小于等于	4<=3	false
>=	大于等于	4>=3	true

func main(){
   
    var a int = 4
    var b int = 5
    fmt.Println(a==b)//false
    fmt.Println(a!=b)//true
    fmt.Println(a>b)//false
    fmt.Println(a<b)//true
    fmt.Println(a>=b)//false
    fmt.Println(a<=b)//true
    flag := a>b
    fmt.Println("flag=",flag)//false
}

4.2.2 注意事项

关系运算符的结果都是 bool 型，也就是要么是 true，要么是 false。
关系运算符组成的表达式，我们称为关系表达式： a > b
比较运算符"=="不能误写成 “=”

4.3 逻辑运算符

用于连接多个条件（一般来讲就是关系表达式），最终的结果也是一个 bool 值。

4.3.1 逻辑运算符表

运算符	描述
&&	逻辑与，一假则假
\|\|	逻辑或，一真则真
！	逻辑非，取反

func main(){
   
    var age int = 40
    //if的条件只有为true时才会执行fmt.Println
    //逻辑或
    if age > 30 && age < 50 {
   
        fmt.Println("ok1")
    }
    if age > 30 && age < 40 {
   
        fmt.Println("ok2")
    }
    
    //逻辑与
    if age > 30 || age < 50 {
   
        fmt.Println("ok3")
    }
    if age > 30 || age < 40 {
   
        fmt.Println("ok4")
    }

    //逻辑非
    if age > 30 {
   
        fmt.Println("ok5")
    }
    if !(age > 30) {
   
        fmt.Println("ok6")
    }
}

4.3.2 注意事项

1)&&也叫短路与：如果第一个条件为 false，则第二个条件不会判断，最终结果为 false

||也叫短路或：如果第一个条件为 true，则第二个条件不会判断，最终结果为 true

4.4 赋值运算符

赋值运算符就是将某个运算后的值，赋给指定的变量。

4.4.1 赋值运算符表

运算符	=	+=	-=	*=	/=	%=
说明	赋值	先加后赋值	先减后赋值	先乘后赋值	先除后赋值	先取余后赋值

运算符	<<=	>>=	&=	^=	\|=
说明	先左移后赋值	先右移后赋值	按位与后赋值	按位异或后赋值	按位或后赋值

4.4.2 赋值运算符的特点

运算顺序**从右往左 **
赋值运算符的左边只能是变量,右边可以是变量、表达式、常量值
复合赋值运算符等价于下面的效果

比如：a += 3 等价于 a = a + 3

4.4.3 面试题

有两个变量，a 和 b，要求将其进行交换，但是不允许使用中间变量，最终打印结果

func main(){
   
    var a int = 10
    var b int = 20
    
    a = a + b
    b = a - b
    a = a - b
    fmt.Printf("a=%d,b=%d\n",a,b)
}

4.5 位运算符

运算符	描述	运算规则
&	按位与运算符“&”是双目运算符	一假则假
\|	按位或运算符“\|”是双目运算符	一真则真
^	按位异或运算符“^”是双目运算符	不同为真，同为假
<<	左移运算符“<<”是双目运算符	g
>>	右移运算符“>>”是双目运算符	暂未知

4.6 其它运算符说明

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

func main(){
   
    a := 100
    fmt.Println("a的地址=", &a)

    var ptr *int = &a
    fmt.Println("ptr指向的值=", *ptr)
}

4.7 课堂案例

4.7.1 案例1

求两个数的最大值

func main(){
   
    //求两个数的最大值
    var a int = 10
    var b int = 20
    var max int
    if a > b {
   
        max = a
    }else{
   
        max = b
    }
    fmt.Println(max)
}

4.7.2 案例2

求三个数的最大值

func main(){
   
    //求三个数的最大值
    var a int = 10
    var b int = 20
    var c int = 15
    var max int
    if a > b {
   
        max = a
    }else{
   
        max = b
    }
    if c > max {
   
        max = c
    }
    fmt.Println(max)
}

4.8 运算符的优先级

4.8.1 运算符的优先级的一览表

请添加图片描述

4.8.2 对上图的说明

运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如右表，上一行运算符总优先于下一行。
只有单目运算符、赋值运算符是从右向左运算的。
梳理了一个大概的优先级

1：括号，++, –

2: 单目运算

3：算术运算符

4：移位运算

5：关系运算符

6：位运算符

7：逻辑运算符

8：赋值运算符

9：逗号

4.9 键盘输入语句

在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。InputDemo.go

4.9.1 步骤：

1)导入 fmt 包

调用 fmt 包的 fmt.Scanln() 或者 fmt.Scanf()

请添加图片描述

4.9.2 课堂案例

1）使用**fmt.Scanln()**获取

func main(){
   
    var name string 
    var age byte
    var sal float32
    var ispass bool
    fmt.Println("请输入姓名：")
    fmt.Scanln(&name)
    fmt.Println("请输入年龄：")
    fmt.Scanln(&age)
    fmt.Println("请输入薪水：")
    fmt.Scanln(&sal)
    fmt.Println("请输入是否通过考试：")
    fmt.Scanln(&ispass)
    fmt.Printf("姓名：%v\n年龄：%v\n薪水：%v\n是否通过考试：%v\n",name,age,sal,ispass)
}

2）使用**fmt.Scanf() **获取

func main(){
   
    var name string 
    var age byte
    var sal float32
    var ispass bool
    fmt.Println("请输入姓名,年龄,薪水,是否通过考试;并用空格隔开：")
    fmt.Scanf("%s %d %f %t",&name ,&age, &sal, &ispass)
    fmt.Printf("姓名：%v\n年龄：%v\n薪水：%v\n是否通过考试：%v\n",name,age,sal,ispass)
}

4.10 进制

对于整数，有四种表示方式：

二进制：0,1 ，满 2 进 1。

在 golang 中，不能直接使用二进制来表示一个整数，它沿用了 c 的特点。

十进制：0-9 ，满 10 进 1。

八进制：0-7 ，满 8 进 1. 以数字 0 开头表示。

十六

最低0.47元/天解锁文章

蓝焰鱼

关注

0
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
2
评论
GO语言学习笔记

GO语言学习笔记编译命令：go build xxx.go运行命令：go run xxx.go格式化命令：gofmt xxx.go格式化后重写入文件命令：gofmt -w xxx.go第一章、GO程序开发的注意事项1、严格区分大小写2、每个语句后不需要加分号3、一行只能写一条语句4、定义的变量或import的包如果没有使用到，代码不能编译通过5、大括号是成对出现的，缺一不可第二章、GO语言的转义字符1、\t：一个制表符，通常用于排版2、\n ：换行符3、\ ：一个\4、
复制链接

扫一扫