【Go语言学习笔记一】基础语法

时间 2020-12-04

标签 golang 数据库编程数组数据结构编程语言 ide 函数 post 学习栏目 Go 繁體版

原文原文链接

Go学习笔记

Go语言基础语法

行分隔行

在 Go 程序中，一行表明一个语句结束。每一个语句不须要像 C 家族中的其它语言同样以分号 ; 结尾，golang

可是可使用分号；结尾，若是当你将多个语句写在同一行时，则必须使用分号；数据库

1、变量

1.1 变量的声明

功能：存储用户的数据编程

注意：变量必须通过声明才能开始使用数组

标准格式：数据结构

var 变量名 变量类型

变量的声明以关键字 var 开头，行尾不须要写分号编程语言

package main
import ( "fmt" )
func main() {
    var a int
    var b string
    var c []float32
    var d  func () bool
    var e  struct {
     x int
    }
}

代码说明：ide

第3行，声明一个整型类型的变量，能够保存整数数值。函数
第4行，声明一个字符串类型的变量。post
第5行，声明一个 32 位浮点切片类型的变量，浮点切片表示由多个浮点类型组成的数据结构。学习
第6行，声明一个返回值为布尔类型的函数变量，这种形式通常用于回调函数，即将函数以变量的形式保存下来，在须要的时候从新调用这个函数。
第7行，声明一个结构体类型的变量，这个结构体拥有一个整型的 x 字段。

使用var关键字和括号批量声明（推荐）

var (
   a int
   b string
   c []float32
   d  func () bool
   e  struct {
     x int
   }
)

使用关键字var和括号，能够将一组变量定义放在一块儿。　

1.2 初始化变量

变量的声明能够包含初始值，每个变量对应一个值。

若是初始化值已存在，则能够省略类型；变量会从初始值中得到类型。

变量初始化的标准格式：

var 变量名 类型 = 表达式

简化形式：

var 变量名 = 表达式

例如：

var x int = 100

能够写成：

var x = 100

默认值：

没有明确初始值的变量声明会被赋予它们一个默认值：

整型和浮点型变量的默认值为 0。
字符串变量的默认值为空字符串。
布尔型变量默认为 bool。
切片、函数、指针变量的默认为 nil。

注意：变量已经被声明过了，再次声明并赋值，使用短变量声明会编译报错

var p string
p :=  '123'
fmt.Println(p)
// 错误信息：no new variables on left side of :=(44.4)
// var p 声明了p变量， p := '123' 会再次声明并赋值

注意：因为使用了 :=，而不是赋值的 =，所以推导声明写法的左值变量必须是没有定义过的变量。若定义过，将会发生编译错误。

注意：在多个短变量声明和赋值中，至少有一个新声明的变量出如今左值中，即使其余变量名多是重复声明的，编译器也不会报错，例如：

x, z := a, b
y, z := a, b

1.4 多个变量同时赋值

使用Go的“多重赋值特性”，能够轻松完成变量交换的任务。

package` `main
import` `"fmt"

func main() {
   var a = 100
   var b = 200
   a, b = b, ago
   fmt.Println(a, b)
}

多重赋值时，变量的左值和右值按从左到右的顺序赋值。

1.5 匿名变量(_)

在使用多重赋值时，若是不须要在左值中接收变量，可使用匿名变量。

匿名变量用一个下划线 _ 来表示，使用匿名变量时，只须要在变量声明的地方使用下划线替换便可。例如：

var a int
a, _ = 100, 200

注意：匿名变量不占用命名空间，不会分配内存。匿名变量与匿名变量之间也不会由于屡次声明而没法使用。

package main
import ("fmt")
func main() {
    a1, _ := getData()
    _, b1 := getData()
    fmt.Println(a1, b1)
}

type IntSlice []int
// 编写一个len方法，提供切片的长度
func (p IntSlice) Len() int { return len(p)}
// 根据提供i,j元素索引,两个元素进行比较，返回比较结果
func (p IntSlice) Less(i, j int) bool { return p[i] < p[j]}
// 根据提供i,j元素索引,交换两个元素的值
func (p IntSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i]}

