最简单的免费网站制作模板,长春做网站推荐选吉网传媒好,搭建免费个人网站2022,wordpress的登录地址文章目录 基础语法值变量常量运算符指针new 和 make 区别 字符串byte 和 rune 类型 流程控制for 循环If else 分支switch 分支 基础语法
项目代码地址#xff1a;02-basicgrammar
值
基本类型值
Go 最基础的数据类型#xff0c;比如整型、浮点型、布尔型。
复合类型值
… 文章目录 基础语法值变量常量运算符指针new 和 make 区别 字符串byte 和 rune 类型 流程控制for 循环If else 分支switch 分支 基础语法
项目代码地址02-basicgrammar
值
基本类型值
Go 最基础的数据类型比如整型、浮点型、布尔型。
复合类型值
由基本类型组成的复杂数据类型比如数组、切片、结构体、函数、map、通道、接口、字符串。
指针类型值
指针类型的变量与指针类型值绑定它内部存储的是另外一个内存单元的地址。 简单示例
// 值
func function01() {fmt.Println(123_456) // 123456fmt.Println(go lang) // golangfmt.Println(1 1 , 11) // 1 1 2fmt.Println(3 / 2 , 3/2) // 3 / 2 1fmt.Println(7.0 / 3 , 7.0/3) // 7.0 / 3 2.3333333333333335fmt.Println(true false) // falsefmt.Println(true || false) // truefmt.Println(!true) // false
}Go 中的值类型和引用类型
值类型int系列、float系列、bool、string、数组、结构体引用类型指针、slice切片、管道channel、接口interface、map、函数
值类型变量直接存储值内存通常在栈中分配 引用类型变量存储的是一个地址地址空间存储真正的值内存通常在堆中分配
在Go语言中所有东西都是以值的形式存在的只有值传递没有引用传递。
传值你是你我是我传指针你是你我是我但我们共同指向他传“引用”你是你我是我但我们有一部分共同指向他
// 指针类型
func function02() {a : 1ptr : func(b *int) {fmt.Println(b, b) // 0xc000088028 0xc00000a0c8*b 2fmt.Println(*b) // 2}fmt.Println(a) // 0xc00000a0c8ptr(a)fmt.Println(a) // 2
}// 引用类型
func function03() {s : []int{1, 2}ref : func(a []int) {fmt.Printf(%p\n, a) // 0xc000008060a[1] 0fmt.Println(a) // [1 0]}fmt.Printf(%p\n, s) // 0xc000008048ref(s)fmt.Println(s) // [1 0]
}不难看出上述在传递参数过程中都是进行值传递的。尽管切片是引用类型但传递时仍然会拷贝新的变量只不过新变量的底层结构有对另一个基础类型的指向。
Go 的引用类型不同于 C 的引用引用并不是同一个地址不过底层指针是同一个指向。
对比 C 的引用引用传递地址不变a,b变量共享同一地址
#includeiostream
using namespace std;struct Node {int a, b, c;
};void func(Node a) {cout a endl; // 0x7ffc43a4a21c
}int main() {Node b {1, 2, 3};func(b);cout b endl; // 0x7ffc43a4a21creturn 0;
}额外补充切片容易踩的坑
切片在运行时由三个字段构成值拷贝创建副本也就是对 Data、Len、Cap字段进行拷贝而 Data 指针指向与原slice 同一地址。
type SliceHeader struct {Data uintptr // 指向底层数组的指针Len int // 切片长度Cap int // 切片容量
}所以在副本中修改元素时原 slice 的元素也会被修改。但是修改的是副本的 Len、Cap 时原 slice 保持不变。如果副本由于扩容导致 Data 地址重新分配那么之后副本的操作完全无法影响到原 slice。
// 传引用
func function04() {a : make([]int, 1, 2) // 指定len(a)1,cap(a)2a[0] 1fmt.Println(len(a), cap(a), a) // 1 2 [1]ref : func(b []int) {b[0] 4fmt.Println(len(b), cap(b), b, len(a), cap(a), a) // 1 2 [4] 1 2 [4]b append(b, 2)fmt.Println(len(b), cap(b), b, len(a), cap(a), a) // 2 2 [4 2] 1 2 [4]b[0] 0fmt.Println(len(b), cap(b), b, len(a), cap(a), a) // 2 2 [0 2] 1 2 [0]b append(b, 3)fmt.Println(len(b), cap(b), b, len(a), cap(a), a) // 3 4 [0 2 3] 1 2 [0]b[0] 1fmt.Println(len(b), cap(b), b, len(a), cap(a), a) // 3 4 [1 2 3] 1 2 [0]}ref(a)
}上面的例子阐明了两点
“引用” 是我们共同一部分指向它b 添加元素后len 变为 2而原 a 的 len 还是 1所以切片的第一个元素是被共同指向的扩容后“引用”的元素地址改变b 扩容后cap 变为 4Data 地址改变再修改第一个元素时不再能影响原 a 的元素
如果上述不能理解可以先放着等下章学习了切片等类型后再来回顾。 变量
常用两种声明变量格式 var 用来声明变量标准声明格式var 变量名 变量类型 : 短变量只能用于声明局部变量不能用于全局变量声明即在函数或方法内部使用。
变量只声明未初始化则为默认值。
// 变量
func function05() {var a int64 // 声明未初始化默认 int64(0)var b string ABC // 标准声明并初始化var c 1 // 自动类型推导var d, e 2, 3 // 一次初始化多个变量// 批量声明var (f float64 3.1g bool false)h : .1 // 简短变量声明fmt.Println(a, b, c, d, e, f, g, h) // 0 ABC 1 2 3 3.1 false 0.1
}常量
var 换为 const 即可定义常量
// 常量
func function06() {const pi 3.1415// 同时声明多个常量某个常量省略值则和上一个相同const (e 2.7182a // 2.7182b // 2.7182c 3d // 3)// iota 预声明标识符表示连续的无类型整数常量初始值 0const (level1 iota 1 // 1level2 // 2level3 // 3_ // 跳过某些值level5 // 5n 1000 // 在 iota 声明中插队level6 iota // 6, 需要再使用 iota)// 多个 iota 定义在一行iota 值逐行增加const (A, B iota 1, iota 2 // 1 2C, D // 2 3E, F // 3 4)// 用来定义数量级const (_ iotaKB 1 (10 * iota) // 1 (10 * 1)MB 1 (10 * iota) // 1 (10 * 2)GM 1 (10 * iota) // 1 (10 * 3)TB 1 (10 * iota) // 1 (10 * 4))
}运算符
需要注意的是
(自增) 和 --(自减) 在 Go 中是单独的语句并不属于运算符^ 按位清除z : x ^ yy 中位 1z 位 0y 中位 0z 位为 x 位
// 运算符
func function10() {var a intafmt.Println(a) // 1// b : a-- 错误i、i--只能单独使用// a 错误没有 i、--i 操作x : 11y : (1 0) | (1 3) // 保证 z 中的第 0 位和第 3 位为 0z : x ^ yfmt.Printf(x %b\n, x)fmt.Println(\t^)fmt.Printf(y %b\n, y)fmt.Println(————————)fmt.Printf(z %04b\n, z)/*x 1011^y 1001————————z 0010*/
}指针
指针用法和其他语言类似而且 Go 中使用了垃圾回收机制不需要手动释放内存。
// 指针
func function15() {str : 123var strPtr *string strfmt.Println(str, *strPtr) // 123 123fmt.Println(str, strPtr, strPtr) // 0xc000026070 0xc000026070 0xc000088020
}new 和 make 区别
Go 语言中 new 和 make 是内建的两个函数主要用来分配内存。 new用于类型的内存分配返回值是一个指向新分配类型零值的指针 make只用于 slice、map、channel 初始化返回这三个引用类型本身
// new、make
func function16() {a : new(bool)fmt.Printf(%T %t %v\n, a, *a, a) // *bool false 0xc000192068b : make([]int, 1, 2)fmt.Printf(%T %v %p %p %p\n, b, b, b, b, b[0]) // []int [0] 0xc0001920b0 0xc000190030 0xc0001920b0
}这里重点关注 make 后返回的切片引用类型本身 b可见 b 和 b[0] 的地址是一样的都是指向底层数组的指针。而 b 则是表示当前这个切片结构体的地址。 字符串
在运行时字符串类型表示如下
type StringHeader struct {Data uintptr // 指向底层字节数组指针Len int // 字节数组长度
}Go 在编程语言层面对值做了限制常量值是不可变的字符串类型值是不可变的其他则为可变值。
Go 中只允许用双引号和反引号定义字符串使用单引号定义字符类型。字符串是一个只读的 byte 类型切片组成每个字符串的元素叫字符字符变量默认 rune 型。
// 字符串
func function07() {s1 : 123s2 : 字符串s3 : 第一行
第二行
第三行
// s1[0] 4 // 不能修改s1 456 // 123456fmt.Println(len(s1), len(s2), len(s3)) // 3 9 30
}byte 和 rune 类型
Go 语言字符有两种类型byte 代表 ASCII 码的一个字符rune 代表一个 UTF-8 字符。
byte 型本质上是 uint8rune 型本质上是 int32
特殊的 rune 类型表示 Unicode 编码的整数能让基于 Unicode 的文本处理更方便比如处理中文或其他复合字符。 内建函数 len() 函数用来获取字符串的 ASCII 字符个数或字节长度。Go 语言的字符串都以 UTF-8 格式保存每个中文占用 3 个字节 unicode/utf8 包提供的 utf8.RuneCountInString() 函数用来统计 Unicode 字符数量 unsafe 包提供的 unsafe.Sizeof 返回数据类型的大小 for 循环遍历对应 ASCII 码for range 遍历对应 Unicode 码
// byte、rune
func function08() {var a avar b byte bfmt.Println(unsafe.Sizeof(a), unsafe.Sizeof(b)) // 4 1s1 : Golang语言fmt.Println(len(s1), utf8.RuneCountInString(s1)) // 12 8for i : 0; i len(s1); i {fmt.Printf(%c, s1[i])} // Golangè¯è¨fmt.Println()for _, s : range s1 {fmt.Printf(%c, s)} // Golang语言
}读者可能会疑惑之前代码中 s1 456 这不是修改了字符串本身了吗
func function09() {// 仅声明字符串var str stringvar stringHeader (*reflect.StringHeader)(unsafe.Pointer(str))fmt.Printf(%p %p %d\n, str, unsafe.Pointer(stringHeader.Data), stringHeader.Len)// 字符串赋值str 快速入门fmt.Printf(%p %p %d\n, str, unsafe.Pointer(stringHeader.Data), stringHeader.Len)// 字符串拼接str GO语言fmt.Printf(%p %p %d\n, str, unsafe.Pointer(stringHeader.Data), stringHeader.Len)// 字符串转 byte 切片var bytes []byte(str)fmt.Printf(%p %p %d\n, bytes, unsafe.Pointer(stringHeader.Data), stringHeader.Len)bytes[3] 1fmt.Println(str)// 0拷贝 byte 切片转换var bytes1 *(*[]byte)(unsafe.Pointer(str))fmt.Printf(%p %p %d\n, bytes1, unsafe.Pointer(stringHeader.Data), stringHeader.Len)bytes1[3] 1fmt.Println(str)
}0xc000026070 0x0 0 0xc000026070 0x541808 12 0xc000026070 0xc000012108 20 0xc000012120 0xc000012108 20 快速入门GO语言 0xc000012108 0xc000012108 20 快入门GO语言 unsafe.Pointer 类似于 C 语言中的 void * 指针能接收任意类型的指针变量转为通用型指针再可强转为其他指针类型。
分析上述代码字符串在赋值和拼接后实际变量的地址没发生变化但是 stringHeader 的 Data 字节数组改变了地址证明字符串本身不可被修改变的是内部的字节数组。上述进行了强转 byte 字节数组会实际拷贝一份 string 内部的字节数组要想实现 0 拷贝则可通过 unsafe.Pointer 转换。 流程控制
for 循环
基本格式
for 初始语句; 条件表达式; 结束语句 {循环体
}for - range 循环
数组、切片、字符串返回索引和值map返回键和值通道channel只返回通道内的值
基本格式
for k, v : range x {
}常见的循环写法
// for
func function11() {i : 1for i 2 {fmt.Println(i)i} // 1for j : 8; j 9; j {fmt.Println(j)} // 8for {fmt.Println(loop)break} // loopfor n : 1; n 3; n {if n%2 0 {continue}fmt.Println(n)} // 1 3var num int
flag:numfor num 3 {fmt.Println(num)goto flag} // 1 2 3s : []int{11, 12}for k, v : range s {fmt.Println(k, v)} // 0 11; 1 12
}If else 分支
// if-else
func function12() {score : 70if score 60 {fmt.Println(不及格)} else if score 60 score 80 {fmt.Println(良好)} else {fmt.Println(优秀)} // 良好if err : 1; err ! 0 {fmt.Println(没有出错)} // 没有出错
}switch 分支
switch 不同于 C 语言break 不写会跳出 case并且一个分支可以有多个值
// switch case
func function13() {switch suf : .a; suf {case .html:fmt.Println(页面)case .doc, .txt:fmt.Println(文档)case .js:fmt.Println(脚本文件)default:fmt.Println(其它后缀)} // 其它后缀
}为了兼容 C 语言的 case 设计fallthrough 语法可以执行满足条件的 case 的下一个case
// fallthrough
func function14() {var suf .docswitch suf {case .html:fmt.Println(页面)case .doc:fmt.Println(文档)fallthroughcase .js:fmt.Println(脚本文件)default:fmt.Println(其它后缀)} // 文档 脚本文件
}
