使用关键字 var 定义变量, 自动初始化为零值. 如果提供初始化值, 可省略变量类型.
在函数内部, 可用更简略的 := 方式定义变量. 空白符号_
- package main
- import "fmt"
- func test() {
- data, _, i := [3]int{0, 1, 2}, 2, 0 // 函数内部:= 定义变量数组 data[0],data[1],data[2]并赋值 0,1,2, 且 i=0
- i, data[i] = 2, 100 // (data[0] = 100),(i = 0) -> (i = 2) | 从右往左赋值
- fmt.Println(i, data[i], data[0])
- }
- func main() {
- test()
- }
输出结果:
2 2 100
有关指针详见 go 语言的指针 * 和 & https://studygolang.com/articles/7412
& 符号的意思是对变量取地址, 如: 变量 a 的地址是 & a
* 符号的意思是对指针取值, 如:*(&a), 就是 a 变量所在地址的值, 等于 a
- package main
- import "fmt"
- func main() {
- s := "abc"
- fmt.Println(&s) //s 的地址
- s, y := "hello", 20 // 重新赋值(地址还是它): 与前 s 在同一层次的代码块中, 且有新的变量被定义.
- fmt.Println(&s, y) // 通常函数多返回值 err 会被重复使用.
- {
- s, z := 1000, 30 // 定义新同名变量(新地址存放新变量): 不在同一层次代码块.
- fmt.Println(&s, z)
- }
- }
输出结果:
- 0xc0000461f0
- 0xc0000461f0 20
- 0xc000014110 30
- package main
- import (
- "fmt"
- )
- func main() {
- var a int = 1
- var b *int = &a //*b=*&a=a, b=&a(a 的地址)
- var c **int = &b // 定义 **c=**&b=*b=*&a=a,*c=b=&a,c=&b(b 的地址),&c(c 的地址)
- var x int = *b //x=*b=a
- fmt.Println("a =",a)
- fmt.Println("&a =",&a)
- fmt.Println("*b =",*b)
- fmt.Println("b =",b)
- fmt.Println("&b =",&b)
- fmt.Println("**c =",**c)
- fmt.Println("c =",c)
- fmt.Println("&c =",&c)
- fmt.Println("x =",x)
- x, y := 1, 2
- ar := [...]*int{&x, &y} // 指针数组(是数组)
- fmt.Println(ar)
- }
输出结果:
- a = 1
- &a = 0xc0000140d8
- *b = 1
- b = 0xc0000140d8
- &b = 0xc000006028
- **c = 1
- c = 0xc000006028
- &c = 0xc000006030
- x = 1
- [0xc00001c0d8 0xc00001c0f0]
枚举
关键字 iota 定义常量组中从 0 开始按行计数的自增枚举值. 如果 iota 自增被打断, 须显式恢复.
- const (
- A = iota // 0
- B // 1
- C = "c" // c
- D // c, 与上? 一? 行相同.
- E = iota // 4, 显式恢复. 注意计数包含了 C,D 两? 行.
- F // 5
- )
使用 "" 定义不做转义处理的原始字符串, 支持跨行. ```go s :=a
- b\r\n\x00
- c`
- println(s)
- ```
输出结果:
a
b\r\n\x00
c
要修改字符串, 可先将其转换成 []rune 或 []byte, 完成后再转换为 string. 无论哪种转换, 都会重新分配内存, 并复制字节数组.
- package main
- import "fmt"
- func main() {
- s := "ab" +
- "cd"
- bs := []byte(s)
- bs[3] = 'D'
- fmt.Println(string(bs))
- u := "电脑"
- us := []rune(u) // 中文 rune
- us[1] = '话'
- fmt.Println(string(us))
- }
输出结果:
abcD
电话
用 for 循环遍历字符串时, 也有 byte 和 rune 两种方式.
- package main
- import "fmt"
- func main() {
- s := "abc 汉字"
- for i := 0; i <len(s); i++ { // byte
- fmt.Printf("%c,", s[i])
- }
- fmt.Println()
- for _, r := range s { // rune
- fmt.Printf("%c,", r)
- }
- }
输出结果:
a,b,c,?,±,?,?,-,?,
a,b,c, 汉, 字,
switch 对应着 case. 语句对语句,
- import (
- "fmt"
- )
- func main() {
- switch a := 1; {
- case a>= 0:
- fmt.Println("a>=0")
- fallthrough
- case a>= 1:
- fmt.Println("a>=1")
- default:
- fmt.Println("Defalut")
- }
- }
输出结果:
a>=0
a>=1
跳转语句 goto(调整执行位置),continue(跳出当前循环),break(退出)配合标签可用于多层循环的跳出
指向数组的指针 (new 关键字创建的数组返回的也是指向数组的指针) 和指针数组
- a := [...]int{
- 9: 4
- }
- fmt.Println(a)
- var p *[10]int = &a // 指向数组的指针(是指针)
- fmt.Println(p)
- n := new([10]int)
- fmt.Println(n)
- /*
- x, y := 1, 2
- ar := [...]*int{
- &x, &y
- } // 指针数组(是数组)
- fmt.Println(ar) // 输出[0xc00001c0d8 0xc00001c0f0]
- */
输出结果:
- [0 0 0 0 0 0 0 0 0 4]
- &[0 0 0 0 0 0 0 0 0 4]
- &[0 0 0 0 0 0 0 0 0 0]
Go 学习笔记(持续更中, 参考 go 编程基础, go 边看边练)
来源: http://www.bubuko.com/infodetail-3301498.html