2顺序编程

目录

• 变量
  • 变量声明
  • 变量初始化
  • 变量赋值
  • 匿名变量
• 常量
  • 字面常量literal
  • 常量定义 const
  • 预定义常量
  • 枚举
• 类型
  • 布尔类型：bool
  • 整型：int8、byte、int16、unit、uintptr
  • 浮点类型：float32、float64
  • 复数类型
  • 字符串类型
    • 字符串操作
    • 字符串遍历
    • 字符类型
  • 数组
  • 数组切片
    • 创建数组切片
      • 基于数组
      • 直接创建
    • 元素遍历
    • 动态增减元素
    • 基于数组切片创建数组切片
  • 内容复制
  • map
    • 变量声明
    • 创建
    • 赋值
    • 删除
    • 查找
• 流程控制
  • 条件
  • 选择
  • 循环
    • 跳转
    • 函数
      • 不定参数
    • 多返回值
  • 匿名函数与闭包
    • 匿名函数
    • 闭包
    • 错误处理
      • error接口
  • defer
  • panic recover

变量

变量声明

• var v1 int
• var v2 string
• var v3 [10]int //数组
• var v4 [] int //数组切片
• var v5 struct {
  f int
  }
• var v6 * int //指针
• var v7 map[string]int //map,key为string类型，value为int类型
• var v8 func(a int) int
• var (
  v1 int
  v2 string
  )

变量初始化

• var可以保留，但不是必要元素
• var v1 int = 10
• var v2 = 10 //编译器自动推导出v2类型
• v3 := 10 //编译器自动推导出v3类型

变量赋值

• var v10 int
• v10 = 123
  多重赋值 i,j = j,i

匿名变量

func GetName()(fistname,lastname,nickname string){
    return "May","Chan","Chi"
}

_,_,nickname := GetName()

常量

字面常量literal

常量定义 const

• const PI float64 = 3.1433434
• const zero = 0.0
• const (
  size int64 = 1024
  eof = -1
  )
• const u,v float32 = 0,3
• cosnt a,b,c = 3,4,"foo"

预定义常量

• true
• false
• iota
  一个可被编译器修改的常量，在每一个const关键字出现时被重置为0，在下一个const出现之前，每出现一次，代表的数字自动增1

枚举

const (
Sunday = ioa
Monday
Tuesday
Wednesday
...
)

类型

布尔类型：bool

不支持自动或强制类型转换
var v1 bool
v1 = true
v2 := (1 == 2)

整型：int8、byte、int16、unit、uintptr

• int8 1 -128-127

• unit8(byte) 1 0-255

• int 平台相关

• unit 平台相关

• unitptr 同指针，在32位平台4字节，64位平台8字节

• var value int32

• value1 :=64 //value1会自动推导为int类型

• value2 = value1 //编译错误

• value2 = int32(value1)

浮点类型：float32、float64

浮点数比较

import "math"
func isEqual(f1,f2,p float64) bool{
    return math.Fdim(f1,f2) < p
}

复数类型

字符串类型

var str string

字符串操作

"hello"+"123"
len("hello")
"hello"[1]

字符串遍历

str : = "hello 世界"
n := len(str)
for i:=0;i<n;i++{
    ch := str[i]
    fmt.Println(i,ch)//每个中文字符在utf8占3个字节 
}
for i,ch := range str{
   fmt.Println(i,ch) //ch类型为rune
}

字符类型

• byte unit8别名 UTF-8字符串单个字节值
• rune 代表单个Unicode字符

数组

• [32]byte
• [2*N] struct
• [1000]*float64
• [3][5]int
• [2][2][2]float64
• arrLength := len(arr)
• 遍历

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

}
for i,v:=range array{

}

• 值类型

数组切片

一个指向数组的指针，拥有自己的数据结构

• 一个指向原生数组的指针
• 数组切片中的元素个数
• 数组切片已分配的存储空间

创建数组切片

基于数组

package main

import "fmt"

func main() {
	var myArray [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	var mySlice []int = myArray[:5]

	fmt.Println("Elemenets of myArray:")
	for _, v := range myArray {
		fmt.Println(v, "")
	}

	fmt.Println("\nElemenets of mySlice:")

	for _, v := range mySlice {
		fmt.Println(v, "")
	}

	fmt.Println()
}

直接创建

• mySlice := make([]int,5)
• mySlice := make([]int,5,10)//初始元素个数为5的数组切片，元素初始值为0，并预留10个元素的存储空间
• mySlice := []int

元素遍历

range

动态增减元素

• cap()返回数组切片分配的空间大小
• len()返回数组切片存储的元素个数

mySlice = append(mySlice,1,2,3)
mySlice2 := []int{8,9,10}
mySlice = append(mySlice,mySlice2...)

基于数组切片创建数组切片

oldSlice := []int{1,2,3,4,5}

newSlice := oldSlice[:3]

内容复制

mySlice1 := []int{1,2,3,4,,5}

mySlice2 := []int{5,4,3}

copy(slice2,slice1)//只会复制slice1前3个元素到slice2中
copy(slice1,slice2)//只会复制slice2前3个元素到slice1前3个位置

map

变量声明

var myMap map[string] PersonInfo

创建

myMap = make(map[string] PersonInfo)

myMap = make(map[string] PersonInfo,1000)

myMap = map[string] PersonInfo{
"1234":PersonInfo{"1","jack"}
}

赋值

myMap["12345"] = PersonInfo{"12345", "Tome", "Room 201"}

删除

delete(myMap,"12345")

查找

value, ok := myMap["1234"]
if ok{

}

流程控制

条件

不允许将“最终的”return语句包含在if ...else...

选择

循环

sum :=0
for i :=0; i < 10; i++ {
    sum +=i
}
sum :=0
for{
    sum++
    if sum > 100 {
        break
    }
}
a := []int{1, 2, 3, 4, 5, 6}
for i,j:=0,len(a)-1;i<j;i,j=i+1,j-1{
    a[i],a[j]=a[j],a[i]
}

跳转

goto

函数

不定参数

func Printf(format string,args ...interface{})

func MyPrintf(args ...interface{}) {
	for _, arg := range args {
		switch arg.(type) {
		case int:
			fmt.Println(arg, "is an int value.")
		case string:
			fmt.Println(arg, "is an int value.")
		}
	}
}
func main() {
	var v1 int = 1
	var v2 string = "string"
	MyPrintf(v1, v2)
}

多返回值

匿名函数与闭包

匿名函数

func (a,b int,z float64) bool{
    return a*b < int(z)
}
f := func(x,y int) int{
    return x+y
}
func(ch chan int){
    ch <- ACK
}(reply_chan) //表示函数调用

闭包

func main() {
	var j int = 5
	a := func() func() {
		var i int = 10
		return func() {
			fmt.Printf("i,j:%d,%d\n", i, j)
		}
	}()

	a()
	j *= 2
	a()
}

错误处理

error接口

type error interface{
    Error() string
}
func Foo(param int)(n int,err error){

}
n,err := Foo(0)
if err != nil{

}else{

}

defer

func CopyFile(dst, src string) (w int64, err error) {
	srcFile, err := os.Open(src)
	if err != nil {
		return
	}

	defer srcFile.Close()

	dstFile, err := os.Create("")
	if err != nil {
		return
	}
	defer dstFile.Close()

	return io.Copy(dstFile, srcFile)
}

panic recover