golang高级语法及特点
golang特点
- 枚举类型 iota
- 没有char 只有rune
- go语言所有类型都有默认值
- 原生支持复数类型
- switch后可以没有表达式
- 只有for 没有while for可以不要条件 可以只有退出条件
- 函数没有缺省参数
- 数组是值类型，调用func f(arr [10]int)会 拷贝 数组
- go只有值传递没有引用传递， 所以用指针类型来补充其他语言的引用传递
- rune相当于go的char 使用utf8编码，中文占3个字节，英文一个字节
rune
package main
import "fmt"
//rune相当于go的char 使用utf8编码，中文占3个字节，英文一个字节
func main() {
s:= "ok我爱你"
fmt.Println(len(s)) // 11
fmt.Println(len([]rune(s))) // 5
fmt.Println(len([]byte(s))) // 11
// str是int32类型
for i, str := range s {
fmt.Printf("%d %c", i, str)
fmt.Println()
}
// str是byte类型
for i, str := range []byte(s) {
fmt.Printf("%d %x", i, str)
fmt.Println()
}
// str是rune类型
for i, str := range []rune(s) {
fmt.Printf("%d %c", i, str)
fmt.Println()
}
}
slice切片
- slice的底层是数组
- slice是对数组的view
- slice可以向后扩展，不可以向前扩展
- s[i]不可以超过len(s), 向后扩展不可以超越底层数组cap(s)
- slice内部维持了3个变量，ptr指针指向slice的第一个元素，len指定了slice的长度，cap指定了slice的容量。
- slice进行append时，容量不够会进行翻倍。
有如下
arr := [...]{0, 1, 2, 3, 4, 5, 6, 7}
s1 := arr[2:6]
s2 := s1[3:5]
则
s1值为[2,3,4,5], len(s1)=4, cap(s1)=6
s2值为[5,6], len(s2)=2, cap(s2)=3
slice底层是数组
slice可以向后扩展，不可以向前扩展
s[i]不可以超过len(s), 向后扩展不可以超越底层数组cap(s)
接着上题
arr := [...]{0, 1, 2, 3, 4, 5, 6, 7}
s1 := arr[2:6]
s2 := s1[3:5]
s3 := append(s2, 10)
s4 := append(s3, 11)
s5 := append(s4, 12)
则
s1值为[2,3,4,5]
s2值为[5,6]
s3值为[5,6,10]
s4值为[5,6,10,11]
s5值为[5,6,10,11,12]
arr值为[0, 1, 2, 3, 4, 5, 6, 10]
由于s4和时s5已经超过arr的cap，此时系统会生成一个新的数组，所以s4和s5是对新数组的view，即s4和s5 no longer view arr
- 添加元素时如果超越cap，系统会重新分配更大的底层数组，原来的数组被拷贝过去，如果原来的数组没人用则会被gc
- 由于值传递的关系，必须接受append的返回值
map
- go语言所以类型都有默认值
- 当map取值的key不存在时，只会返回默认值，不会报错。判断key存不存在用 key, ok := m[“key”]
- map使用哈希表，作为map的key必须可以比较相等
- 除了slice，map， function的内建类型都可以作为key
- struce类型不包含上述字段，也可以作为key
struct
- 只有使用指针才可以改变结构体内容
- nil指针也可以调用方法
- 如何扩充系统类型或者别人的类型：通过结构体继承，通过类型起别名
package main
// 如何扩充系统类型或者别人的类型：通过结构体继承，通过类型起别名
type queue []int
func (q *queue) push(v int) {
*q = append(*q, v)
}
func (q *queue) pop() int {
head := (*q)[0]
*q = (*q)[1:]
return head
}
func (q *queue) isEmpty() bool {
return len(*q) == 0
}
func main() {
}
- 值接受者vs指针接受者，
-
值接受者是go语言特有
-
要改变内容必须使用指针接受者，
-
结构过大也考虑使用指针接受者。
-
值/指针接受者都可以调用值/指针调用
package main
import "fmt"
type node struct {
value int
left, right *node
}
func newNode(value int) *node{
return &node{
value: value,
left: nil,
right: nil,
}
}
func (n node) setVal(val int) {
n.value = val
}
func (n *node) setValue(vall int) {
n.value = vall
}
func (n node) print() {
fmt.Println(n.value)
}
func (n *node) travel() {
if n == nil {
return
}
fmt.Println(n.value)
n.left.travel()
n.right.travel()
}
func main() {
var root node
root = node{}
root.left = &node{value:5}
root.right = new(node)
root.left.right = &node{4, nil, nil}
root.right.left = newNode(7)
// 调用指针方法，相当于引用传递，可以改变外部的值
root.left.setValue(100)
fmt.Println(root.left.value)
// 值传递，调用值方法，方法内部不能改变外部值
root.left.setVal(99)
fmt.Println(root.left.value)
// 先序遍历
root.travel()
}
interface
defer
