视频来源：B站《golang入门到项目实战 [2022最新Go语言教程，没有废话，纯干货！]》

文章为自己整理的学习笔记，侵权即删，谢谢支持！

golang基础语法

一、golang标识符、关键字、命名规范

1.1 标识符概念

1. Golang 对各种变量、常量、方法、函数、结构体、数组、切片、接口命名时使用的字符序列称为标识符
2. 凡是自己可以起名字的地方都叫标识符

1.2 标识符命名规则

1. 由 26 个英文字母大小写、0-9 和 _ 组成

2. 数字不可以开头。

3. Golang 中严格区分大小写。

4. 标识符不能包含空格。

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

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

举例：

正确的命名

package mainimport "fmt"func main(){var name stringvar age intvar _sys int
}

错误的命名

package mainimport "fmt"func main(){var 1name stringvar &age intvar !abc
}

hello // ok
hello12 //ok
1hello // error ,不能以数字开头
h-b // error ,不能使用 -
x h // error, 不能含有空格

h_4 // ok
_ab // ok
int // ok , 我们要求大家不要这样使用
float32 // ok , 我们要求大家不要这样使用
_ // error
Abc // ok

1.3 关键字

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

除了以上介绍的这些关键字，Go语言还有36个预定义标识符，其中包含了基本类型的名称和一些基本的内置函数，如下：

1.4 命名规范

命名规范设计变量、常量、全局函数、结构、方法等等的命名。

Go语言从语法层面进行了以下限定：任何需要对外暴露的名字必须以大写字母开头，不需要对外暴露的则以小写字母开头。

当一个命名以一个大写字母开头，如GetUserName，那么使用这种形式的标识符的对象就可以被外部包的代码使用（客户端程序需要先导入这个包），这被称为导出（如面向对象语言中的public）；命名如果以小写字母开头，则对包外是不可兼得，但是他们在整个包的内部是可见的并且可用的（如面向对象语言中的private）

1.4.1包命名

保持package的名字和目录保持一致，尽量采用有意义的包名，简短、有意义且尽量和标准库不要冲突。包命应该为小写单词，不要使用下划线或者混合大小写。

package psych
package service

1.4.2 文件命名

尽量采用有意义且简短的文件名，应为小写单词，使用下划线分隔各个单词

customer_dao.go

1.4.3 结构体命名

采用驼峰命名法，首字母根据访问控制大小写

struct 声明和初始化格式采用多行，例：

type CustomerOrder struct{Name stringAddress string
}
order := CustomerOder{"psych","四川成都"}

1.4.4 接口命名

命名规则基本上与上面结构体类似

单个函数的结构名以“er”作为后缀，例如Reader，Writer

type Reader interface{Read(p []byte)(n int,err error)
}

1.4.5 变量命名

和结构体类似，一般遵循驼峰命名法，首字母根据访问控制大小写，但遇到特有名词时，需要遵循以下规则：

如果变量为私有，且特有名词为首个单词，则使用小写，如 appService；若变量为bool类型，则名称应以has、is、can或allow开头

var isExist bool
var hasConflict bool
var canManage bool
var allowGitHook bool

1.4.6 常量命名

常量需使用全部大写字母组成，并使用下划线分词

const APP_URL = "https://www.baidu.com"

如果是枚举类型的常量，需要先创建对应类型

type Scheme stringconst{HTTP Scheme = "http"HTTPS Scheme = "https"
}

1.4.7 错误处理

错误处理的原则是不能丢弃任何有返回err的调用，不要使用_丢弃，必须全部处理。接收到错误，要么返回err，或者使用log记录下来尽早return；一旦有错误发生，马上返回，尽量不要使用panic，除非你知道你在做什么，错误描述如果是英文必须为小写，不需要标点结束，采用独立的错误流进行处理

1.4.8 单元测试

单元测试文件命名规则为example_test.go 测试用例的函数名称必须以Test开头，例如：TestExample每个重要的函数都要首先编写测试用例，测试用例和正规代码一起提交方便进行回归测试

二 golang变量

变量相当于内存中一个数据存储空间的表示，不同的变量保存的数据类型可能会不一样。你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到房间，同样的道理，通过变量名可以访问到变量(值)。

2.1 声明变量

Go语言中的变量需要声明后才能使用，同一作用域内不支持重复声明，并且Go语言的变量声明后必须使用。

语法

var identifier type

var：声明变量关键字

identifier：变量名称

type：变量类型

例如：

package mainimport "fmt"func main（）{var name stringvar age intvar married bool
}

批量声明

使用一个var关键字，把一些变量写在一个括号()里

