go语言学习第二天==>变量+数组+map+流程控制+goto语句+cap()函数和len()函数

#go语言学习第二天==>变量+数组+map+流程控制+goto语句+cap()函数和len()函数

- 变量

1 变量声明: (注：go语言每行后面不用加";“号 编译时它会在除了”+"、"-"、"*“等符号结尾的行后面自动加”;"号)

var+变量名+类型

 var v1 int16
 var v2 [10]int  ///数组
 var v3 []int     //数组切片
 var v4 struct{
	f int
}                        /结构体
var  v6 *int     ///指针
var v7 map[string] int    //map  key为string ,value为int
var v8 func(a int) int     //参数a 返回值int

//
2初始化

var v1 int = 10	 	// 正确的使用方式1  
var v2 = 10 		// 正确的使用方式2，编译器可以自动推导出v2的类型 
v3 := 10      		// 正确的使用方式3，编译器可以自动推导出v3的类型

:= 表示声明并且初始化赋值 相同作用域内go语言不允许重复声明标识符相同的变量
即
var i int
i := 2
编译出错↑
///
3多重赋值

i, j = j, i  //i和j交换值 等同于  t = i; i = j; j = t; 
i,j=1,2		//i=1,j=2

///
4匿名变量
demo

func GetName() (firstName, lastName, nickName string) {  
  return "May", "Chan", "Chibi Maruko" 
}

此方法返回三个值，若只要nickName则可以用匿名变量

_, _, nickName := GetName()

///
5声明多个

var(
	v1 int
	v2 string
)

• 常量
  ///
  1字面产量

-12 
3.14159265358979323846 // 浮点类型的常量 
3.2+12i      // 复数类型的常量 
true      // 布尔类型的常量 
"foo"     // 字符串常量

go语言中的字面常量是无类型的，只要这个产拿过来在相应类型的值域，就可以作为该类型的常量如 -12可以赋值给int int64 float complex64等

/
2常量定义

const Pi float64 = 3.14159265358979323846  
const zero = 0.0             // 无类型浮点常量 
const (     
	size int64 = 1024     
	eof = -1                // 无类型整型常量 
)  
const u, v float32 = 0, 3    // u = 0.0, v = 3.0，常量的多重赋值 
const a, b, c = 3, 4, "foo" // a = 3, b = 4, c = "foo", 无类型整型和字符串常量 

Go语言预定义了这些常量：true、false和iota。

iota比较特殊，可以被认为是一个可被编译器修改的常量，在每一个const关键字出现时被 重置为0，然后在下一个const出现之前，每出现一次iota，其所代表的数字会自动增1。

const (           // iota被重设为0     
	c0 = iota  // c0 == 0     
	c1 = iota    // c1 == 1     
	c2 = iota    // c2 == 2  
)   
 
const (     
	a = iota   // a == 0 (iota在每个const开头被重设为0)     
	b = iota   // b == 1     
	c = iota   // c == 2  
) 

如果两个const的赋值语句的表达式是一样的，那么可以省略后一个赋值表达式。因此，上 面的前两个const语句可简写为：

const (       // iota被重设为0     
	c0 = iota     // c0 == 0     
	c1      // c1 == 1     
	c2       // c2 == 2 
)

• 枚举（就是const定义的一组常量）
  demo

const (     
	Sunday = iota     
	Monday     
	Tuesday     
	Wednesday     
	Thursday    
	Friday     
	Saturday     
	numberOfDays        // 这个常量没有导出  
)

同Go语言的其他符号（symbol）一样，以大写字母开头的常量在包外可见。 以上例子中numberOfDays为包内私有，其他符号则可被其他包访问。

- 数组
//
1声明

var user []User
var a []int
[32]byte     // 长度为32的数组，每个元素为一个字节 
[2*N] struct { x, y int32 } // 复杂类型数组 
[1000]*float64   // 指针数组 
[3][5]int    // 二维数组 
[2][2][2]float64   // 等同于[2]([2]([2]float64)) 

数组初始化：

var a [5]int = [5]int{1, 2, 3, 4, 5}
b := [5]int{1, 2, 3, 4, 5}

//部分初始化
c := [5]int{1, 2, 3}

//指定某个元素初始化
d := [5]int{2: 10, 0: 20}  //下标为2的赋值为10，下标为0的赋值为20

