视频来源：B站《golang入门到项目实战 [最新Go语言教程，没有废话，纯干货！]》
文章为自己整理的学习笔记，侵权即删，谢谢支持！
文章目录
golang基础语法一、golang标识符、关键字、命名规范1.1 标识符概念1.2 标识符命名规则1.3 关键字1.4 命名规范1.4.1包命名1.4.2 文件命名1.4.3 结构体命名1.4.4 接口命名1.4.5 变量命名1.4.6 常量命名1.4.7 错误处理1.4.8 单元测试二 golang变量2.1 声明变量2.2 变量的初始化2.2.1 语法2.2.2 初始化多个变量2.3 短变量声明2.4 匿名变量三 golang常量3.1 定义常量3.2 特殊关键字`iota`四 golang数据类型4.1 简介4.2 布尔类型4.3 数字类型4.3.1 整型4.3.2 以二进制、八进制或十六进制浮点数的格式定义数字4.3.3 浮点型4.3.4 复数4.4 字符串类型4.4.1 golang字符串字面量4.4.2 golang字符串拼接4.4.3 golang字符串转义字符4.4.4 golang字符串切片操作4.4.5 golang字符串常用方法五 golang格式化输出5.1 普通占位符5.2 布尔占位符5.3 整数占位符5.4 浮点数和复数的组成部分(实部与虚部)5.5 字符串与字节切片5.6 指针六 基本数据类型的相互转换6.1 数据类型的基本默认值6.2 基本数据类型相互转换的基本语法6.3 基本数据类型相互转换的注意事项6.4 基本类型转字符串类型6.5 字符串类型转基本数据类型七、golang运算符7.1 算术运算符7.2 关系运算符7.3 逻辑运算符7.4 位运算符7.5 赋值运算符7.6 其他运算符7.7 运算符的优先级golang基础语法
一、golang标识符、关键字、命名规范
1.1 标识符概念
Golang 对各种变量、常量、方法、函数、结构体、数组、切片、接口命名时使用的字符序列称为标识符凡是自己可以起名字的地方都叫标识符1.2 标识符命名规则
由 26 个英文字母大小写、0-9 和 _ 组成
数字不可以开头。
Golang 中严格区分大小写。
标识符不能包含空格。
下划线_本身在 Go 中是一个特殊的标识符，称为空标识符。可以代表任何其它的标识符，但是它对应的值会被忽略(比如：忽略某个返回值)。所以仅能被作为占位符使用，不能作为标识符使用
不能以系统保留关键字作为标识符（一共有 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 psychpackage 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 boolvar hasConflict boolvar canManage boolvar allowGitHook bool
1.4.6 常量命名
常量需使用全部大写字母组成，并使用下划线分词
const APP_URL = ""
如果是枚举类型的常量，需要先创建对应类型
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:100B:100C: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:0B:1C: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:0C: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:0B:100C: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:trueb2:falseb3：trueb4:falseb5:trueb6: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=1i=2i=3i=4i=5i=6i=7i=8i=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 整型
① 有符号整数：
② 无符号整数:
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)}
运行结果：
10101077ffFF
4.3.3 浮点型
Go语言支持两种浮点型：float32和float64。这两种浮点型都遵循IEEE 754标准。
注：整型的零值为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.1415933.14
4.3.4 复数
complex64和complex128
var c1 complex64c1 = 1 + 2ivar c2 complex128c2 = 2 + 3ifmt.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 worldhtml:<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 worlds2: helloworlds3: helloworlds4: 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 worlds[n]: 108s[n:m]: los[n:]: lo worlds[: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 Worldlen(s): 11strings.Split(s, ""): [H e l l o W o r l d]strings.Contains(s, "hello"): falsestrings.ToLower(s): hello worldstrings.ToUpper(s): HELLO WORLDstrings.HasPrefix("Hello"): truestrings.HasSuffix(s, "world"): falsestrings.Index(s, "l"): 2strings.LastIndex(s, "l"): 9
五 golang格式化输出
5.1 普通占位符
说明：
注：下面实例使用到的结构体为：
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.WebSitea: int%%
5.2 布尔占位符
应用举例：
package mainimport ("fmt")type WebSite struct {Name string}func main() {b := truefmt.Printf("b: %t\n", b)}
运行结果：
b: true
5.3 整数占位符
应用举例：
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: 8i: 1000i: `i: 64i: 4d2i: 4D2
5.4 浮点数和复数的组成部分(实部与虚部)
5.5 字符串与字节切片
5.6 指针
应用举例：
package mainimport ("fmt")type WebSite struct {Name string}func main() {x := 100p := &xfmt.Printf("i: %p\n", p)}
运行结果：
i: 0xc000014098
六 基本数据类型的相互转换
6.1 数据类型的基本默认值
在 go 中，数据类型都有一个默认值，当程序员没有赋值时，就会保留默认值，在 Go 中，默认值
又叫零值。
案例：
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: 0b: 0c: 0d: falsename:
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: 100n1: 100i 的数据类型是: 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=truen1的数据类型是int64 n1=1234590n2的数据类型是int n2=1234590f1的数据类型是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 语言内置的运算符有：
算术运算符关系运算符逻辑运算符位运算符赋值运算符
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): 0a: 101b: 9
7.2 关系运算符
应用举例：
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 逻辑运算符
应用举例：
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 位运算符
位运算符对整数在内存中的二进制位进行操作。
应用举例：
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: 100b: 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: 100a: 101a: 100a: 200a: 100
7.6 其他运算符
应用举例：
package mainimport ("fmt")func main() {a := 100fmt.Println("a的地址为: ", &a)var ptr *int = &afmt.Println("ptr指向的值是: ", *ptr)}
运行结果：
a的地址为: 0xc000014098ptr指向的值是: 100