func getData() (int, int) {
    return 200, 100
}

2、常量

常量是恒定不变的值，例如圆周率。

常量的声明与变量相似，只不过是使用 const 关键字。

常量能够是字符、字符串、布尔值和数值。

常量不能用 := 语法声明。

常量的声明, 例如：

const pi = 3.1415926

注意：常量在声明的时候必须赋值。

多个变量能够一块儿声明，相似的，多个变量也能够一块儿声明。例如：

const(
    pi = 3.1415926
    e = 2.718281
)

3、基本数据类型

Go语言中有丰富的数据类型，除了基本的整型、浮点型、布尔型、字符串外，还有切片、结构体、函数、map、通道（channel）等。

Go 语言的基本类型和其余语言大同小异。

3.1 整型

整型能够分红如下两个大类：

按长度分为：int八、int1六、int3二、int64

对应的无符号整型：uint八、uint1六、uint3二、uint64

其中，uint8 就是咱们熟知的 byte 型.

3.2 浮点型

Go语言支持两种浮点型数：

float3二、float64.

注意：没有float

Go语言的浮点型默认声明为float64.

3.3 布尔型

布尔型数据只有 true（真）和 false（假）两个值。

注意：

在Go语言中,
true和false均为小写
不容许将整型强制转换为布尔型

3.4 字符串

字符串的两种表示形式：

\1. 双引号，会识别转义字符

\2. 反引号，不会识别转义字符。以字符串的原生形式输出，包括换行和特殊字符。

3.4.1 字符串常见转义符

转义符	含义
\r	回车符(返回行首)
\n	换行符
\t	制表符
'	单引号
"	双引号
\	反斜杠

3.4.2 反引号定义多行字符串

const str = ` 第一行
第二行
第三行
\r\n`
fmt.Println(str)

代码运行结果：

第一行
第二行
第三行
\r\n

3.5 字符

字符串中的每个元素叫作“字符”，在遍历或者单个获取字符串元素时能够得到字符。

Go语言的字符有如下两种：

一种是 uint8 类型，或者叫 byte 型，表明了 ASCII码的一个字符。
另外一种是 rune 类型，表明一个 UTF-8 字符。当须要处理中文、日文或者其余复合字符时，则须要用到 rune 类型。rune 类型实际是一个 int32。

4、数据类型的转换

Go语言使用类型前置加括号的方式进行类型转换，通常格式以下：

T(表达式)

其中，T 表明要转换的类型。表达式包括变量、复杂算子和函数返回值等。

注意：在类型转换时，须要考虑两种类型的关系和范围，是否会发生数值截断等。

package main
 
import "fmt"
 
func main(){
    var n1 int = 20
    var n2 float64 = float64(n1)
 
    n2 = n2 + 3.6
 
    var n3 int32 = int32(n2) // 当将一个float类型转成 int时，是直接去掉小数点后的部分
 
    fmt.Printf("n1 type=%T, val=%v; n2 type=%T, val=%v; n3 type=%T, val=%v\n",
        n1, n1, n2, n2, n3, n3)
}

代码运行结果：

n1 type=int, val=20; n2 type=float64, val=23.6; n3 type=int32, val=23

五、指针

两个核心：

一种是类型指针，容许对这个指针类型的数据进行修改。传递数据使用使用指针，而无须拷贝数据类型指针不能进行偏移和运算

二种是切片，由指向起始元素的原始指针、元素数量和容量组成

5.1 认识指针地址和指针类型

每一个变量在运行时都会被内存分配一个地址，这个地址表明变量在内存中的位置使用“&”操做符放在变量前面对变量进行“取地址”操做格式：

ptr := &variable   //variable的类型为T

其中v表明被取地址的变量，被取地址的variable使用ptr变量进行接收，ptr的类型为“T”,称做T的指针类型。“”表明指针