结构体数组初始化

type userinfo struct{
    Id int16
    Username string 
    Age  int16
}
/*
        u1:=userinfo{
            Id:   6,
            Username:   "kkk",
            Age:    777,
        }
        u2:=userinfo{
            7,
            "kkk",
            777,
        }
        us:=[2]userinfo{u1,u2}

    */
    //或者这样初始化
    us:=[2]userinfo{
        {
            66,
            "kkk",
            777,
        },
        {
            77,
            "kkk",
            777,
        },
    }

数组求长度 len(数组名)

/
2数组切片

var myArray [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
var mySlice []int = myArray[:5]
//mySlice=1,2,3,4,5
mySlice = myArray[:]
//mySlice=1,2,3,4,5,6,7,8,9,10
基于从第5个元素开始的所有元素创建数组切片：
mySlice = myArray[5:]
//mySlice=5,6,7,8,9,10

直接创建
创建一个初始元素个数为5的数组切片，元素初始值为0：
mySlice1 := make([]int, 5)
创建一个初始元素个数为5的数组切片，元素初始值为0，并预留10个元素的存储空间：
mySlice2 := make([]int, 5, 10)
直接创建并初始化包含5个元素的数组切片：
mySlice3 := []int{1, 2, 3, 4, 5}

遍历：

for i := 0; i <len(mySlice); i++ {     
	fmt.Println("mySlice[", i, "] =", mySlice[i])  
}

使用range关键字可以让遍历代码显得更整洁。range表达式有两个返回值，第一个是索引， 第二个是元素的值：

for i, v :=  range mySlice {     
	fmt.Println("mySlice[", i, "] =", v)  
} 

cap()函数和len()函数
cap()函数返回数组切片分配的空间大小，
len()函数返回数组切片中当前所存储的元素个数。
demo

package main 
 
import "fmt" 
 
func main() {     
	mySlice := make([]int, 5, 10)  
 
    fmt.Println("len(mySlice):", len(mySlice))     
    fmt.Println("cap(mySlice):", cap(mySlice)) 
}

该程序的输出结果为：
len(mySlice): 5 cap(mySlice): 10

append()函数在数组元素后面新增元素
mySlice = append(mySlice, 1, 2, 3)
或者
mySlice2 := []int{8, 9, 10} // 给mySlice后面添加另一个数组切片 mySlice = append(mySlice, mySlice2…)
内容复制

slice1 := []int{1, 2, 3, 4, 5}   
slice2 := []int{5, 4, 3}  
 
copy(slice2, slice1) // 只会复制slice1的前3个元素到slice2中 
copy(slice1, slice2) // 只会复制slice2的3个元素到slice1的前3个位置 

//

- map的使用

///
声明：

var myMap map[string] PersonInfo

↑其中 ，变量名：myMap ，key类型：string ，value类型：PersonInfo

创建：可以使用make()来创建map↓

var myMap0 = make(map[string] string)

创建时指定map的存储能力为100↓

var myMap0 = make(map[string] string, 100)

创建时初始化↓

myMap := map[string]string{
		"k1": "one", 
		"k2": "two",
	}

赋值↓

myMap["k13"]="love"

元素删除 (如果1234键存在则删除，不存在则不会发生什么如果myMap值为nil将抛出panic异常)↓

delete(myMap, "1234") 
//

查找↓

value, ok := myMap["1234"]  
if ok {
	 // 找到了     // 处理找到的value 
 }

遍历↓

for k := range myMap {
        fmt.Printf("%d--->%s\n", k, myMap[k])
    }

或者

for k, v := range myMap {
        fmt.Printf("%d--->>>%s\n", k, v)
    }

• 流程进制

if a < 5 {     
	return 0 
} else {
     return 1 
}  

switch i {     
	case 0:         
		fmt.Printf("0")     
	case 1:         
		fmt.Printf("1")   
	default:         
		fmt.Printf("Default") 
}

循环

sum := 0
for i := 0; i < 10; i++ {     
	sum += i 
}

//支持多重赋值
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]
}
//
sum := 0 
for {     
	sum++      
	if sum > 100 {         
		break     
	}
 
}

goto语句

func myfunc() {     
	i := 0     
	HERE:     
	fmt.Println(i)     
	i++     
	if i < 10 {         
		goto HERE     
	} 
}