package mainimport "fmt"func main（）{var (name stringage intmarried bool)
}

2.2 变量的初始化

Go语言在声明变量的时候，会自动对变量对应的内存区域进行初始化，每个变量会被初始化成其他类型的默认值，例如：整型和浮点型变量的默认值为0；字符串变量的默认值为空字符串""。bool类型变量默认为false；切片、函数、指针变量的默认值为nil

2.2.1 语法

var 变量名 类型 = 表达式

例如：

package mainimport "fmt"func main（）{var name string = "Psych"var age int = 18var married bool = False
}

2.2.2 初始化多个变量

可一次性初始化多个变量，中间用逗号隔开

package mainimport "fmt"func main（）{var name, age, married = "Psych", 18, False
}

2.3 短变量声明

在函数内部可以用:=运算符对变量进行声明和初始化

package mainimport "fmt"func main（）{name := "Psych"age := 18married := False
}

注：此方法只适用于函数内部，函数外部不可使用

2.4 匿名变量

若我们接收到多个变量，有一些变量使用不到，则可使用_表示变量名称，这种变量即为匿名变量

package mainimport "fmt"func getNameAndAge(string, int){return "Psych", 18
}func main（）{name, _ := getNameAndAge()fmt.Printf("name: %v\n", name)
}

三 golang常量

常量即为程序在编译阶段就已经确定的值，而程序运行时则无法改变该值，即一旦定义则无法修改。

在Go中常量可以为数值类型、布尔类型或者字符串类型等。

3.1 定义常量

语法：

const constantName [type] = value

const:定义常量的关键字

constantName:常量名称

type：常量类型（可省略）

value:常量的值

举例：

package mainimport "fmt"func main（）{//单常量声明：const PI float64 = 3.14const PI2 = 3.1415 //可省略类型//多常量声明：const （W = 100H = 100）//多重赋值const i, j = 1, 2const a, b, c = 3, 4, "foo"
}

注：const 同时声明多个常量时，若省略了值则表示和和上面一行值相同

package mainimport "fmt"func main（）{const （A = 100B C）fmt.Printf("A: %v\n", A)fmt.Printf("B: %v\n", B)fmt.Printf("C: %v\n", C)}

其运行结果为：

A:100
B:100
C:100

3.2 特殊关键字iota

iota可被认为是一个可被编译修改的常量，其默认值为0，每次调用一次则加1，遇到const关键字时被重置为0