package main

import (
    "fmt"
    "math"
)

func main() {  
    var cat int = 1
    var str2 string = "banana"
    fmt.Printf("%p, %p\n", &cat, &str2)
}
    //0xc00004e0e8, 0xc0000421f0 为cat,str2取地址后的指针值

注意：变量、指针和地址三种的关系是：每一个变量都拥有地址，指针的值就是地址

5.2 从指针获取指针指向的值

对变量“&”取地址操做后得到这个变量的指针，对指针使用“*”操做，就是指针取值

package main

import (
    "fmt"
    "math"
)
func main() {
    var house = "Malibu Point 10880, 90265"
    // 对字符串取地址，ptr1类型为*string
    ptr1 := &house
    // 打印ptr类型
    fmt.Printf("ptr1 类型：%T\n", ptr1)
    // 打印ptr指针地址
    fmt.Printf("ptr1 地址：%p\n", ptr1)
    // 对指针进行取值操做
    value := *ptr1
    // 取值后类型
    fmt.Printf("value 类型：%T\n", value)
    // value值
    fmt.Printf("value：%s\n", value)
}
// ptr1 类型：*string
// ptr1 地址：0xc000042200
// value 类型：string
// value：Malibu Point 10880, 90265

总结：

取地址“&”和取值“”是一对互补操做符，“&”取地址，"&"根据地址取出地址指向的值

1.对变量进行其地址（&）操做，可得到这个变量的指针变量

2.指针变量的值是指针地址

3.对指针变量进行取值（）操做，能够得到指针变量指向的原变量的值

5.3 使用指针修改值

x, y := 1,2

package main

import (
    "fmt"
    "math"
)

func main() {
    //错误示例
    swap1(&x, &y)
    fmt.Println("x: ",x, "y：", y)
    //x:  1 y:  2
    //正确
    swap(&x, &y)
    fmt.Println("x: ", x, "y: ",y)
    //x:  2 y:  1
}
// 交换函数
func swap(a, b *int) {
    // 取a的指针的值，赋给临时变量t
    t := *a
    //取b指针的值，赋值给a指针指向的变量
    *a = *b
    //a指针的值赋值给b指针指向的变量
    *b = t
}

// 错误示例
func swap1(a, b *int) {
    b, a = a, b
}

5.4 建立指针的另外一种方法--new（）函数

new(类型)

str3 := new(string)
*str3 = "ninja"
fmt.Println(*str3)
fmt.Println(str3)
//ninja
//0xc000042230

6、字符串应用

6.1 计算机字符串长度 -- len()

go 语言字符串都是以UTF-8格式保存,每一个中文占用3个字符

tip1 := "genji is a ninja"
fmt.Println(len(tip1))
// 16
tip2 := "忍者无敌"
fmt.Println(len(tip2))
//12
// 使用RuneCountInString()统计Uncode字符数量
fmt.Println(utf8.RuneCountInString("忍者"))

总结

ASCII字符串长度使用len()函数
Unicode字符串长度使用utf8.RuneCountInString()函数

6.2 遍历字符串 -- 获取每一个字符串

两种写法

遍历每一ASCII字符，使用for循环遍历

theme := "阻击 start"

    for i := 0; i < len(theme); i++ {

        fmt.Printf("ascii: %c %d\n", theme[i], theme[i])

    }
    // ascii: é 233
    // ascii: • 152
    // ascii: » 187
    // ascii: å 229
    // ascii: • 135
    // ascii: » 187
    // ascii:   32
    // ascii: s 115
    // ascii: t 116
    // ascii: a 97
    // ascii: r 114

按Unicode字符遍历字符串

for _, s := range theme {

        fmt.Printf("Unicode %c %d\n", s, s)

    }

    // Unicode 阻 38459
    // Unicode 击 20987
    // Unicode   32
    // Unicode s 115
    // Unicode t 116
    // Unicode a 97
    // Unicode r 114
    // Unicode t 116

