这是我参与「第三届青训营 -后端场」笔记创作活动的的第1篇笔记
一.基本语法
1.概述
1.1特点
-
高性能、高并发
- 不依赖第三方高性能标准库实现高并发
-
语法简单
-
标准库丰富
-
工具链完善
-
静态链接
-
快速编译
-
跨平台
-
垃圾回收
1.2 环境安装
- 安装Golang
- 配置集成开发环境
1.3 hello world
package main
import (
"fmt"
)
func main() {
fmt.Println("hello world")
}
运行
2.语法
2.1 基本数据类型
| 数据类型 | 描述 |
|---|---|
| 布尔型 | 布尔型的值只可以是常量 true 或者 false。 |
| 数字类型 | 整型 int 和浮点型 float32、float64，Go 语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。 |
| 字符串类型 | 字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。 |
| 派生类型 | (a) 指针类型（Pointer） (b) 数组类型 (c) 结构化类型(struct) (d) Channel 类型 (e) 函数类型 (f) 切片类型 (g) 接口类型（interface） (h) Map 类型 |
2.1.1 布尔型
布尔型的值只可以是常量 true 或者 false。
var b bool = true
2.1.2 数字类型
整型 int 和浮点型 float32、float64，Go 语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。
1.整数
| 类型 | 描述 |
|---|---|
| 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 位整型 (-9223372036854775808 到 9223372036854775807) |
2.浮点型
| 类型 | 描述 |
|---|---|
| float32 | IEEE-754 32位浮点型数 |
| float64 | IEEE-754 64位浮点型数 |
| complex64 | 32 位实数和虚数 |
| complex128 | 64 位实数和虚数 |
3.其他
| 类型 | 描述 |
|---|---|
| byte | 类似 uint8 |
| rune | 类似 int32 |
| uint | 32 或 64 位 |
| int | 与 uint 一样大小 |
| uintptr | 无符号整型，用于存放一个指针 |
2.1.3 字符串类型
字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。
2.1.4 派生类型
- (a) 指针类型（Pointer）
- (b) 数组类型
- (c) 结构化类型(struct)
- (d) Channel 类型
- (e) 函数类型
- (f) 切片类型
- (g) 接口类型（interface）
- (h) Map 类型
2.2 变量与常量
2.2.1 变量声明
Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。
// 一般声明
var identifier type
// 声明多个
var identifier1, identifier2 type
var a string = "hello world"
var b, c int = 1, 2
// 未赋值
- 数值类型（包括complex64/128）为 0
- 布尔类型为 false
- 字符串为 ""（空字符串）
- 以下几种类型为 nil：
var a *int
var a []int
var a map[string] int
var a chan int
var a func(string) int
var a error // error 是接口
//格式化输出
var i int
var f float64
var b bool
var s string
fmt.Printf("%v %v %v %q\n", i, f, b, s)
:=的用法
v_name := value
直接使用声明变量，不需要var
如果变量已经使用 var 声明过了，再使用 * := 声明变量，就产生编译错误*
var intVal int
intVal :=1 // 这时候会产生编译错误，因为 intVal 已经声明，不需要重新声明
intVal := 1 // 此时不会产生编译错误，因为有声明新的变量，因为 := 是一个声明语句
//相当于
var intVal int
intVal =1
2.2.2 常量声明
const identifier [type] = value
2.3 if-else
if后面没有括号
if a != "a" {
fmt.Println(a)
}
2.4 for
for {
// while(1)
}
for i := 0; i < 1; i++ {
}
2.5 switch
switch b {
case 1:
fmt.Println(a);
case 2:
fmt.Println(a);
default:
fmt.Println(a);
}
2.6 数组
var balance [10] float32
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
如果数组长度不确定，可以使用 ... 代替数组的长度，编译器会根据元素个数自行推断数组的长度：
var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
或
balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
2.7 切片
Go 语言切片是对数组的抽象。
Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go 中提供了一种灵活，功能强悍的内置类型切片("动态数组")，与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。
var slice1 []type = make([]type, len)
也可以简写为
slice1 := make([]type, len)
s := make([]string, 3)
s[0] = "a"
s = append(s, "a")
c := make([]string, len(s))
copy(c, s)
fmt.Println(s[1:3])
fmt.Println(s[:3])
2.8 map
m:=make(map[string]int)
m["one"]=1
fmt.Println(m)
r,ok:=m["no"]
fmt.Println(r,ok)
//判断是否存在
delete(m, "one")
2.9 range
for i,num:=range nums{
fmt.Println(i,num)
}
for k,v:=range m{
fmt.Println(k,v)
}
2.10 函数
func add(a int, b int) int {
return a + b
}
func exist(a int, b int) (and int,ok bool) {
and = a+b;
ok = false
return and,ok
}
2.11 指针
2.12 结构体
type user struct {
name string
password string
}
a := user{name: "wanga", password: "aaaa"}
fmt.Println(a)
2.13 错误处理
2.14 字符串操作
2.15 字符串格式化
2.16 JSON
2.17 时间处理
2.18 数字解析
2.19 进程信息
\
