应用程序入口

  1. 必须是main包， package main
  2. 必须是main函数， func main()
  3. 文件名可以不是main.go
  4. 文件目录名也可以不为main，不过一般包名和目录名相同

main函数

  • main函数没有返回值也没有参数
  • 可以通过 os.Exit 函数来返回退出状态码
  • 可以通过 os.Args 来获取命令行参数，array，第一个元素为程序名（包含路径），后面的才是参数 ```go package main

import ( “os”
)

func main(){ fmt.Println(os.Args) os.Exit(0) // 正常退出 // os.Exit(1) // 非正常退出 }

  2. <a name="DCOiI"></a>
  3. # 变量定义
  5. - Go语言中推荐使用驼峰式命名
  6. - 除全局变量外，变量声明必须使用，否则编译将报错 `xxx declared and not used`
  9. <a name="gsJHi"></a>
  10. ## 定义变量
  11. ```go
  12. // var 变量名 类型
  13. var num int   // 定义后为该类型的零值  0
  14. var s string  // "" 空字符串
  15. var flag1, flag2 bool // 同时定义多个变量
  17. // 定义多个变量时 简略写法
  18. var (
  19.     a = 10   // 直接定义赋值
  20.     b int    // 定义变量  0
  21.     c string // ""
  22. )

定义变量并赋值

  1. // 定义变量并赋值
  2. var a string = "abc"
  3. var b,c int = 15
  5. var d = 14  // 类型可以省略，编译器自动推导
  6. var x,y,o,s = 1, 2, true, "Go"  // 可赋值不同类型的值

简短变量声明

只能在函数内使用 := 进行定义变量和初始化, 函数外部只能用 var 定义变量

  1. func foo(){
  2.     num := 12  // 等价于  var num = 12 
  3.     a, b, s := 1, 2, "Go"
  4. }

匿名变量

使用多重赋值时，如果想忽略某个值，可以使用匿名变量。匿名变量使用一个下划线 _ 表示。

  1. func foo() (bool, string){
  2.     return true, "Hello Go"
  3. }
  5. func main() {
  6.     isOk, _ := foo() // 只接收bool值，丢弃string
  7. }

常量

定义常量

使用 const 定义常量, 常量定义后值不能修改
常量名和其他语言不通

  1. const a = 10
  2. const (
  3.     b = 20
  4.     s = "Go"
  5. )

批量声明常量时如果某一行没有赋值，则默认和上行相同

  1. const (
  2.      a = 100 // 100
  3.     b        // 100
  4.     c        // 100
  5. )

iota

  • iota Go语言的常量计数器，只能在常量的表达式中使用
  • iota 在 const 声明时将重置为 0
  • const 中每新增一行常量声明将使iota计数加一(iota可理解为const语句块中的行索引)

    1. const (
    2.    zone = iota // 0 
    3.    one  = iota // 1
    4.    tow         // 2
    5.    _           // 忽略
    6.    four        // 4
    7.    five        // 5
    8. )
  1. const (
  2.     B = 1<<10 * iota  // 1 << 10 * 0  = 1
  3.     KB                  // 1 << 10 * 1  = 1 << 10 = 1024 
  4.     MB                  // ...
  5.     GB
  6.     TB
  7. )

基本数据类型

整数

（u为无符号）

  • (u)int 在 32 位系统中为 int32，在 64 位系统中为 int64
  • (u)int8
  • (u)int16
  • (u)int32
  • (u)int64
  • uintptr 指针

浮点型

  • float32
  • float64
  • complex64
  • complex128

bool

  • 值只有：true 和 false
  • 不允许将整数转换为布尔值

string

  • 字符串必须使用双引号
  • 单引号为字符
  • 多行字符串 使用 ``` 反引号
  • 字符串常用操作
    • len(str) : 求长度，字节（byte）数
    • + 或 fmt.Sprintf() : 拼接字符串
    • strings.Split() : 分割
    • strings.contains() : 判断是否包含
    • strings.HasPrefix strings.HasSuffix : 前缀、后缀判断
    • strings.Index strings.LastIndex : 子串出现的位置
    • strings.Join() : 将切片拼接成字符串

byte 和 rune

  • byte 字符类型 8位， uint8
  • rune 字符型 32 位, int32 存放utf8 字符

类型转换

  • Go 中类型不能进行隐式转换，必须强制转换
  • 别名和原有类型也不能进行隐式类型转换
  • bool 类型不能转换为int ```go var a, b, c int

c = int(math.Sqrt(float64(a a + b b)))

  2. <a name="8ztV9"></a>
  3. # 流程控制
  5. <a name="RBBHH"></a>
  6. ## if else
  8. ```go
  9. if a >= 90 {
  10.     fmt.Println("优")
  11. }else if a >= 70 {
  12.     fmt.Println("良")
  13. }else if a >= 60 {
  14.     fmt.Println("及格")
  15. }else{
  16.     fmt.Println("不及格")
  17. }

if 的条件里可以赋值，作用域仅在该 if 语句内

  1. if contents, err := ioutil.RadFile("1.txt"); err{
  2.     fmt.Println(string(contents))
  3. }else {
  4.     fmt.Println(err)   
  5. }

switch

switch 会自动 break，除非使用 fallthrough

  1. switch op {
  2.     case "+":
  3.         result = a + b
  4.     case "-":
  5.         result = a - b
  6.     default:
  7.         panic("该运算符不支持")
  8. }
  1. switch num {
  2.     case 1, 2:
  3.     fmt.Println("A")
  4.     case 3,4:
  5.     fmt.Println("B")
  6.     default:
  7.     fmt.Println("C")
  8. }
  1. switch {
  2.     case a > 10:
  3.     fmt.Println("A > 10")
  4.     case a == 10:
  5.     fmt.Println("A == 10")
  6.     default:
  7.     fmt.Println("A < 10")
  8. }

fallthrough

fallthrough 可以执行满足条件的case的下一个case

循环 for

  1. // 1. 基本使用
  2. for i:=0; i<10; i++ {
  3.     fmt.Println(i)
  4. }
  6. // 2. 省略初始语句
  7. var i = 1
  8. for ;i<10; i++ {
  9.     fmt.Println(i)   
  10. }
  12. // 3. 相当于其他语言中 while循环
  13. var i = 5
  14. for i < 10{
  15.     fmt.Println(i)
  16. }
  18. // 4. 死循环
  19. for {
  21. }

for range

  1. s := "hello GO语言"
  2. for i, c := range s {
  3.     fmt.Println(s)   
  4. }

break continue

  • break 跳出循环
  • continue 跳过本次循环

运算符

算术运算符

+ 加 - 减 * 乘 / 除 % 求余

++ 和 -- 是单独的语句，不能放在等号右边

关系运算符

== 等于 != 不等于 > 大于 >= 大于等于 < 小于 <= 小于等于

逻辑运算符

&& 与 ` ` 或 ! 非

位运算符

& 按位与 ` ` 按位或 ^ 异或 << 左移 >> 右移 &^ 按位清零 
  1. // 按位清零
  2. 1 &^ 0 == 1
  3. 1 &^ 1 == 0
  4. 0 &^ 1 == 0
  5. 0 &^ 0 == 0

赋值运算符

= += -= *= /= %=
<<= >>= &= &#124;= ^=