package main
import "fmt"
func main() {
//数组 同一个类型的集合
var id [50]int
//操作数组通过下标从0开始到len()-1
for i := 0;i<len(id) ;i++ {
id[i] =i+1
fmt.Printf("id[%d]=%d\n",i,id[i])
}
}
数组基本使用
package main
import "fmt"
func main() {
//定义一个数组 [10]int和[5]int是不同类型
//[数字],数字作为数组元素个数
//注意:定义数组是 指定的数组元素个数必须是常量
var a [10]int
var b [5]int
fmt.Printf("len(a)=%d,len(b)=%d\n",len(a),len(b))
}
数组的初始化
package main
import "fmt"
func main() {
//声明定义同时腐赋值 :初始化
//1全部初始化
var a [5]int =[5]int{1,2,3,4,5}
fmt.Println("a=",a)
b :=[5]int{1,2,3,4,5}
fmt.Println("b=",b)
//2部分初始化 没有初始化的元素 自动赋值为0
c := [5]int{1,2,3}
fmt.Println("c=",c)
//3指定某个元素初始化
d :=[5]int{2:10,4:30}
fmt.Println("d=",d)
}
数组比较和赋值
package main
import "fmt"
func main() {
//支持比较 只支持==或者 !=,比较是不是每一个元素都一样,2个数组比较,数组类型要一样
a := [5]int{1,2,3,4,5}
b := [5]int{1,2,3,4,5}
c := [5]int{2,3,4}
fmt.Println("a==b",a==b)
fmt.Println("a==c",a==c)
//同类型的数组可以赋值
var d [5]int
d=a
fmt.Println("d=",d)
}
随机数
package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
//设置种子,只需要一次
//如果种子参数一样,每次运行程序产生的随机数都一样
rand.Seed(time.Now().UnixNano()) //以当前系统时间作为种子参数
for i :=0;i<5 ;i++ {
//产生随机数
//fmt.Println("rand=",rand.Int()) //随机很大的数
fmt.Println("rand=",rand.Intn(100)) //限制在100内的数
}
}
数组做函数参数
package main
import "fmt"
//数组做函数参数,它是值传递
//实参数组的每个元素给形参数组拷贝一份
//形参的数组是实参数组的复制品
func modify(a [5]int) {
a[0] =666
fmt.Println("modify a =",a)
}
func main() {
//初始化
a :=[5]int{1,2,3,4,5}
//数组传递过去
modify(a)
fmt.Println("main a =",a)
}
package main
import "fmt"
func main() {
m := map[int]string{1:"lisi",2:"wangwu",3:"hello"}
//第一个返回值为key,第二个返回值为value,遍历结果是无序的
for key,value :=range m {
fmt.Printf("%d====> %s\n",key,value)
}
//如何判断一个key值是否存在
//第一个返回值为key所对应的value,第二个返回值为key是否存在的条件,存在ok为true
value ,ok := m[0]
if ok ==true {
fmt.Printf("m[%s]",value)
}else {
fmt.Println("key不存在")
}
}
map删除
package main
import "fmt"
func main() {
m :=map[int]string{1:"lisi",2:"zhaoliu",3:"hello"}
fmt.Println("m=",m)
//删除key为1的内容
delete(m,1)
fmt.Println("m=",m)
}
map做函数参数
package main
import "fmt"
func test12(m map[int]string) {
delete(m,2)
}
func main() {
m :=map[int]string{1:"lisi",2:"wangwu",3:"zhaoliu"}
//在函数内部删除某个key
test12(m)
fmt.Println("m=",m)
}
结构体普通变量初始化
package main
import "fmt"
//定义一个结构体类型
type Student struct {
id int
name string
sex string
age int
addr string
}
func main() {
//顺序初始化,每个成员必须初始化
var s1 Student =Student{1,"hello","男",18,"USA"}
fmt.Println("s1 =",s1)
//指定成员初始化,没有初始化的成员,自动赋值为0
s2 :=Student{name:"lisi",sex:"男",addr:"Chain"}
fmt.Println("s2=",s2)
}
结构体成员的使用普通变量
package main
import "fmt"
//定义一个结构体
type Students struct {
id int
name string
sex string
age int
addr string
}
func main() {
//定义一个结构体普通变量
var s Students
//操作成员,需要使用(.)运算符
s.id = 1
s.name="hello"
s.sex = "男"
s.age = 18
s.addr = "sz"
fmt.Println("s= ",s)
}
结构体成员使用指针变量
package main
import "fmt"
//定义一个结构体
type Student1 struct {
id int
name string
sex string
age int
addr string
}
func main() {
//指针有合法指向后,才操作成员
//先定义一个普通结构变量
var s Student1
//在定义一个指针变量,保存s的地址
var p *Student1
p = &s
//通过指针操作成员 p1.id 和(*p1).id完全等价,只能使用.
p.id =1
p.name ="hello"
p.sex = "男"
p.age = 18
p.addr = "sz"
fmt.Println("p=",p)
//2通过new申请一个结构体
p1 := new(Student1)
p1.id =1
p1.name ="hello"
p1.sex = "男"
p1.age = 18
p1.addr = "sz"
fmt.Println("p1=",p1)
}