開始翻看菜鳥教程學習golang了，現在從最初的hello world開始學起，期間學到幾個問題。按道理應該一一記錄下來
1.包引入問題
一般來說開頭這幾行代碼最常見，對我自己基本次次都在
package main
import (
"fmt"
"strconv"
)
注意事項，如果只有一個go文件，想要運行的話必須包含package main，如果換成其他包名則無法運行
另外fmt是一個格式輸出到控制檯的，裏面包含了類似python3的print方法
strconv是一個通用數據類型轉換工具，可以整數與字符串轉換等等
2.一個文件想要運行必須包含主函數，跟c語言入庫類似，比起python來說，python的主函數也是隻在自身調用時生效，自己調用自己可以不寫主函數。但是golang必須寫。類似下面的:
func main() {
fmt.Println("Hello, World!")
}
3.golang的func後面定義方法名字後，花括號左邊必須是在方法名行尾部，不能換行寫，這一點跟js隨便放是不一樣的
4.golang定義全局變量並不支持 :=的形式，親測的，必須用var。也就是寫在func外面的變量。在func裏面的變量可以用:=的方式初始化值和自動推斷，但是已經有初始化的值只需要直接寫=就好了，不然會報錯
5.關於golang的整數類型，分爲很多個，不像python就一個int，但是千萬不要被他唬住了。
| 1 | uint8 無符號 8 位整型 (0 到 255) |
| 2 | uint16 無符號 16 位整型 (0 到 65535) |
| 3 | uint32 無符號 32 位整型 (0 到 4294967295) |
| 4 | uint64 無符號 64 位整型 (0 到 18446744073709551615) |
| 5 | int8 有符號 8 位整型 (-128 到 127) |
| 6 | int16 有符號 16 位整型 (-32768 到 32767) |
| 7 | int32 有符號 32 位整型 (-2147483648 到 2147483647) |
| 8 | int64 有符號 64 位整型 (-9223372036854775808 到 9223372036854775807) |
菜鳥教程廢了這麼多話，其實簡而言之就是，int從8位到64位，每次翻倍，8，16，32，64
前面帶了u的證明是正整數，沒帶u的代表正負各一半
6.關於定義字符串變量或者常量的奇葩問題，不支持單引號
自己親測，定義的字符串必須用雙引號，單引號系統不認，這個不知道go怎麼想的，我按規矩來就行
7.fmt.println不支持字符串格式化，只是換行打印，如果需要字符串格式話得用fmt.printf的方法，例子:
func test() {
c:=7
d:=5
area:= area_count(c,d)
//printf可以格式和字符串
fmt.Printf("面積爲 : %d\n", area)
//println不行
fmt.Println("計算所得的面積是 %d \n",area)
//也可以用類型轉換來相加
fmt.Println("面積: "+strconv.Itoa(c))
println(url_index)
}
8. var與const，變量與常量定義時因式分解寫法
var (
g1 int = 1
g2 int = 2
g3 string = "4"
)
const (
author = "道長"
qq = "123456"
sex = "男"
)
9.golang裏面取字符串的長度也跟python一樣有一個len()函數，但是他取出的是裏面的字節位長度，比如兩個中文的字符串佔6位，len()後得到的返回值就是6，python裏面是2
10.
iota，特殊常量，可以認爲是一個可以被編譯器修改的常量。
iota 在 const關鍵字出現時將被重置爲 0(const 內部的第一行之前)，const 中每新增一行常量聲明將使 iota 計數一次(iota 可理解爲 const 語句塊中的行索引)。
iota 可以被用作枚舉值：
const (
a = iota
b = iota
c = iota
)
11.與或非邏輯運算符同js，跟python不一樣，用的是 && || !。其中&和|都是兩個，單個的話表示位運算
12.變量與指針。用的 &變量，*指針，千萬別弄反了
func ptr() {
a:=4
b:=&a
*b = 7
println(a)
}
&變量得到的是變量的地址，*指針得到是該變量，*指針賦值會改變原變量的值
13. switch case用法:
package main
import "fmt"
func main() {
/* 定義局部變量 */
var grade string = "B"
var marks int = 90
switch marks {
case 90: grade = "A"
case 80: grade = "B"
case 50,60,70 : grade = "C"
default: grade = "D"
}
switch {
case grade == "A" :
fmt.Printf("優秀!\n" )
case grade == "B", grade == "C" :
fmt.Printf("良好\n" )
case grade == "D" :
fmt.Printf("及格\n" )
case grade == "F":
fmt.Printf("不及格\n" )
default:
fmt.Printf("差\n" );
}
fmt.Printf("你的等級是 %s\n", grade );
}
package main
import "fmt"
func main() {
var x interface{}
switch i := x.(type) {
case nil:
fmt.Printf(" x 的類型 :%T",i)
case int:
fmt.Printf("x 是 int 型")
case float64:
fmt.Printf("x 是 float64 型")
case func(int) float64:
fmt.Printf("x 是 func(int) 型")
case bool, string:
fmt.Printf("x 是 bool 或 string 型" )
default:
fmt.Printf("未知型")
}
}
fallthrough
使用 fallthrough 會強制執行後面的 case 語句，fallthrough 不會判斷下一條 case 的表達式結果是否爲 true。
實例
package main
import "fmt"
func main() {
switch {
case false:
fmt.Println("1、case 條件語句爲 false")
fallthrough
case true:
fmt.Println("2、case 條件語句爲 true")
fallthrough
case false:
fmt.Println("3、case 條件語句爲 false")
fallthrough
case true:
fmt.Println("4、case 條件語句爲 true")
case false:
fmt.Println("5、case 條件語句爲 false")
fallthrough
default:
fmt.Println("6、默認 case")
}
}
從以上代碼輸出的結果可以看出：switch 從第一個判斷表達式爲 true 的 case 開始執行，如果 case 帶有 fallthrough，程序會繼續執行下一條 case，且它不會去判斷下一個 case 的表達式是否爲 true。
貼了這麼多代碼，要說明的東西也很簡單，跟js比起來，不需要每case結尾寫break，相當於是默認帶了break，但是爲了實現不進行break的想法，go多了一個fallthrough。等於跟js的switch case思路相反。js是默認可以挨個判斷，需要終止時自己寫的break.go是默認break，需要挨個進行是自己在 下面加上fallthrough