总结:

ASCII字符串遍历直接使用下标
Unicode字符串遍历使用for range

6.3 获取字符串的某一段字符

string.Index() 在字符串中搜索另外一个子串

tracer := "努力拥抱每一天，不断成长"
comma := strings.Index(tracer, "每一天")
posi := strings.Index(tracer[comma:], "成长")

fmt.Println(comma, posi, tracer[comma+posi:])

 // 12 18 成长

总结：

strings.Index：正向搜索子字符串
string.LastIndex: 反向搜索自字符串

搜索的起始位置能够经过切片偏移制做

6.4 修改字符串

go语言没法直接修改每个字符元素，只能经过从新构造新的字符串并赋值给原来的字符串变量

angel := "Hero nerver die"

arrayBytes := []byte(angel)

for i := 5; i <= 10; i++ {

     arrayBytes[i] = '-'

}

fmt.Println(arrayBytes)

// [72 101 114 111 32 45 45 45 45 45 45 32 100 105 101]

fmt.Println(string(arrayBytes))

 // Hero ------ die

总结

Go语言的字符串是不能够改变的
修改字符串时,能够将字符串转换为[]byte进行修改
[]byte 和string 能够经过强制类型转换互换

6.5 链接字符串

可使用加号“+”链接可使用相似于StringBuilder的机制链接，更高效

hamer := "GO GO GO"
sickle := "You Can"

// 声明字节缓冲

var stringBuilder bytes.Buffer

// 将字符串写入缓冲区

stringBuilder.WriteString(hamer)

stringBuilder.WriteString(sickle)

//将缓冲以字符串形式输出

fmt.Println(stringBuilder.String())

// GO GO GOYou Can

bytes.Buffer能够缓冲并写入各类字节数组，字符串也是一种字符串数组，使用writeString()
将须要链接的字符串，经过bytes.Buffer声明缓冲stringBuilder调用WriteString()方法写入里面，
再经过stringBuilder.String()方法将缓冲转换为字符串

6.6 格式化

写法： fmt.Sprintf(格式化样式，参数列表)

格式化样式：字符串形式，格式化动词以%开头

参数列表：多个参数以逗号分隔，个数必须与格式化中样式个数一一对应

var progress = 2
    var target = 8

    // 两参数格式化
    title := fmt.Sprintf("以完成%d个任务，还差%d个就完成", progress, target)

    fmt.Println(title)
    // 以完成2个任务，还差8个就完成

    pi := math.Pi

    // 按数值自己格式输出
    variant := fmt.Sprintf("%v %v %v", "月球基地", pi, true)   
    fmt.Println(variant)
    // 月球基地 3.141592653589793 true

    profile := &struct {
        Name string
        HP   int
    }{
        Name: "stat",
        HP: 150,
    }

    fmt.Printf("使用'%%+v' %+v\n", profile)
    fmt.Printf("使用'%%#v' %#v\n", profile)
    fmt.Printf("使用'%%T' %T\n", profile)

    // 使用'%+v' &{Name:stat HP:150}
    // 使用'%#v' &struct { Name string; HP int }{Name:"stat", HP:150}
    // 使用'%T' *struct { Name string; HP int }

base64编码解码示例

package main

import (
    "fmt"
    "encoding/base64"
)

func main() {

    // 须要处理的字符串
    message := "Away from keyboard. https://golang.org/"

    // 编码消息, 传入的字符串需转为字节数组，才能供这个函数使用
    encodeMessage := base64.StdEncoding.EncodeToString([]byte(message))
    // 输出编码完成的消息
    fmt.Println(encodeMessage)
    // 解码消息
    data, err := base64.StdEncoding.DecodeString(encodeMessage)
    // 出错处理

    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println(string(data))
    }

    // QXdheSBmcm9tIGtleWJvYXJkLiBodHRwczovL2dvbGFuZy5vcmcv
    // Away from keyboard. https://golang.org/


}

