Go语言（二）

Go语言（二）

二、语法

注释

单行注释：//
多行注释：/**/
变量操作
变量声明赋值：var 变量名称 类型
Eg:

var age int = 10
var num,sum int

自动推导类型：变量名:=赋值
Eg:

num1 := 10

输出

fmt.Println(num1, num2, num3)
fmt.Printf("num1 = %d\n", num1)
fmt.Scanf("%d",&age)
fmt.Scan(&age)
//有格式的输出
 fmt.Println(num, num1)
//格式化输出
 fmt.Printf("num = %d\n", num)

数据类型(%T表示输出变量类型)

//整型 int有符号整型 uint无符号整型-->正整数
 var age uint
 age = -10 //uint无符号整型，报错
 fmt.Println(age)
 //浮点  float32精确到后7位  float64精确到后15位（建议使用float64）
 var num float64
 var num1 float64
 num = 123.45
 num1 = 123.4567
 fmt.Printf("%f\n", num)    //123.450000保留六位小数，不足补齐
 fmt.Printf("%f\n", num1)   //123.456700
 fmt.Printf("%.2f\n", num1) //123.46保留两位小数，同时四舍五入
 fmt.Printf("%T", num)      //输出类型
 //布尔 bool ---true,false
 var isResult bool
 isResult = false
 fmt.Printf("%T\n", isResult)
 fmt.Println(isResult)
 //字符
 var chr byte = 'A' //单引号引起的单个字符为字符类型,一定是单引号
 fmt.Println(chr)
 var name string = "a" //中
 fmt.Println(name)
 fmt.Println(len(name)) //注意：中文字符一个汉字占3个字符
 //强制类型转换：需转换的类型(变量)
 var num int = 10
 fmt.Println(float64(num))
 fmt.Printf("%T", float64(num))
 var name string = "啦啦啦"
 var age int = 10
 fmt.Scan(&name)
 fmt.Scan(&age)
 fmt.Println("%s年龄是%d", name, age)
 //常量
 const PI = 3.14
 fmt.Println(PI)

运算符

+、-、、/、%、++后自增、–后自减（无前自增和前自减，只能写在变量后面）
=、+=、-=、=、/=、%=
==、!=、<、>、<=、>=
!、&&、||
优先级：

if

var num int = 9
 if num > 9 {
  fmt.Println("PPPPPP")
 } else if num == 9 {
  fmt.Println(num)
 } else {
  fmt.Println("lllllllllllll")
 }

switch

var data int = 10
 switch data {
 case 10:
  fmt.Println("kkkkk")
 default:
  fmt.Println("dddd")
 }

for

for i := 0; i < 10; i++ {
  fmt.Println(i)
 }
 var i int
 for i = 0; i < 4; i++ {
  fmt.Println(i)
 }
//break结束当前循环
//continue语句：结束本轮循环,然后进行循环条件判断，如果成立进行然后进入下一轮循环，否则退出循环

函数

定义：func 函数名 ( ) {函数体},参数：固定参数num1 int、不定参数arg …int,固定参数放在前面，不定参数放在后面

var num = play(1, 2, 4, 6)
 fmt.Println(num)
func play(num int, num1 int, arg ...int) int { // 表示指定函数返回的数据的类型
  fmt.Println("kkkkkkkkkkk")
  fmt.Println(num + num1)
  fmt.Println(arg[0] + arg[1])
  return arg[1]
}

数组

var Numbers [5]int = [5]int{1, 2, 3, 4, 5}
 for i := 0; i < len(Numbers); i++ {
  fmt.Println(Numbers[i])
 }
 for _, v := range Numbers {
  fmt.Println(v)
 }
 //数组做为函数参数func play(num [5]int){}

二维数组：var 数组名 [ x ][ y ] 类型

 var arr [2][3]int = [2][3]int{{1, 2, 3}, {5, 6, 7}}
 var arr1 [2][3]int = [2][3]int{{1, 2}, {6}} // 部分初始化
 var arr2 [2][3]int = [2][3]int{0: {1: 6}}   // 指定元素初始化