package mainimport "fmt"func main（）{const （A = iota //0B = iota //1(i++)C = iota //2）fmt.Printf("A: %v\n", A)fmt.Printf("B: %v\n", B)fmt.Printf("C: %v\n", C)}

运行结果：

A:0
B:1
C:2

使用_可跳过某些值

package mainimport "fmt"func main（）{const （A = iota //0_          //1C = iota //2 ）fmt.Printf("A: %v\n", A)fmt.Printf("C: %v\n", C)}

运行结果为

A:0
C:2

iota可声明中间插队

package mainimport "fmt"func main（）{const （A = iota //0B = 100C = iota //2）fmt.Printf("A: %v\n", A)fmt.Printf("B: %v\n", B)fmt.Printf("C: %v\n", C)}

运行结果为：

A:0
B:100
C:2

四 golang数据类型

4.1 简介

在Go语言中，数据类型用于声明函数和变量。每一种数据都定义了明确的数据类型，在内重中分配了不同大小的内存空间。

Go也有基于架构的类型，例如：int、uint、uintptr

浮点型：

其他数字类型：

4.2 布尔类型

布尔类型也叫 bool 类型，bool 类型数据只允许取值 true 和 false。bool 类型的数据占 1 个字节。布尔类型适于逻辑运算，一般用于程序流程控制中的条件控制语句，或者循环控制语句

package mainimport "fmt"func main（）{var b1 bool = truevar b2 bool = falsevar b3 = true //也可省略类型var b4 = falseb5 := true //短变量形式b6 := falsefmt.Printf("b1: %v\n", b1)fmt.Printf("b2: %v\n", b2)fmt.Printf("b3: %v\n", b3)fmt.Printf("b4: %v\n", b4)fmt.Printf("b5: %v\n", b5)fmt.Printf("b6: %v\n", b6)}

运行结果为：

b1:true
b2:false
b3：true
b4:false
b5:true
b6:false

用于if条件控制语句中：

package mainimport "fmt"func main（）{age := 18adult := age >= 18 // 此处adult数据类型为bool型fmt.Printf("adult: %v\n",adult)if adult {fmt.Printf("成年人")}else {fmt.Printf("未成年")}
}

运行结果为：

adult: true
成年人

用于循环控制语句中：

package mainimport "fmt"func main（）{count := 10for i := 0;i < count; i++ { // 此处i<count返回值为bool类型fmt.Printf("i=%v\n", i)}
}

运行结果为：

i=1
i=2
i=3
i=4
i=5
i=6
i=7
i=8
i=9

用于逻辑表达式中：

package mainimport "fmt"func main（）{age := 18gender := "男"if age >= 18 && gender == "男" {fmt.Printf("是成年男性")}}
}

注：不能使用0或者非0表示真假

package mainimport "fmt"func main（）{i := 1if i {// 此时编译出错}
}

4.3 数字类型

Go语言支持整型和浮点型数字，并原生支持复数，其中位的运算采用补码。

Go语言中也有基于架构的类型，如int、uint和uintptr。这些类型的长度都是根据运行程序所在的操作系统类型所决定的：

• int和uint在32位操作系统上，它们均使用32位（即4个字节）；在64位操作系统上，它们均使用64位（即8个字节）

• uintptr的长度被设定为足够存放一个指针即可

注：Go语言中没有float类型（只有float32和float64），也没有double类型。

与操作系统架构无关的类型都有固定的大小：

4.3.1 整型

① 有符号整数：

类型	有无符号	表示范围
int8	有	-128 ~ 127
int16	有	-2^15 ~ 2^15 - 1
int32	有	-2^31 ~ 2^31 - 1
int64	有	-2^63 ~ 2^63 - 1

② 无符号整数:

类型	有无符号	表示范围
uint8	无	0 ~ 255
uint16	无	0 ~ 2^16 - 1
uint32	无	0 ~ 2^32 - 1
uint64	无	0 ~ 2^64 - 1

4.3.2 以二进制、八进制或十六进制浮点数的格式定义数字

package mainimport "fmt"func main（）{// 十进制var a int = 10fmt.Printf("%d \n", a)fmt.Printf("%b \n", a) //占位符%b表示二进制// 八进制（以0开头）var b int = 077fmt.Printf("%o \n", b)// 十六进制（以0x开头）var c int = 0xfffmt.Printf("%x \n", c)fmt.Printf("%X \n", c)}

运行结果：

10
1010
77
ff
FF

4.3.3 浮点型

Go语言支持两种浮点型：float32和float64。这两种浮点型都遵循IEEE 754标准。

类型	表示范围
float32	-3.403E38 ~ 3.408E38
float64	-1.798E308 ~ 1.798E308

注：整型的零值为0，浮点型的零值为0.0

float32可以使用一个常量定义：math.MaxFloat32

float64可以使用一个常量定义：math.MaxFloat64

打印浮点数时可使用fmt包配合动词%f，例如：

package mainimport ("fmt""math"
)func main（）{fmt.Printf("%f \n", math.Pi)fmt.Printf("%.2f \n", math.Pi) // %.2f值取小数点后两位
}

运行结果为：

3.141593
3.14

4.3.4 复数

complex64和complex128

var c1 complex64
c1 = 1 + 2i
var c2 complex128
c2 = 2 + 3i
fmt.Printf(c1)
fmt.Printf(c2)

复数有实部和虚部，complex64 的实部和虚部为32位 complex128 的实部和虚部为64位

4.4 字符串类型

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

4.4.1 golang字符串字面量

在Go语言中，字符串字面量使用双引号""或者反引号``来创建。

双引号""： 用于创建可解析的字符串，会识别转义字符，但不用来引用多行。应用广泛。
反引号``：用于创建原生的字符串，以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击、输出源代码等效果，但不支持转义。多用于书写多行消息、HTML以及正则表达式。

package mainimport "fmt"func main（）{var str1 string = "hello world"var html string = `<html><head><title>hello Go</title><html>`fmt.Printf("str1: %v\n", str1)fmt.Printf("html: %v\n", html)
}

运行结果

str1: hello world
html:
<html><head><title>hello Go</title>
</html>

4.4.2 golang字符串拼接

① 使用加号拼接

Go语言支持+级联操作和+=追加操作

package mainimport "fmt"func main（）{str1 := "Psych"str2 := "永远18岁"msg := str1 + str2fmt.Printf("msg: %v\n", msg)
}

运行结果：

msg: Psych永远18岁

注：由于golang里的字符串都是不变的，每次运算都会产生一个新的字符串，所以会产生很多临时的无用的字符串，因此会给pc带来额外的负担导致性能变差

② 使用fmt.Sprintf()函数

package mainimport "fmt"func main（）{str1 := "Psych"str2 := "永远18岁"msg := fmt.Sprint("%s,%s", str1, str2)fmt.Printf("msg: %v\n", msg)
}

运行结果：

msg: Psych,永远18岁

注：内部使用[]byte实现，不想直接运算符这种会产生很多临时的字符串，但是内部逻辑很复杂，有很多额外的判断，还用到了interface，因此性能也不是很好。

③ 使用strings.Join()

package mainimport "fmt"func main（）{str1 := "Psych"str2 := "永远18岁"msg := strings.Join([]string{str1, str2}, ",")fmt.Printf("msg: %v\n", msg)
}

运行结果：

msg: Psych,永远18岁

注：Join会先根据字符串数组的内容，计算出一个拼接之后的长度，然后申请对应大小的内存，将一个一个字符串依次填入，在已有一个数组的情况下，此方法效率会很高，但是若未存在此数组，则构造这个数据的代价也不小。

④ 使用buffer.WriteString()

package mainimport "fmt"func main（）{var buffer bytes.Bufferbuffer.WriteString("Psych")buffer.WriteString(",")buffer.WriteString("永远18岁")fmt.Printf("buffer.String(): %v\n", buffer.String())
}

运行结果：

buffer.String(): Psych，永远18岁

注：此方法较为理想，可当成可变字符使用，对内存的增长也有优化，若能预估字符串的长度，还可使用buffer.Grow()接口来设置capacity

4.4.3 golang字符串转义字符

应用举例：

package mainimport "fmt"func main() {s1 := "hello world"fmt.Printf("s1: %v\n", s1)s2 := "hello\nworld" // 制表符四个空格fmt.Printf("s2: %v\n", s2)s3 := "hello\tworld"fmt.Printf("s3: %v\n", s3)s4 := "c:\\program files\\a"fmt.Printf("s4: %v\n", s4)}

运行结果

s1: hello world
s2: hello
world
s3: hello   world
s4: c:\program files\a

4.4.4 golang字符串切片操作

package mainimport "fmt"func main() {s := "hello world"n := 3m := 5fmt.Printf("s: %v\n", s)fmt.Printf("s[n]: %v\n", s[n])     // 获取字符串索引位置为 n 的原始字节fmt.Printf("s[n:m]: %v\n", s[n:m]) // 截取字符串索引位置为 n 到 m-1 的字符串fmt.Printf("s[n:]: %v\n", s[n:])   // 截取字符串索引位置为 n 到 len(s)-1 的字符串fmt.Printf("s[:m]: %v\n", s[:m])   // 截取字符串索引位置为 0 到 m-1 的字符串}

运行结果：

s: hello world
s[n]: 108
s[n:m]: lo
s[n:]: lo world
s[:m]: hello

4.4.5 golang字符串常用方法

应用举例：

package mainimport ("fmt""strings"
)func main() {s := "Hello World"fmt.Printf("s: %v\n", s)fmt.Printf("len(s): %v\n", len(s))fmt.Printf("strings.Split(s, \"\"): %v\n", strings.Split(s, ""))                 // 得到的是一个数组fmt.Printf("strings.Contains(s, \"hello\"): %v\n", strings.Contains(s, "hello")) // 是否包含hellofmt.Printf("strings.ToLower(s): %v\n", strings.ToLower(s))                       // 全部小写fmt.Printf("strings.ToUpper(s): %v\n", strings.ToUpper(s))                       // 全部大写fmt.Printf("strings.HasPrefix(\"Hello\"): %v\n", strings.HasPrefix(s, "Hello"))    // 判断前缀fmt.Printf("strings.HasSuffix(s, \"world\"): %v\n", strings.HasSuffix(s, "world")) // 判断后缀（区分大小写）fmt.Printf("strings.Index(s, \"l\"): %v\n", strings.Index(s, "l"))         // 第一次出现l的索引位置fmt.Printf("strings.LastIndex(s, \"l\"): %v\n", strings.LastIndex(s, "l")) // 最后一次出现l的索引位置}

运行结果：

s: Hello World
len(s): 11
strings.Split(s, ""): [H e l l o   W o r l d]
strings.Contains(s, "hello"): false
strings.ToLower(s): hello world
strings.ToUpper(s): HELLO WORLD
strings.HasPrefix("Hello"): true
strings.HasSuffix(s, "world"): false
strings.Index(s, "l"): 2
strings.LastIndex(s, "l"): 9

五 golang格式化输出

5.1 普通占位符

说明：

占位符	说明
%v	相应值的默认格式
%+v	打印结构体时，添加字段名
%#v	相应值的Go语言语法表示
%T	相应值的类型的Go语言语法表示
%%	字面上的百分号，并非值的占位符

注：下面实例使用到的结构体为：

type Website struct {Name string
}// 定义结构体变量
var site = Website{Name: "duoke360"}

应用举例：

package mainimport ("fmt"
)type WebSite struct {Name string
}func main() {site := WebSite{Name: "duoke360"}fmt.Printf("site: %v\n", site)fmt.Printf("site: %#v\n", site)fmt.Printf("site: %T\n", site)a := 100fmt.Printf("a: %T\n", a)fmt.Println("%%")
}

运行结果：

site: {duoke360}
site: main.WebSite{Name:"duoke360"}
site: main.WebSite
a: int
%%

5.2 布尔占位符

占位符	说明
%t	单词true或false

应用举例：

package mainimport ("fmt"
)type WebSite struct {Name string
}func main() {b := truefmt.Printf("b: %t\n", b)
}

运行结果：

b: true

5.3 整数占位符

占位符	说明
%b	二进制表示
%c	相应unicode码点所表示的字符
%d	十进制表示
%o	八进制表示
%q	单引号围绕的字符字面值，由Go语言安全地转义
%x	十六进制表示，字母形式为小写 a-f
%X	十六进制表示，字母形式为大写 A-F
%U	Unicode格式：U+1234，等同于 “U+%04X”

应用举例：

package mainimport ("fmt"
)type WebSite struct {Name string
}func main() {i := 8fmt.Printf("i: %v\n", i)fmt.Printf("i: %b\n", i)i = 96fmt.Printf("i: %c\n", i)fmt.Printf("i: %x\n", 100)fmt.Printf("i: %x\n", 1234)fmt.Printf("i: %X\n", 1234)
}

运行结果：

i: 8
i: 1000
i: `
i: 64
i: 4d2
i: 4D2

5.4 浮点数和复数的组成部分(实部与虚部)

占位符	说明
%b	无小数部分的，指数为二的幂的科学计数法，与strconv.FormatFloat 的 'b' 转换格式一致。例如 -123456p-78
%e	科学计数法，例如 -1234.456e+78
%E	科学计数法，例如 -1234.456E+78
%f	有小数点而无指数，例如 123.456
%g	根据情况选择 %e 或 %f 以产生更紧凑的（无末尾的0）输出
%G	根据情况选择 %E 或 %f 以产生更紧凑的（无末尾的0）输出

5.5 字符串与字节切片

占位符	说明
%s	输出字符串表示（string类型或[]byte)
%q	双引号围绕的字符串，由Go语法安全地转义
%x	十六进制，小写字母，每字节两个字符
%X	十六进制，大写字母，每字节两个字符

5.6 指针

占位符	说明
%p	十六进制表示，前缀 0x

应用举例：

package mainimport ("fmt"
)type WebSite struct {Name string
}func main() {x := 100p := &xfmt.Printf("i: %p\n", p)
}

运行结果：

i: 0xc000014098

六 基本数据类型的相互转换

6.1 数据类型的基本默认值

在 go 中，数据类型都有一个默认值，当程序员没有赋值时，就会保留默认值，在 Go 中，默认值
又叫零值。

数据类型	默认值
整型	0
浮点型	0
字符串	“”
布尔类型	false

案例：

package mainimport "fmt"func main() {var a intvar b float32var c float64var d boolvar name stringfmt.Printf("a: %v\n", a)fmt.Printf("b: %v\n", b)fmt.Printf("c: %v\n", c)fmt.Printf("d: %v\n", d)fmt.Printf("name: %v\n", name)
}

运行结果：

a: 0
b: 0
c: 0
d: false
name:

6.2 基本数据类型相互转换的基本语法

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

表达式为 T(v)即将值v转换为类型T，其中T: 就是数据类型，比如 int32，int64，float32 等；v: 就是需要转换的变量

案例：

package mainimport "fmt"func main() {var i int32 = 100// 将i =》 floatvar n1 float32 = float32(i)var n2 int16 = int16(i)var n3 int8 = int8(i)fmt.Printf("i: %v\n", i)fmt.Printf("n1: %v\n", n1)fmt.Printf("n2: %v\n", n2)fmt.Printf("n3: %v\n", n3)
}

6.3 基本数据类型相互转换的注意事项

① Go 中，数据类型的转换可以是从 表示范围小–>表示范围大，也可以 范围大—>范围小

② 被转换的是变量存储的数据(即值)，变量本身的数据类型并没有变化！例如：

package mainimport "fmt"func main() {var i int32 = 100var n1 float32 = float32(i)fmt.Printf("i: %v\n", i)fmt.Printf("n1: %v\n", n1)fmt.Printf("i 的数据类型是: %T\n", i)
}

i: 100
n1: 100
i 的数据类型是: int32

③ 在转换中，比如将 int64 转成 int8，编译时不会报错，只是转换的结果是按溢出处理，和我们希望的结果不一样。 因此在转换时，需要考虑范围.

package mainimport "fmt"func main() {var n1 int64 = 999999var n2 int8 = int8(n1)fmt.Printf("n2: %v\n", n2)}

n2: 63

6.4 基本类型转字符串类型

① 使用fmt.Sprintf

语法：fmt.Sprintf("%参数", 表达式)

根据参数生成格式化的字符串并返回该字符串

应用实例：

package mainimport "fmt"func main() {var n1 int = 99var n2 float64 = 23.456var n3 bool = truevar n4 byte = 'h'var str stringstr = fmt.Sprintf("%d", n1)fmt.Printf("str的数据类型是%T str=%q\n", str, str)str = fmt.Sprintf("%f", n2)fmt.Printf("str的数据类型是%T str=%q\n", str, str)str = fmt.Sprintf("%t", n3)fmt.Printf("str的数据类型是%T str=%q\n", str, str)str = fmt.Sprintf("%c", n4)fmt.Printf("str的数据类型是%T str=%q\n", str, str)}

运行结果：

str的数据类型是string str="99"
str的数据类型是string str="23.456000"
str的数据类型是string str="true"
str的数据类型是string str="h"

② 使用 strconv 包的函数

应用实例：

package mainimport ("fmt""strconv"
)func main() {var n1 int = 99var n2 float64 = 23.456var n3 bool = truevar str stringstr = strconv.FormatInt(int64(n1), 10)fmt.Printf("str的数据类型是: %T str=%q\n", str, str)str = strconv.FormatFloat(n2, 'f', 10, 64)// 其中'f'格式10表示小数位保留10位，64表示这个小数是float64fmt.Printf("str的数据类型是: %T str=%q\n", str, str)str = strconv.FormatBool(n3)fmt.Printf("str的数据类型是: %T str=%q\n", str, str)}

运行结果：

str的数据类型是: string str="99"
str的数据类型是: string str="23.4560000000"
str的数据类型是: string str="true"

6.5 字符串类型转基本数据类型

使用strconv包的函数：

应用举例：

package mainimport ("fmt""strconv"
)func main() {var str1 string = "true"var b boolb, _ = strconv.ParseBool(str1)// strconv.ParseBool(str)函数会返回两个值（value bool , err error）// 因此只想获取value bool 而不想获取err，则可使用_忽略fmt.Printf("b的数据类型是 %T b=%v\n", b, b)var str2 string = "1234590"var n1 int64var n2 intn1, _ = strconv.ParseInt(str2, 10, 64)n2 = int(n1)fmt.Printf("n1的数据类型是%T n1=%v\n", n1, n1)fmt.Printf("n2的数据类型是%T n2=%v\n", n2, n2)var str3 string = "123.456"var f1 float64f1, _ = strconv.ParseFloat(str3, 64)fmt.Printf("f1的数据类型是%T f1=%v\n", f1, f1)}

运行结果:

b的数据类型是 bool b=true
n1的数据类型是int64 n1=1234590
n2的数据类型是int n2=1234590
f1的数据类型是float64 f1=123.456

注：在将 String 类型转成 基本数据类型时，要确保 String 类型能够转成有效的数据，比如 我们可以把 “123” , 转成一个整数，但是不能把 “hello” 转成一个整数，如果这样做，Golang 直接将其转成 0 ，其它类型也是一样的道理. float => 0 或bool => false

package mainimport ("fmt""strconv"
)func main() {var str1 string = "hello"var n int64 = 11n, _ = strconv.ParseInt(str1, 10, 64)fmt.Printf("n的数据类型是 %T n=%v\n", n, n)
}
// n的数据类型是 int64 n=0

七、golang运算符

Go 语言内置的运算符有：

1. 算术运算符
2. 关系运算符
3. 逻辑运算符
4. 位运算符
5. 赋值运算符

7.1 算术运算符

运算符	描述
+	相加
-	相减
*	相乘
/	相除
%	求余

注意： ++（自增）和 --（自减）在Go语言中是单独的语句，并不是运算符，因此不能这样使用：

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

应用举例：

package mainimport "fmt"func main() {a := 100b := 10fmt.Printf("(a + b): %v\n", (a + b))fmt.Printf("(a - b): %v\n", (a - b))fmt.Printf("(a * b): %v\n", (a * b))fmt.Printf("(a / b): %v\n", (a / b))fmt.Printf("(a %% b): %v\n", (a % b))a++fmt.Printf("a: %v\n", a)b--fmt.Printf("b: %v\n", b)
}

运行结果：

(a + b): 110
(a - b): 90
(a * b): 1000
(a / b): 10
(a % b): 0
a: 101
b: 9

7.2 关系运算符

运算符	描述
==	检查两个值是否相等，如果相等返回 True 否则返回 False。
!=	检查两个值是否不相等，如果不相等返回 True 否则返回 False。
>	检查左边值是否大于右边值，如果是返回 True 否则返回 False。
>=	检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。
<	检查左边值是否小于右边值，如果是返回 True 否则返回 False。
<=	检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。

应用举例：

package mainimport "fmt"func main() {a := 1b := 2fmt.Printf("(a > b): %v\n", (a > b))fmt.Printf("(a < b): %v\n", (a < b))fmt.Printf("(a >= b): %v\n", (a >= b))fmt.Printf("(a <= b): %v\n", (a <= b))fmt.Printf("(a == b): %v\n", (a == b))fmt.Printf("(a != b): %v\n", (a != b))
}

运行结果：

(a > b): false
(a < b): true
(a >= b): false
(a <= b): true
(a == b): false
(a != b): true

7.3 逻辑运算符

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

应用举例：

package mainimport "fmt"func main() {a := trueb := falsefmt.Printf("(a && b): %v\n", (a && b))fmt.Printf("(a || b): %v\n", (a || b))fmt.Printf("(!a): %v\n", (!a))fmt.Printf("(!b): %v\n", (!b))
}

运行结果：

(a && b): false
(a || b): true
(!a): false
(!b): true

7.4 位运算符

位运算符对整数在内存中的二进制位进行操作。

运算符	描述
&	参与运算的两数各对应的二进位相与。 （两位均为1才为1）
|	参与运算的两数各对应的二进位相或。 （两位有一个为1就为1）
^	参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。 （两位不一样则为1）
<<	左移n位就是乘以2的n次方。 “a<<b”是把a的各二进位全部左移b位，高位丢弃，低位补0。
>>	右移n位就是除以2的n次方。 “a>>b”是把a的各二进位全部右移b位。

应用举例：

package mainimport "fmt"func main() {a := 4 // 二进制 100fmt.Printf("a: %b\n", a)b := 8 // 二进制 1000fmt.Printf("b: %b\n", b)fmt.Printf("(a & b): %v, %b \n", (a & b), (a & b))fmt.Printf("(a | b): %v, %b\n", (a | b), (a | b))fmt.Printf("(a ^ b): %v, %b\n", (a ^ b), (a ^ b))fmt.Printf("(a << 2): %v, %b\n", (a << 2), (a << 2))fmt.Printf("(b >> 2): %v, %b\n", (b >> 2), (b >> 2))
}

运行结果：

a: 100
b: 1000
(a & b): 0, 0
(a | b): 12, 1100
(a ^ b): 12, 1100
(a << 2): 16, 10000
(b >> 2): 2, 10

7.5 赋值运算符

运算符	描述
=	简单的赋值运算符，将一个表达式的值赋给一个左值
+=	相加后再赋值
-=	相减后再赋值
*=	相乘后再赋值
/=	相除后再赋值
%=	求余后再赋值
<<=	按位左移后赋值
>>=	按位右移后赋值
&=	按位与后赋值
|=	按位或后赋值
^=	按位异或后赋值

应用举例：

package mainimport "fmt"func main() {var a inta = 100fmt.Printf("a: %v\n", a)a += 1 // a = a + 1fmt.Printf("a: %v\n", a)a -= 1 // a = a -1fmt.Printf("a: %v\n", a)a *= 2 // a = a * 2fmt.Printf("a: %v\n", a)a /= 2 // a = a / 2fmt.Printf("a: %v\n", a)
}

运行结果：

a: 100
a: 101
a: 100
a: 200
a: 100

7.6 其他运算符

运算符	描述
&	返回变量存储地址
*	指针变量

应用举例：

package mainimport ("fmt"
)func main() {a := 100fmt.Println("a的地址为: ", &a)var ptr *int = &afmt.Println("ptr指向的值是: ", *ptr)
}

运行结果：

a的地址为:  0xc000014098
ptr指向的值是:  100

7.7 运算符的优先级

Go语言学习笔记—golang基础语法相关推荐

1. Go语言学习笔记—golang基础简介

   视频来源:B站<golang入门到项目实战 [2022最新Go语言教程,没有废话,纯干货!]> 文章为自己整理的学习笔记,侵权即删,谢谢支持! 文章目录 一.Go语言简述 二.Go语言特点 ...

2. Go语言学习笔记之基础语法（一）

   目录 1. Go语言介绍 Go语言是什么 Go语言优势 Go适合用来做什么 2. Go环境搭建 通过Sublime 编译运行go程序 学习资料 3. 第一个Go程序 通过命令行运行程序 4. 基础语法 ...

3. java基本语法心得_Java学习笔记(一)——基础语法(上)

   Java学习笔记(一)--基础语法(上) 软件构造 写在前面 编写Java程序时,应注意以下几点:大小写敏感:Java是大小写敏感的,这就意味着标识符Hello与hello是不同的. 类名:对于所有的 ...

4. Java学习笔记之基础语法（一）

   目录 前言 一.基础语法 基础概念 运算符 数据输入Scanner 条件判断 循环 Random 二.IDEA安装与使用 IDEA项目结构介绍 IDEA中HelloWorld步骤 IDEA快捷键 前言 ...

5. Vue2.0学习笔记二 基础语法

   1. Mustache语法 Mustache语法也叫插值表达式,Mustache语法式通过{{}}渲染到页面,并且数据是响应式的. 数据的响应式:数据的变化导致页面的内容随之变化 效果图: 2. 指令 ...

6. Python学习笔记(2)-基础语法

   1 ########### python基础语法 ################### 2 3 #标识符 4 #第一个字符必须是字母表中字母或下划线-- 5 #标识符的其他部分有字母,数字和下划线组 ...

7. python学习笔记：基础语法

   目录 python语言概述 python基础语法 python标准数据类型 1.数字类型 2.字符串类型 3.列表类型 4.元组 5.字典 python基础语法 1.条件判断语句 2.循环语句 3.函 ...

8. 【Erlang】学习笔记-erlang基础语法

   一.关于erlang erlang是函数式编程语言,最初主要用在电信软件开发,他是面向并发编程的,和主流语言相比,主流语言并不能很好的利用多核CPU的资源,采取加锁的方式使得编程易出错,且锁也是耗资源 ...

9. PHP学习笔记01——基础语法

   1 <!DOCTYPE html> 2 <html> 3 <?php 4 // 1.使用$加变量名来表示变量,php是弱类型语言,不要求在使用变量前声明,第一次赋值时变量 ...

最新文章

1. 【Linux - mysql】怎么修改数据库编码
2. 前端学习（710）：命名规范和语法格式
3. FreeSql （十）更新数据
4. hdu 3037 Lucas定理
5. tiny_mce的本地图片上传插件
6. 【Word】批量修改Word 图片大小
7. js 获取浏览器经纬度精确到100米（chrome,firefox等大浏览器，ios，安卓亲测可用）
8. DRM:Digital Rights Management数字版权加密保护技术
9. 谈谈MATLAB数字滤波器频域响应
10. SVA16.14并发断言翻译笔记$inferred_clock和$inferred_disable（六）
11. 初学unity（简单的视觉欺骗）
12. Visual Assist X 10.9 builds 2333 with patch.7z
13. 2.3 构建C语言入职教程
14. 巧用千寻位置GNSS软件|逐点放样应用技巧
15. 【“计算机科学与技术”专业小白成长系列】Linux Shell 编程 极简教程
16. 在Mac机上用命令idevice_id -l来查udid和ideviceinstaller -l来查看bundleId出现错误
17. 实验二利用自动机理论实现词法分析器
18. 如何在ubuntu中设置webcam
19. 一款炫酷Loading动画--加载失败
20. !!! 格式塔原理及应用

热门文章

1. 韦德是梦八“救火队员“
2. Realsense L515 例程详解 Tutorial 1
3. xp 解除计算机锁定,Windows XP锁定屏幕的三种方法
4. 云课堂计算机教室怎么使用,云课堂计算机教室解决方案 3.0
5. Java调用Zebra条码打印机打印条码、中英文数字条码混合标签，可自由控制格式和排版
6. PCL Super4PCS点云粗配准（源码编译）
7. 计算机xp系统怎么录音,XP系统电脑怎么录音？ - KK录像机
8. 2021辽宁省赛-I.完美主义-M.比赛
9. 《权力的游戏》剧情解析全靠它！
10. mkdocs 部署教程