7、枚举

7.1 枚举 -- 一组常量值

// 使用iota模拟枚举
  type Weapon int
   const (
       Arrow Weapon = iota // 开始生成枚举值,默认为0
        Shuriken
       SniperRifle
       Rifle
       Blower
   )
   // 输出全部枚举值
    fmt.Println(Arrow, Shuriken, SniperRifle, Rifle, Blower)
   var weapon Weapon = Blower
    fmt.Println(weapon)
    // 0 1 2 3 4
    // 4

7.2 枚举--将枚举值转换为字符串

package main
import ("fmt")

// 声明芯片类型
type ChipType int

const (
    None ChipType = iota
    GPU
    CPU
)

func (c ChipType) String() string {

    switch c {
    case None:
        return "None"
    case GPU:
        return "GPU"
    case CPU:
    return "CPU"

     }
    return "N/A"

}

func main() {
    // 输出CPU的值并以整型格式显示
    fmt.Printf("%s %d", CPU, CPU)
    //CPU 2
}

8、类型别名

8.1 区分类型别名与类型定义

类型别名的写法：

type TypeAlias = Type

类型别名规定：

TypeAlias只是Type的别名，本质上TypeAlias与Type是同一个类型

// 将NewInt定义为int类型
type NewInt int
// 将int取一个别名叫IntAlias
type IntAlias = int

// 将a声明为一个NewInt类型
var alias_a NewInt
fmt.Printf("a type: %T\n", alias_a)
// a type: main.NewInt

// 将a2声明为IntAlias类型
var alias_a2 IntAlias
fmt.Printf("a2 type: %T\n", alias_a2)
 // a2 type: int

8.2 非本地类型不能定义方法

不能为不在同一个包中声明的类型定义方法，即不能为在其余包声明的类型在本地包中定义方法

package main

import ("time")

// 2.8.2
// 定义time.Duration 的别名为MyDuration
type MyDuration = time.Duration

// 为MyDuration 添加一个函数
func (m MyDuration) EasySet(a String) {
    
}

func main() {
    
}
//# 2-base/2.2-data_type
//.\data_type.go:51:6: cannot define new methods on non-local type time.Duration
//.\data_type.go:51:31: undefined: String
//exit status 2
//Process exiting with code: 1

8.3 在结构体成员嵌入时使用别名

package main

import (
    "fmt"
    "reflect"
)

// 定义商标结构
type Brand struct {

}
// 为商标结构添加Show()方法
func (t Brand) Show() {

}

// 为Brand定义一个别名
type FakeBrand = Brand
// 定义车辆结构，嵌入商标结构
type  Vehicle struct {
    Brand
    FakeBrand
}

func main() {

    // 声明变量 a 为车辆类型
    var a Vehicle
    // 指定调用FakeBrand的Show
    a.FakeBrand.Show()
    // 取a的类型反射对象
    ta := reflect.TypeOf(a)

    // 遍历a的全部成员
    for i := 0; i < ta.NumField(); i++ {
        // ta 成员信息
        f := ta.Field(i)
        // 打印成员的字段名和类型
        fmt.Printf("FieldName: %v, FieldType: %v\n", f.Name, f.Type.Name())
    }

    
    // FieldName: Brand, FieldType: Brand
    // FieldName: FakeBrand, FieldType: Brand

go
}

总结：

FakeBrand是Brand的一个别名，在Vehicel中嵌入FakeBrand和Brand，Vehicel的类型会以名字的方式保留在Vehicle的成员中
FakeBrand和Brand 都有Show()方法, 调用时必须制定调用谁的, a.FakeBrand.Show()

9、条件语句

8.1 if语句

if 语句由布尔表达式后紧跟一个或多个语句组成。

语法

Go 编程语言中 if 语句的语法以下：

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
}

注意：if语句必定要加{}

8.2 if...else语句

if 语句后可使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。

语法

