目录
Go是静态编译型语言 。Go和C语言类似，要先编译再执行，即编译型语言。Python、JavaScript等是动态解释型语言。 Go最大的优势：天生支持并发。
变量
Go语言中的变量必须先声明再使用，并且在此变量的整个生命周期内，此变量的类型不可以改变。
声明变量
Go语言中推荐使用驼峰式命名规范。
有名变量
单个变量的声明：
var s1 string // 单个变量声明多个变量同时的声明：
var (
name string
age int
sex bool
)package main
import "fmt"
// 单独声明变量(全局变量)
/*
var name string
var age int
var isOk bool
*/
// 批量声明变量类型(全局变量)
var (
name string // ""
age int // 0
sex bool // false
)
func main() {
name = "hepengli"
age = 18
sex = true
fmt.Print("You are young \n") // 打印完成直接结束（\n表示换行）
fmt.Printf("You are young:%s\n", name) // %s表示格式化输出
fmt.Println(age, sex) // 打印完成自带换行
}
You are young
You are young:hepengli
18 true其他声明变量的方式:
package main
import "fmt"
func main() {
var hobby string = "eating" // 声明变量同时赋值
fmt.Println(hobby)
var like = "sleeping" // 推导型声明变量（根据值判断该变量是什么类型）
fmt.Println(like)
st1 := "hpl" // 简短型声明变量(只能在函数中使用)
fmt.Println(st1)
}
eating
sleeping
hpl匿名变量
_(下划线)表示匿名变量，不会占用命名空间，不会为其分配内存地址
package main
import "fmt"
func foo() (int, string) {
return 18, "hpl"
}
func main() {
x, _ := foo() // _表示匿名变量，不会占用命名1空间，不会为其分配内存地址
_, y := foo()
fmt.Println("x =", x)
fmt.Println("y =", y)
}注意事项：
函数外的每个语句都必须以关键字开始（var、const、func等）
:=不能在函数外面使用
_多表示占位，表示忽略值同一个作用域不能声明同名的变量名
注意：
Go语言中声明的局部变量必须要被使用，否则编译就会报错。
例如错误如下：
package main
func main() {
var hobby string
}
.\变量.go:4:6: hobby declared but not used常量
常量的声明及基本使用
package main
import "fmt"
// 常量，定义了常量之后就是不能变化的
const num = 3.14
// 批量的声明常量
const (
num1 = 10
num2 = 20
)
// 假如批量声明的常量后面没有赋值，则表示等于上一行变量值
const (
num3 = 30
num4
num5
)
func main() {
fmt.Println(num3, num4, num5)
num6 := 666
fmt.Println(num6)
}
30 30 30
666iota
iota是Go语言中的常量计数器，只能在常量的表达式中使用。
iota在const关键字出现时将被重置为0，const中每新增一行常量声明将使iota计数一次（iota可以理解为const语句中的索引）。使用iota能简化定义，在定义枚举时很有用。
package main
import "fmt"
const (
a1 = iota // 表示a1为0
a2 // 1
a3 // 2
a4 // 3
)
func main() {
fmt.Println(a1, a2, a3, a4)
}
0 1 2 3关于iota的面试题及使
-
package main import "fmt" const ( a1 = iota // 表示a1为0 a2 // 1 _ // 2 a4 // 3 ) func main() { fmt.Println(a1, a2, a4) } -
package main import "fmt" const ( a1 = iota // 表示a1为0 a2 = 100 a3 // 100 a4 // 100 a5 = iota a6 ) func main() { fmt.Println(a1, a3, a4, a5, a6) } -
package main import "fmt" // 多个常量声明在一行 const ( a1, a2 = iota + 1, iota + 2 a3, a4 = iota + 1, iota + 2 ) func main() { fmt.Println(a1, a2, a3, a4) } -
package main import "fmt" // 定义数量级 const ( _ = iota // 扔掉 KB = 1 << (10 * iota) // 左移（1*2^10） MB = 1 << (10 * iota) // 1*2^20 GB = 1 << (10 * iota) // 1*2^30 TB = 1 << (10 * iota) // 1*2^40 PB = 1 << (10 * iota) // 1*2^50 ) func main() { fmt.Println(KB, MB, GB, TB, PB) }
基本数据类型
Go语言中有丰富的数据类型，整形、浮点型、布尔型、字符串、数组、切片、结构体、map、通道（channel）等。Go语言的基本数据类型和其他的语言基本大同小异。
整形
| 类型 | 描述 |
|---|---|
| uint8 | 无符号的8位整型（0~255） |
| uint16 | 无符号的16位整型（0~65535） |
| uint32 | 无符号的32位整型（0~4294967295） |
| uint64 | 无符号的64位整型（0~18446744073709551615） |
| int8 | 有符号的8位整型（-128~127） |
| int16 | 有符号的16位整型（-32768~32767） |
| int32 | 有符号的32位整型（-2147483648~2147483647） |
| int64 | 有符号的64位整型（-92233720368644775808~92233720368644775807） |
特殊整形
| 类型 | 描述 |
|---|---|
| uint | 32位操作系统上就是uint32，64位操作系统上就是uint64 |
| int | 32位操作系统上就是int32，64位操作系统上就是int64 |
| uintptr | 无符号整型，用于存放一个指针 |
注意： 在使用int和 uint类型时，不能假定它是32位或64位的整型，而是考虑int和uint可能在不同平台上的差异。
数字字面量语法
Go1.13版本之后引入了数字字面量语法，这样便于开发者以二进制、八进制或十六进制浮点数的格式定义数字，例如：v := 0b00101101， 代表二进制的 101101，相当于十进制的 45。 v := 0o377，代表八进制的 377，相当于十进制的 255。 v := 0xff，代表十六进制的ff，也就是十进制的255。
package main
import "fmt"
func main() {
a1 := 0b111 // 1*2^0 + 1*2^1 + 1*2^2 = 7
a2 := 0o637 // 7*8^0 + 3*8^1 + 6*8^2 = 415
a3 := 0xff // 0b 1111 1111 ==> 255
fmt.Println(a1)
fmt.Println(a2)
fmt.Println(a3)
}浮点数
Go语言支持两种浮点型数：float32和float64。这两种浮点型数据格式遵循IEEE 754标准： float32 的浮点数的最大范围约为 3.4e38，可以使用常量定义：math.MaxFloat32。 float64 的浮点数的最大范围约为 1.8e308，可以使用一个常量定义：math.MaxFloat64。
package main
import (
"fmt"
"reflect"
)
func main() {
// math.MaxFloat32 // 浮点数32位1最大值
f1 := 1.23 // Go中默认定义的是float64类型
fmt.Print(f1, reflect.TypeOf(f1))
}
1.23 float64注意：Go中默认定义的是float64类型 。
布尔型
Go语言中以bool类型进行声明布尔型数据，布尔型数据只有true（真）和false（假）两个值。
注意：
布尔类型变量的默认值为
false。Go 语言中不允许将整型强制转换为布尔型.
布尔型无法参与数值运算，也无法与其他类型进行转换。
package main
import "fmt"
func main() {
a1 := true
var a2 bool // 布尔值默认为false
fmt.Println(a1, a2)
}
true false字符串
注意：Go中的字符串必须用双引号，Go语言中的单引号表示为字符。
s := "hpl" // 字符串
// 单独的字符、汉字、符号等就是一个字符
s1 := 'a' // 字符
s2 := '和' // 字符字符串转义
| 转义符 | 含义 |
|---|---|
\r |
回车符（返回行首） |
\n |
换行符（直接跳到下一行的同列位置） |
\t |
制表符 |
\' |
单引号 |
\" |
双引号 |
\\ |
反斜杠 |
package main
import "fmt"
func main() {
str1 := "D:\\Learning_notes\\note\\GO\\go基础"
fmt.Printf("%#v\n", str1)
str2 := "'D:\\Learning_notes\\note\\GO\\go基础'"
fmt.Println(str2)
}
"D:\\Learning_notes\\note\\GO\\go基础"
'D:\Learning_notes\note\GO\go基础'定义多行字符串
package main
import "fmt"
func main() {
s2 := `
静夜思
唐 李白
床前明月光，
疑似地上霜。
举头望明月，
低头思故乡。`
fmt.Printf(s2)
}
静夜思
唐 李白
床前明月光，
疑似地上霜。
举头望明月，
低头思故乡。注意：反引号中写什么就输出什么，不用担心转义问题。
| 方法 | 介绍 |
|---|---|
| len(str)，len([]rune(str))，utf8.RuneCountInString(str) | 求长度 |
| +或fmt.Sprintf | 拼接字符串 |
| strings.Split | 分割 |
| strings.contains | 判断是否包含 |
| strings.HasPrefix,strings.HasSuffix | 前缀/后缀判断 |
| strings.Index(),strings.LastIndex() | 子串出现的位置 |
| strings.Join(a[]string, sep string) | join操作 |
package main
import (
"fmt"
"strings"
)
func main() {
name := "hepengli"
hobby := "sleeping"
fmt.Println(len(name)) // len()输出长度
fmt.Println("xxx" + "yyy")
s1 := fmt.Sprintf("%s%s", name, hobby) // 拼接并返回
fmt.Println(s1)
web := "www.baidu.com"
ret := strings.Split(web, ".") // 切割 [www baidu com]
fmt.Println(ret)
res := strings.Contains(web, "ww") // 判断web字符串中是否包含ww，包含返回true，不包含返回false
res1 := strings.Contains(web, "xxx") // 判断web字符串中是否包含xxx，包含返回true，不包含返回false
fmt.Println(res, res1)
res2 := strings.HasPrefix(web, "ww") // 判断字符串web是否是以ww开始的，是返回true，否则返回false
res3 := strings.HasSuffix(web, "sss") // 判断字符串web是否是以sss结尾的，是返回true，否则返回false
fmt.Println(res2, res3)
sss := "Nice to meet you!"
res4 := strings.Index(sss, "t") // 默认只获取第一个t所在的索引位置
fmt.Println(res4)
res5 := strings.LastIndex(sss, "t") // 返回最后一个t所在的索引位置
fmt.Println(res5)
res6 := strings.Join(ret, "+") // 用某种字符进行拼接
fmt.Println(res6)
}
8
xxxyyy
hepenglisleeping
[www baidu com]
true false
true false
5
11
www+baidu+combyte和rune类型
Go 语言的字符有以下两种：
-
uint8类型，或者叫 byte 型，代表了ASCII码的一个字符。 -
rune类型，代表一个UTF-8字符。
当需要处理中文、日文或者其他复合字符时，则需要用到rune类型。rune类型实际是一个int32。
Go 使用了特殊的 rune 类型来处理 Unicode，让基于 Unicode 的文本处理更为方便，也可以使用 byte 型进行默认字符串处理，性能和扩展性都有照顾。
package main
import "fmt"
func main() {
str1 := "Nice to meet you, 遇见你我也很高兴！"
for i := 0; i < len(str1); i++ {
fmt.Printf("%c", str1[i]) // 中文会乱码(%c输出单个字符)
}
fmt.Println()
for _, s := range str1 {
fmt.Printf("%c", s) // 中文不乱码
}
}
Nice to meet you, éè§ä½ æä¹å¾é«å´ï¼
Nice to meet you, 遇见你我也很高兴！修改字符串
要修改字符串，需要先将其转换成[]rune或[]byte，完成后再转换为string。无论哪种转换，都会重新分配内存，并复制字节数组。
package main
import "fmt"
func main() {
s1 := "hepengli"
bytes1 := []byte(s1) // 要先转换为[]byte
bytes1[0] = 's'
fmt.Println(string(bytes1))
s2 := "hello你好"
runes2 := []rune(s2) // 先转换为[]rune类型
runes2[5] = '擦'
fmt.Println(string(runes2))
}
sepengli
hello擦好类型转换
Go语言中只有强制类型转换，没有隐式类型转换。该语法只能在两个类型之间支持相互转换的时候使用。
package main
import (
"fmt"
"reflect"
)
func main() {
a1 := 222
fmt.Println(reflect.TypeOf(a1))
a2 := float64(a1)
fmt.Println(reflect.TypeOf(a2))
}
int
float64fmt.Printf中的占位符
package main
import "fmt"
// fmt中的占位符
func main() {
num := 666
str1 := "hpl"
fmt.Printf("%T:输出数据类型\n", num)
fmt.Printf("%v:输出任何类型的值\n", num)
fmt.Printf("%b:输出二进制数据\n", num)
fmt.Printf("%o:输出八进制数据\n", num)
fmt.Printf("%d:输出十进制数据\n", num)
fmt.Printf("%x:输出十六进制数据\n", num)
fmt.Printf("%s:输出字符串\n", str1)
fmt.Printf("%#v:输出带描述符", str1)
}
int:输出数据类型
666:输出任何类型的值
1010011010:输出二进制数据
1232:输出八进制数据
666:输出十进制数据
29a:输出十六进制数据
hpl:输出字符串
"hpl":输出带描述符输出类型
package main
import (
"fmt"
"reflect"
)
const a3 = 666
func main() {
fmt.Println(reflect.TypeOf(a3))
fmt.Printf("%T", a3)
}
int
int