通过初始化确定二维数组行数
 arr3 := [...][3]int{{1, 2, 3}, {5, 6}} // 行的下标可以用"..."来代替，但是列的下标不能用"..."来代替。
 fmt.Println(arr)                       //[[1 2 3] [5 6 7]]
 fmt.Println(arr1)                      // [[1 2 0] [6 0 0]]
 fmt.Println(arr2)                      //[[0 6 0] [0 0 0]]
 fmt.Println(arr3)                      //[[1 2 3] [5 6 0]]
 fmt.Println(len(arr))                  //几行
 fmt.Println(len(arr[0]))               //几列
 for i := 0; i < len(arr); i++ {
  for j := 0; j < len(arr[0]); j++ {
   fmt.Println(arr[i][j])
  }
 }
 for _, v := range arr {
  for j, data := range v {
   fmt.Println(j)    //每行索引
   fmt.Println(data) //对应数值
  }
 }

切片：也称动态数组，但是不是数组

s := make([]int, 3, 5) //长度len3，容量cap5
 fmt.Println(s)
 fmt.Println(len(s)) // 长度不能大于容量。容量可以省略，省略后容量和长度是相同的
 fmt.Println(cap(s))
 s = append(s, 1, 2, 3, 4, 5) //append拼接s和后面一串，称函数追加值
 s = append(s)//也可以不追加，此时相当于对s里面的元素进行初始化为0
 // s[3] = 88
 fmt.Println(s[3])
 fmt.Println(s)

map

var m map[int]string = map[int]string{1: "张三", 2: "李四", 4: "llll"} //定义+初始化
 m1 := make(map[string]int, 10) //定义
 m1["张三"] = 12//初始化
 fmt.Println(m)//map[1:张三 2:李四]
 fmt.Println(m1) //map[张三:12]
 fmt.Println(len(m)) // len()返回的是map中已有的键值对个数。
 fmt.Println(m[4])
//map作为函数参数func PrintMap(m map[int]string) {}

结构体

type Student struct {
  id    int
  name  string
  age   int
  addr  string
  isStu bool
 } //注意，默认整型初始化为0，bool初始化为false,字符初始化为" "
 var s Student = Student{101, "张三", 18, "北京", false} //不能省略任何一个值
 fmt.Println(s)                                      //{101 张三 18 北京}
 var s1 Student = Student{name: "张三", age: 18}
 fmt.Println(s1) //{0 张三 18 北京}
 var s2 Student
 s2.age = 19
 s2.name = "s2"
 fmt.Println(s2) //{0 s2 19 }

结构体数组

 var arr [3]Student = [3]Student{
  Student{101, "张三", 18, "北京", false},
  Student{102, "李四", 18, "北京", false},
  Student{103, "王五", 19, "北京", false},
 }
 fmt.Println(arr)
 结构体切片var arr []Student = []Student{}、
 结构体map m := make(map[int]Student)
 m[1] = Student{101, "张三", 18, "北京",false}
 m[2] = Student{102, "李四", 18, "北京",false}
 结构体作为函数参数
 func PrintDemo(stu Student) {
  stu.age = 20
  fmt.Println(stu) // {101 张三 20 北京}
 }

指针

var a int = 10
 var p *int
 fmt.Println(p) //未赋值前为空指针
 p = &a
 fmt.Println(&a) //0xc000128058
 fmt.Println(p)  //0xc000128058引用地址
 fmt.Println(&p) //0xc00014c018指针地址
 fmt.Println(*p) //10
 var p1 *int = new(int)
 *p1 = 67
 fmt.Println(*p1) //67

指针作函数参数

func update(p *int){
 }

数组指针

nums := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
 var p2 *[10]int
 p2 = &nums
 fmt.Println(*p2)

指针数组

var p3 [2]*int = [2]*int{new(int), new(int)}
 *p3[0] = 1
 *p3[1] = 2
 fmt.Println(p3)     //[0xc000014098 0xc0000140b0]
 fmt.Println(*p3[0]) //1

切片指针

s := []int{1, 2, 3, 4, 5, 6}
 var p *[]int
 p = &s
 fmt.Println(*p)      //[1 2 3 4 5 6]
 fmt.Println((*p)[0]) //1

结构体指针

stu := Student{101, "张三", 18, "北京", false}
 var p *Student
 p = &stu
 fmt.Println(*p) //{101 张三 18 北京 false}