Go 编程语言中 if...else 语句的语法以下：

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
} else {
  /* 在布尔表达式为 false 时执行 */
}

注意：每个 if else 都须要加入括号同时 else 位置不能在新一行

寻找到 100 之内的全部的素数:

package main

import "fmt"
func main(){
    // var count,c int   //定义变量不使用也会报错
    var count int
    var flag bool
    count=1
    //while(count<100) {    //go没有while
    for count < 100 {
        count++
        flag = true;
        //注意tmp变量  :=
        for tmp:=2;tmp<count;tmp++ {
            if count%tmp==0{
                flag = false
            }
        }

        // 每个 if else 都须要加入括号 同时 else 位置不能在新一行
        if flag == true {
            fmt.Println(count,"素数")
        }else{
            continue
        }
    }
}

8.3 switch case语句：

普通的switch语句：

var i = 0
switch i {
case 0:
case 1:
      fmt.Println(“1”)
case 2:
fmt.Println(“2”)
default:
     fmt.Println(“def”)
}

fallthrough语句：

var i = 0
switch i {
case 0:
        fallthrough
case 1:
      fmt.Println(“1”)
case 2:
fmt.Println(“2”)
default:
     fmt.Println(“def”)
}

注：加了fallthrough后，会直接运行【紧跟的后一个】case或default语句，不论条件是否知足都会执行，后面的条件并不会再判断了。

注意：Go 没有三目运算符，因此不支持*?: 形式的条件判断。

10、for循环

for 循环是一个循环控制结构，能够执行指定次数的循环。

语法

Go 语言的 For 循环有 3 种形式，只有其中的一种使用分号。

和 C 语言的 for 同样：

for init; condition; post { }

和 C 的 while 同样：

for condition { }

和 C 的 for(;😉 同样：

for { }

init：通常为赋值表达式，给控制变量赋初值；
condition：关系表达式或逻辑表达式，循环控制条件；
post：通常为赋值表达式，给控制变量增量或减量。

for语句执行过程以下：

一、先对表达式 1 赋初值；
二、判别赋值表达式 init 是否知足给定条件，若其值为真，知足循环条件，则执行循环体内语句，而后执行 post，进入第二次循环，再判别 condition；不然判断 condition 的值为假，不知足条件，就终止for循环，执行循环体外语句。

for 循环的 range 格式能够对 slice、map、数组、字符串等进行迭代循环。格式以下：

for key, value := range oldMap {
    newMap[key] = value
}

实例

计算 1 到 10 的数字之和：

实例

package main

import "fmt"

func main() {
    sum := 0
    for i := 0; i <= 10; i++ {
        sum += i
    }
    fmt.Println(sum)
}

输出结果为：

init 和 post 参数是可选的，咱们能够直接省略它，相似 While 语句。

如下实例在 sum 小于 10 的时候计算 sum 自相加后的值：

实例

package main

import "fmt"

func main() {
    sum := 1
    for ; sum <= 10; {
        sum += sum
    }
    fmt.Println(sum)

    // 这样写也能够，更像 While 语句形式
    for sum <= 10{
        sum += sum
    }
    fmt.Println(sum)
}

输出结果为：

16
16

无限循环:

实例

package main

import "fmt"

func main() {
    sum := 0
    for {
      sum++ // 无限循环下去
    }
    fmt.Println(sum) // 没法输出
}

要中止无限循环，能够在命令窗口按下ctrl-c 。

For-each range 循环

这种格式的循环能够对字符串、数组、切片等进行迭代输出元素。

实例

package main
import "fmt"

func main() {
    strings := []string{"google", "runoob"}
    for i, s := range strings {
        fmt.Println(i, s)
    }


    numbers := [6]int{1, 2, 3, 5}
    for i,x:= range numbers {
        fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
    } 
}

以上实例运行输出结果为:

0 google
1 runoob
第 0 位 x 的值 = 1
第 1 位 x 的值 = 2
第 2 位 x 的值 = 3
第 3 位 x 的值 = 5
第 4 位 x 的值 = 0
第 5 位 x 的值 = 0

11、数组

11.1 声明数组

Go 语言数组声明须要指定元素类型及元素个数，语法格式以下：

var variable_name [SIZE] variable_type

以上为一维数组的定义方式。例如如下定义了数组 balance 长度为 10 类型为 float32：

var balance [10] float32

11.2 初始化数组

如下演示了数组初始化：

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

初始化数组中 {} 中的元素个数不能大于 [] 中的数字。

若是忽略 [] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小：

var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

该实例与上面的实例是同样的，虽然没有设置数组的大小。

balance[4] = 50.0

以上实例读取了第五个元素。数组元素能够经过索引（位置）来读取（或者修改），索引从0开始，第一个元素索引为 0，第二个索引为 1，以此类推。

11.3 访问数组元素

数组元素能够经过索引（位置）来读取。格式为数组名后加中括号，中括号中为索引的值。例如：

var salary float32 = balance[9]

11.4多维数组

Go 语言支持多维数组，如下为经常使用的多维数组声明方式：

var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type

如下实例声明了三维的整型数组：

var threedim [5][10][4]int

11.5初始化多维数组

多维数组可经过大括号来初始值。如下实例为一个 3 行 4 列的二维数组：

a = [3][4]int{  
 {0, 1, 2, 3} ,   /*  第一行索引为 0 */
 {4, 5, 6, 7} ,   /*  第二行索引为 1 */
 {8, 9, 10, 11},   /* 第三行索引为 2 */
}

注意：以上代码中倒数第二行的 } 必需要有逗号，由于最后一行的 } 不能单独一行，也能够写成这样：

