Go语言学习(Day1)

一.输出

fmt.Print(),不换行输出，fmt.Printf("%v", a)不换行格式化输出，%v可以代表任何类型的变量,fmt.Println(),换行输出。

package main

import (
	"fmt"
)

func main() {
	var a = "initial"
	_ = a
	var b, c int = 1, 2
	_ = b
	_ = c
	t := 1
	fmt.Print(a)
	fmt.Print("\n")
	fmt.Printf("第%v\n", t)
	fmt.Println("hello_go")

}

二.变量

变量的声明：

第一种方法

var a = "initial"

会自动推到变量的类型

也可以

var b, c int = 1, 2

第二种方法

a := 1

同样是会自动推导a的变量类型，跟python类似，十分方便
注意

声明了变量a之后，会有报错，是因为在go中声明变量不用是会报错了，当你使用此变量之后，就不会报错了。

可以在后面加一行，就不会报错了

a := 1
_ = a

go查看变量的数据类型

a := 1
_ = a
fmt.Println(a, reflect.TypeOf(a))

三.if/else

if 7%2 == 0 {
		fmt.Println("7 is even")
	} else {
		fmt.Println("7 is odd")
	}
	var num string
	if fmt.Scan(&num); num == "9" {
		fmt.Println(num, "is negative")
	} else {
		fmt.Println(num, "has multiple digits")
	}

注意

else 要写到if的后面括号的后面，不能另起一行

if 后面没有括号

三.循环

golang中没有while do while,只有for 循环

写法一 

与if 一样，没有括号，裸露在外面

for i := 0; i < 9; i++ {
		fmt.Println(i)
	}
for j := 0; j < 9; j++ {
	if j == 2 {
		fmt.Println("没有跳过")
	} else {
		continue
	}
}
for n := 0; n < 9; n++ {
	if n == 3 {
		break
	} else {
		fmt.Println(n)
	}

}

写法二

i := 0
for i <= 3 {
	fmt.Println(i)
	i += 1
}

输入写法

var num int
for fmt.Scan(&num); num < 9; num++ {
	fmt.Println(num)
}

死循环

for ;; {
       fmt.Println(66) 
	}
for {
		fmt.Println(66)
	}

四.switch

    var a int
	for i := 0; i < 3; i++ {

		fmt.Scan(&a)
		switch a {
		case 1:
			fmt.Println("one")
		case 2:
			fmt.Println("two")
		case 3:
			fmt.Println("three")

		}
	}

不用写break,go直接会退出，不同于c++,java

swith后可以不加任意变量，case后面写条件分支，可以当作if分支结构用

    t := time.Now()
	switch {
	case t.Hour() < 12:
		fmt.Println("小于12")
	default:
		fmt.Println("大于12")
	}

五.数组

数组声明的索引是固定的，不能灵活改变元素的量，在业务中切片使用较数组多

声明数组a之后，默认是给所有元素赋值0

两种声明方式

    var a [5]int
	fmt.Println(a)
	a[4] = 100
	fmt.Println(a, len(a))
运行结果
[0 0 0 0 0]
[0 0 0 0 100] 5

    b := [5]int{1, 2, 3}
	fmt.Println(b, len(b))
运行结果
[1 2 3 0 0] 5

二维数组

    var towD [2][3]int
	for i := 0; i < 2; i++ {
		for j := 0; j < 3; j++ {
			towD[i][j] = i + j
		}
	}
	for i := 0; i < 2; i++ {
		for j := 0; j < 3; j++ {
            //fmt.Print 不换行输出
			fmt.Print(towD[i][j])
		}
        //fmt.Println 换行输出
		fmt.Println()
	}
运行结果
012
123

六.切片

切片类似于python中的列表

声明方式

3为切片的元素个数

s = make([]String, 3)

    s := make([]string, 3)
	s[0] = "a"
	s[1] = "b"
	s[2] = "c"
	fmt.Println(s, len(s))
	for i := 0; i < 3; i++ {
		fmt.Println(s[i])
	}
运行结果
[a b c] 3
a
b
c

append 给切片扩容，添加元素之后重新赋值给切片

    s := make([]string, 3)
	s[0] = "a"
	s[1] = "b"
	s[2] = "c"
    s = append(s, "d")
	s = append(s, "e")
	fmt.Println(s, len(s))
运行结果
[a b c d e] 5

copy 将切片s复制给切片c

    s := make([]string, 3)
	s[0] = "a"
	s[1] = "b"
	s[2] = "c"
	s = append(s, "d")
	s = append(s, "e")
	c := make([]string, len(s))
	copy(c, s)
	fmt.Println(c, len(c))
运行结果
[a b c d e] 5

切片操作，跟python类似，同样是，包头不包尾，但是没有负数索引

    fmt.Println(s[2:4])
	fmt.Println(s[:4])
	fmt.Println(s[2:])
运行结果
[c d]    
[a b c d]
[c d e]  

不用make，直接给切片赋值

    good := []string{"g", "o", "o", "d"}
	fmt.Println(good)
运行结果
[g o o d]

go切片不同于python列表的是，没有逗号分隔