人生苦短，Let's Go !

图片
学习网站推荐

studygolang.com

liwenzhou.com

Go语言中只有强制类型转换，没有隐式类型转换。该语法只能在两个类型之间支持相互转换的时候使用

if判断语句 for循环

package main

import “fmt”

func main() {
BREAKDEMO1:
for i := 0; i < 5; i++ {
for j := 0; j < 3; j++ {
if j == 2 {
// 设置退出标签
break BREAKDEMO1
}
fmt.Printf("%v-%v\n", i, j)
}
}
// return
// 标签
//breakTag: 相当于java的GOTO语法
fmt.Println(“结束for循环”)
}
如果跳出两层循环在退出标签处写breakTag，然后声明标签，break，continue等也可用标签跳出，虽不常用，但看起来dd的

99乘法表

package main

import “fmt”

//编写代码打印99乘法表。
func main() {
for i := 1; i <= 9; i++ {
for j := 1; j <= i; j++ {
fmt.Printf("%d * %d = %-2d ", i, j, ij)
}
fmt.Println()
}
}
图片

Array(数组)
数组是同一种数据类型元素的集合。数组大小不可变

1.基本语法

var 数组变量名 [元素数量]T
package main

import “fmt”

//数组
func main() {

var testArray [3]int
var numArray = [3]int{1,2}
var cityArray = [3]string{“北京”,“上海”,“深圳”}

fmt.Println(testArray)
fmt.Println(numArray)
fmt.Println(cityArray)

}
图片

2.编译器根据初始值的个数自行推断数组长度

var testArray [3]int //初始化 空
var numArray = […]int{1,2}
var cityArray = […]string{“北京”,“上海”,“深圳”}
3.索引赋值

a :=[…]int{1: 1,3: 5}
// var numArray = […]int{1,2}
//var cityArray = […]string{“北京”,“上海”,“深圳”}
fmt.Println(a)
图片

遍历数组

func main() {

//a :=[…]int{1: 1,3: 5}
// var numArray = […]int{1,2}
var a = […]string{“北京”,“上海”,“深圳”}
for i :=0 ; i<len(a);i++{
fmt.Println(a[i])

 }
 for index,value :=range a{
    fmt.Println(index,value)
 }

图片

二维数组

a:= [3][2]string{
{“北京”,“上海”},
{“天津”,“内蒙”},
{“成都”,“重庆”},
}
fmt.Println(a)
fmt.Println(a[2][1])

图片

二维数组的遍历

a:= [3][2]string{
{“北京”,“上海”},
{“天津”,“内蒙”},
{“成都”,“重庆”},
}
for _, v1 := range a{
for _, v2 := range v1{
fmt.Println("%s\t",v2)
}
}

切片 slice

切片（Slice）是一个拥有相同类型元素的可变长度的序列。它是基于数组类型做的一层封装。它非常灵活，支持自动扩容。

切片是一个引用类型，它的内部结构包含地址、长度和容量。切片一般用于快速地操作一块数据集合。属于引用数据类型 不能直接比较

基本语法

var name []T
切片底层还是数组

package main

import “fmt”

//数组
func main() {
var a = [3]int{1,2,3}//数组
var b = []int{1,2,3}//切片
fmt.Println(a,b)
fmt.Println(a,b)
//从数组得到切片
var c []int
c = a[0:2]//右不包含 c[:] 从开始到结束
d := a[:2]

fmt.Println©
fmt.Println(d)
//切片的大小
fmt.Println(len(b))
//切片的容量 底层数组最大能放多少
x := […]string{“北京”,“上海”,“深圳”,“西安”}
y := x[1:4]
fmt.Println(y)
fmt.Println(len(y))
fmt.Println(cap(y))//x 从1开始
//切片再切片 以上注释掉
var a = [5]int{1,2,3,4,5}//数组
// var b = []int{1,2,3}//切片

//切片再切片
s := a[1:3] // s := a[low:high]
fmt.Printf(“s:%v len(s):%v cap(s):%v\n”, s, len(s), cap(s))
s2 := s[3:4] // 索引的上限是cap(s)而不是len(s)
fmt.Printf(“s2:%v len(s2):%v cap(s2):%v\n”, s2, len(s2), cap(s2))
}
图片

low则默认为0；省略了high则默认为切片操作数的长度

对于数组或字符串，如果0 <= low <= high <= len(a)，则索引合法，否则就会索引越界（out of range）。

切片的本质

切片的本质就是对底层数组的封装，它包含了三个信息：底层数组的指针、切片的长度（len）和切片的容量（cap）。

要检查切片是否为空，请始终使用len(s) == 0

var a =[]int{}//切片
fmt.Printf(“a:%v len:%d cap:%d ptr:%p\n”,a,len(a),cap(a), &a)
a= append(a,1)
fmt.Printf(“a:%v len:%d cap:%d ptr:%p\n”,a,len(a),cap(a), &a)
a= append(a,1)
fmt.Printf(“a:%v len:%d cap:%d ptr:%p\n”,a,len(a),cap(a), &a)
a= append(a,1)
fmt.Printf(“a:%v len:%d cap:%d ptr:%p\n”,a,len(a),cap(a), &a)
a= append(a,1)
fmt.Printf(“a:%v len:%d cap:%d ptr:%p\n”,a,len(a),cap(a), &a)
注:语法非常严格，注意各种符号位

图片

地址值指向一样