a = [3][4]int{  
 {0, 1, 2, 3} ,   /*  第一行索引为 0 */
 {4, 5, 6, 7} ,   /*  第二行索引为 1 */
 {8, 9, 10, 11}}   /* 第三行索引为 2 */

11.6 访问多维数组

多维数组经过指定坐标来访问。如数组中的行索引与列索引，例如：

val := a[2][3]
或
var value int = a[2][3]

以上实例访问了二维数组 val 第三行的第四个元素。

12、函数

函数是基本的代码块，用于执行一个任务。

Go 语言最少有个 main() 函数。

你能够经过函数来划分不一样功能，逻辑上每一个函数执行的是指定的任务。

函数声明告诉了编译器函数的名称，返回类型，和参数。

Go 语言标准库提供了多种可动用的内置的函数。例如，len() 函数能够接受不一样类型参数并返回该类型的长度。若是咱们传入的是字符串则返回字符串的长度，若是传入的是数组，则返回数组中包含的元素个数。

12.1 函数定义

Go 语言函数定义格式以下：

func function_name( [parameter list] ) [return_types] {
   函数体
}

函数定义解析：

func：函数由 func 开始声明
function_name：函数名称，函数名和参数列表一块儿构成了函数签名。
parameter list：参数列表，参数就像一个占位符，当函数被调用时，你能够将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也能够不包含参数。
return_types：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不须要返回值，这种状况下 return_types 不是必须的。
函数体：函数定义的代码集合。

注意：

1.2.1 golang函数不支持重载，一个包不能有两个函数名同样的函数。

1.2.2 函数也是一种类型，一个函数能够赋值给变量。

12.2 函数返回多个值

Go 函数能够返回多个值，例如：

package main

import "fmt"

func swap(x, y string) (string, string) {
   return y, x
}

func main() {
   a, b := swap("Google", "Runoob")
   fmt.Println(a, b)
}

以上实例执行结果为：

Runoob Google

12.3 函数return值的几种状况

分三种状况

（如下 “指定返回值”这句话，仅指return后面直接跟着的返回值）

1.退出执行，不指定返回值
(1) 函数没有返回值

package main
import (
    "fmt"
)

func GetMoney(){
fmt.Println("money")
  return
}

