GO入门笔记

时间 2019-12-08

标签入门笔记繁體版

原文原文链接

GO笔记整理

Golang内置关键字python

//Go内置关键字（25个均为小写）
/* break default func interface select case defer go map struct chan else goto package switch const fallthrough if range type continue for import return var */
"内置函数名也不能用于变量声明"
复制代码

Go程序的通常结构

Go程序是经过 package 来组织的（与python相似）ide
只有 package 名称为 main 的包能够包含 main 函数函数
一个可执行程序有且仅有一个 main 包测试
经过 ==import== 关键字来导入其它非 main 包ui
经过 ==const== 关键字来进行常量的定义spa
经过在函数体外部使用 ==var== 关键字来进行全局变量的声明与赋值指针
经过 ==type== 关键字来进行==结构(struct)==或==接口(interface)==的声明code
经过 ==func== 关键字来进行函数的声明接口

GO的数据类型汇总给

int,float uint complex bool   //足够保存指针的 32 位或 64 位整数型：uintptr

array struct string
slice map chan
interface
func 复制代码

###变量string

// 声明变量的三种方式
var str string = "I am Dean"   // 变量名 变量类型 = 值
var str = "I am Dean"    // 自行判断类型
str := "I am Dean"       // 最简便写法,===>> 不可用于声明全局变量 

/*其余须要注意的=+++++++++++++++++++++++++++++++++++++++++++++*/
var (            // 全局变量声明必须使用var关键字
	a = 1
    b,c = 2,3          // 并行声明变量
)
var a,b,c,d int //如没有赋值,则取初始值 数字=0 bool=false string=''
// ===================================================================
/*1==>GO中不存在隐式转换,全部类型转换必须显式声明 2==>转换只发生在两种相互兼容的类型之间 3==>类型转换的格式: <ValueA>[:] = <TypeOfValueA>(<ValueB>) */
a:=1.1
b:=int(a)
fmt.Println(b)
// 下面的会报错 cannot convert c (type bool) to type int
c:=true
d:=int(c)
fmt.Println(d)
// 测试如下代码打印的值
	var aa int  = 66
	bb := string(aa)
	fmt.Println(bb)

复制代码

常量

常量的值在编译的时候就已肯定不可更改
常量定义格式基本与变量相同
等号右侧必须是常量或者是常量表达式
常量表达式中的函数必须是==内置函数==

const a int = 1
const b = 'A'
const (
	text = '123'
    length = len(text)
    num = b*20
)
// iota是常量的计数器,从0开始,组中每定义一个常量自动递增1
// 但没遇到一个const关键字,iota就会归零
const (
	aa = iota
	a = 1
	b
	c = iota
	d = iota
)
const (
	Monday = iota
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
    Sunday 
)
// 预测 aa,a,b,c,d的值 分析出要点
func main() {
	fmt.Println(aa,a,b,c,d)
}
复制代码

运算符

运算符
Go中的运算符均是从左至右结合
优先级（从高到低）

^      !                                               （一元运算符）
*       /    %    <<    >>    &      &^
+      -     |      ^                                （二元运算符）
==   !=   <    <=    >=    >
<-                                              // （专门用于channel）
&&
||
复制代码

数据类型

//float32 float64
// uint8 / int8 
// bool
// byte (uint8别名)
// int/uint

复制代码

结构struct

type jiegou struct {
    name string
    age int
}
// 匿名结构
func main() {
    a := &struct {
        Name string
        Age int
    }{
        Name: "dean",
        Age:19,
    }
}
// 匿名结构
type person struct {
    Name string
    Age int
    Contact struct {
        Phone,City string
    }
}

func main() {
    a := person{Name: "dean",Age:19}
    a.Contact.Phone = "13356424532"
    a.Contact.City = "ruishi"
}
//匿名字段 靠顺序对应字段类型
type person struct {
    string
    int
}
func main() {
    a:= person{"joe", 19}
    fmt.Pringln(a)
}

复制代码

method(相似于class的def)

概念:method是附属在一个给定的类型上,语法和函数的声明几乎同样,只是func后面增长了一个recvier(这个def给哪一个class的意思)

//格式
func (r ReveiverType) funcName(parameters) (results){
    //
}
//示例1
func main() {
    r1 := Rectangle{12,2}
    r1.area()
}
type Rectangle struct {
    width, height float64
}

func (r Rectangle) area() float64 {
    return r.width * r.height
}
//示例2
func main() {
    a:=A{}
    a.Print()
    fmt.Println(a.Name)
    
    b:=B{}
    b.Print()
    fmt.Println(b.Name)
} // 输出结果是 A AA B 这是指针和无指针的对比

type A struct {
    Name string
}
type B struct {
    Name string
}
func (a *A) Print() {
    a.Name="AA"
    fmt.Pringln("A")
}
func (b B) Print() {
    a.Name="BB"
    fmt.Pringln("B")
}
// 示例3
type TZ int
func main() {
    var a TZ
    a.Print()  //输出TZ
    
    (*TZ).Print(&a) // 一样能够输出TZ 
}
func (a *TZ) Print() {
    fmt.Pringln("TZ")
}

复制代码

接口interface

type Shaper interface {
	Area() float32
}
type Square struct{
    side float32
}
func (sq *Square) Area() float32 {
	return sq.side * sq.side
}
func main() {
	sq1 := new(Square)
	sq1.side = 5
	var areaIntf Shaper
	areaIntf = sq1
    //使用 类型断言 来测试在某个时刻 varI 是否包含类型 T 的值
    if t,ok := areaIntf.(*Square); ok{   // t,ok := 接口变量.(*某个类型)
		fmt.Println(t,ok)
		fmt.Printf("The type of areaIntf is :%T\n", t)
	}
}
复制代码

函数

Go语言中，使用大小写来决定该常量、变量、类型、接口、结构或函数是否能够被外部包所调用：

根据约定，函数名首字母小写即为private 大写为public.

私有与公共,是以包为单位,==私有是相对两个包之间==,私有变量在包内,仍然是公共的

复制代码