package main
import"fmt"funcmain(){
fmt.Println("----数字----")//uint8(别名"byte",0-255), uint16, uint32, uint64var a uint8=255var b byte=255
n1 := a + b
//int8(-128-127), int16, int32(别名"rune"), int(默认,不能与int32互用),int64var c rune=10var d int32=10
n2 := c + d
//float32, float64(默认)var n3 =3.14
fmt.Println(n1)//254
fmt.Printf("%T %T %T \n", n1, n2, n3)
fmt.Println("----字符串----")
str :="hallo "
str +="world"//使用“+”拼接字符串//不能直接更改单个字符,拆成字节切片,修改后转回字符串
s :=[]byte(str)
fmt.Println(s)
s[1]='e'
str =string(s)
fmt.Println(str)//字符串可以切割
str ="I like the "+ str[6:]
fmt.Println(str)
fmt.Println("----常量----")//特殊常量iota,在 const关键字出现时将被重置为 0,const 中每新增一行常量声明将使 iota 计数一次const(
A =iota
B
C string="C"
D
E =iota)const F =iota
fmt.Println(A, B, C, D, E, F)}
二、指针
package main
import"fmt"funcmain(){
var a int=4//一个指针变量通常缩写为ptr,空指针为nilvar ptr *int
fmt.Println(ptr ==nil)
ptr =&a
fmt.Printf("ptr类型为%T\n", ptr)
fmt.Println("ptr值为", ptr)
fmt.Printf("*ptr值为%d\n",*ptr)}
package main
import"fmt"type Human struct{
Name string
Age int}//组合,相当于类继承type Student struct{
Human
Number int}funcmain(){
me := Student{
Human : Human{
Name:"abc"},
Number:67373,//换行结束时此处必须有逗号}//两种形式皆可获得,未赋值Age数字类型默认为0
me.Age =1
me.Human.Age =2
fmt.Println(me)// 可以使用 new 去创建,但是返回的是指针类型
you :=new(Student)
you.Number =18//指针类型不能.属性,这里做了语法糖,其实是(*you).Number
fmt.Printf("%T\n", you)//匿名结构体,临时使用
his :=struct{
name string
age uint8}{
"his",34}// 可以不指定key,值列表形式
fmt.Println(his)}
六、函数
package main
import"fmt"//多个返回值funcfn1(c int)(d int,e int){
d,e = c +1, c +2return}funcfn2(c int)(int,int){
return c +1, c +2}//不定参数生成反转数组funcfn3(arg ...int)[]int{
length :=len(arg)
s :=make([]int, length)for i :=0; i < length; i++{
s[i]= arg[length - i -1]}return s
}// 专有函数,也就是方法,作用于特定类型,需要有接收者// 举例先声明一个结构体type Me struct{
name string}// 这里的变量名应使用结构体首字母小写,不要用this或者selffunc(m *Me) say (){
fmt.Println("我是"+ m.name)}funcmain(){
c :=1//多返回值
d,e :=fn1(c)
f,g :=fn2(c)
fmt.Println(d, e, f, g)//不定参数
s :=fn3(1,2,3,4)
fmt.Println(s)//say不能直接调用
me := Me{
"张三"}//new(Me)
me.say()}
七、接口
package main
import"fmt"funcmain(){
//空接口可以传任何类型type Element interface{
}//一个空接口类型的切片的值可以是任意类型
list :=[]Element{
1,"Hello",'e'}
fmt.Println(list)//断言类型
val,ok := list[0].(int)
fmt.Println(val,ok)//使用接口类型var phone Phone =new(Huawei)//这里必须取址,等同&Huawei{}
phone.call()}//定义接口type Phone interface{
call()}//定义结构体type Huawei struct{
}//接口实现方法func(huawei *Huawei)call(){
fmt.Println("我用华为打电话")}
八、并发goruntine
package main
import("fmt""runtime")funcmain(){
fmt.Printf("CPU数量%d \n",runtime.NumCPU())
runtime.GOMAXPROCS(3)//设置可以并行计算的CPU核数,返回之前的值for i :=0; i <10; i++{
fmt.Println(i)//固定顺序,被gorutine穿插gofunc(i int){
fmt.Printf("goruntine%d\n", i)}(i)//输出的数量不固定,顺序不固定}}
九、chan通道
package main
import("fmt""time")//通道可以声明接收或者发送类型// type Sender chan<- int// type Receiver <-chan intfuncmain(){
//默认非缓存阻塞的,即第二个参数默认0.//设置缓存数量,可以直接写入,(再直接写入会报错),其后的可以通过goruntine写入
c :=make(chanint,2)
c <-1
c <-2gofunc(c chan<-int){
for i :=3; i <6; i++{
c <- i
fmt.Println("发送",i)}close(c)}(c)//1,2可以直接读取,goruntine不一定这时候有没有发送,所以此时等待,接收到便读取,直到closefor i :=range c {
fmt.Println("接收", i)}// 让main函数执行结束的时间延迟1秒,// 以使上面两个代码块有机会被执行。
time.Sleep(time.Second)}