func main(){
  GetMoney()
}

(2) 函数返回值有变量名

package main
import (
    "fmt"
)

func GetMoney() (_amount int){
 _amount = 88
 fmt.Println("money: ",_amount)
  return
}

func main(){
  var amount  = GetMoney()
  fmt.Println("money: ",amount)
}

2.退出执行，指定返回值

package main
import (
    "fmt"
)

func GetMoney() (_amount int){
 fmt.Println("money: ",_amount)
  return 88
}

func main(){
  var amount  = GetMoney()
  fmt.Println("money: ",amount)
}

运行结果：
money:  0
money:  88

3.退出执行，指定返回值和指定默认值

package main
import (
    "fmt"
)

func GetMoney() (_amount int){
_amount  = 99     //若是return后面没有指定返回值，就用赋给“返回值变量”的值
 fmt.Println("money: ",_amount)
  return 88       //若是return后面跟有返回值，就使用return后面的返回值
}

func main(){
  var amount  = GetMoney()  
  fmt.Println("money: ",amount)
}

运行结果：
money:  99
money:  88

12.4 可变参数

0或多个参数

func add(arg…int) int {
}

1或多个参数

func add(a int, arg…int) int {
}

2或多个参数

func add(a int, b int, arg…int) int {
}

12.5 匿名函数

由一个不带函数名的函数声明和函数体组成。

func main()  {
    i := 1
 
    go func(i int) {
        time.Sleep(100*time.Millisecond)
        fmt.Println("i =", i)
    } (i)
 
    i++
    time.Sleep(1000*time.Millisecond)
}

十3、defer的用途

当函数返回时，先执行return，后执行defer语句。所以，能够用来作资源清理、关闭句柄、锁的释放、数据库链接释放。
多个defer语句，按先进后出的方式执行。
defer语句中的变量，在defer声明时就决定了。

func a() {
          i := 0
          defer fmt.Println(i)
          i++
          return
}

关闭文件句柄：

func read() {
   file := open(filename)
   defer file.Close()
   //其余操做
}

锁资源的释放：

func read() {
   mc.Lock()
   defer mc.Unlock()
   //其余操做
}

数据库链接释放：

func read() {
   conn := openDatabase()
   defer conn.Close()
   //其余操做
}

十4、输入的使用

一、输入的使用

第一种写法：fmt.Scanf("%d", &a)

第二种写法：fmt.Scan(&a)

示例：

package main //必须有一个main包
 
import "fmt"
 
func main() {
    var a int //声明变量
    fmt.Printf("请输入变量a: ")
 
    //阻塞等待用户的输入
    //fmt.Scanf("%d", &a) //别忘了& 
    fmt.Scan(&a)
    fmt.Println("a = ", a)
}

#执行结果：

请输入变量e：666
a =  666

Scanf %d只能接收整型，不能接收字符型

因此在输入字符型变量时应该使用fmt.Scanf(“%c”,&a)

格式	含义
%%	一个%字面量
%b	一个二进制整数值(基数为2)，或者是一个(高级的)用科学计数法表示的指数为2的浮点数
%c	字符型。能够把输入的数字按照ASCII码相应转换为对应的字符
%d	一个十进制数值(基数为10)
%f	以标准记数法表示的浮点数或者复数值
%o	一个以八进制表示的数字(基数为8)
%p	以十六进制(基数为16)表示的一个值的地址，前缀为0x,字母使用小写的a-f表示
%q	使用Go语法以及必须时使用转义，以双引号括起来的字符串或者字节切片[]byte，或者是以单引号括起来的数字
%s	字符串。输出字符串中的字符直至字符串中的空字符（字符串以'\0‘结尾，这个'\0'即空字符）
%t	以true或者false输出的布尔值
%T	使用Go语法输出的值的类型
%x	以十六进制表示的整型值(基数为十六)，数字a-f使用小写表示
%X	以十六进制表示的整型值(基数为十六)，数字A-F使用小写表示