Golang基础语法

一、变量定义

使用关键字var定义变量：
   1、var [变量名] [变量类型]
  例如： var a int (未给变量赋初始值则变量会有默认值，当前变量默认值为0)
   2、var [变量名] [变量类型] = [变量值] ---- 例如：var a int = 1
   3、var [变量名],[变量名],... [变量类型] = [变量值],[变量值],...
  例如： var a, b, c int = 1, 2, 3 (同时定义多个变量并赋值时必须保证每个变量都赋值)
   4、var [变量名],[变量名],[变量名],... = [变量值],[变量值],[变量值]...
  例如： var a, b, c = 1, "hh", false
  (未定义变量类型时，可以同时定义多个不同类型的变量;go语言编译器能根据变量值自动推断出变量类型)
   5、var (
      [变量名] = [变量值]
      [变量名] = [变量值]
      ...
     )
使用“:=”定义变量
   [变量名] := [变量值]
   例如：a := 1 (符号":="定义变量的方式只能在函数内使用，函数外必须有关键字开头)

var (
    name  = "猪猪"
    age   = 18
    phone = 12345678
)
func variableDefaultValue() {
    var a int
    var b string
    fmt.Printf("%d,%q\n", a, b)
}

func variableInit() {
    var a, b = 1, "test"
    println(a, b)
}

func variableMultiple() {
    a, b, c := 1, 2, 3
    println(a, b, c)
}

go语言中定义的变量必须被使用，在函数外定义的变量称为：包内变量

二、 内建变量类型

bool 、 string
(u)int 、(u)int8 、(u)int16 、(u)int32、(u)int64、uintptr(指针) --- 加u即无符号整数
byte 、rune
float32、float64、complex64(实数float32、虚数float32) 、complex128(实数float64、虚数float64)

• 强制类型转换

func demo() {
    a, b := 3, 4
    var c int
    c = int(math.Sqrt(float64(a*a + b*b)))
    println(c)
}

• 变量要点

1、变量类型写在变量名之后
2、编译器可推测变量类型
3、没有char,只有rune
4、原生支持复数类型

三、 常量与枚举

/**
 *常量和枚举
 *使用关键字const定义常量，和定义变量基本相同
 *枚举类型：
 *  普通枚举
 *  自增值枚举
 */
func constDemo() {
    //定义常量
    const a = 1
    const b, c = 4, 5
    const project = "golang"
    println(a, b, c, project)
    const (
        language = "golang"
        code     = 01
    )
    println(language, code)
    //普通枚举
    const (
        java   = 01
        golang = 02
        scala  = 03
    )
    println(java, golang, scala)
    //自增值枚举
    const (
        lua = iota
        spark
        python
    )
    println(lua,spark,python)
}

四、条件语句

/**
 * 条件语句
 * if [表达式] {}else{}
 * switch [表达式(可忽略)]
 *
 */
func demo(code int) string {

    a := "hello"
    c := "go"
    d := a + c

    e := "hello" + "go"

    if d == e {
        fmt.Println(true)
    } else {
        fmt.Println(false)
    }

    if b := "hello"; a == b {
        fmt.Println(true)
    } else {
        fmt.Println(false)
    }

    switch {
    case code == 1:
        return "春天"
    case code == 2:
        return "夏天"
    case code == 3:
        return "秋天"
    case code == 4:
        return "冬天"
    default:
        panic("code wrong")
    }
}

• 总结

1、if 语句的条件不需要()
2、if 的条件里可以赋值
3、if 的条件里赋值的变量作用域就在这个if语句里
4、switch 语句会自动break，除非使用fallthrough
5、switch后可以没有表达式

五、循环

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
)

func main() {
    sum := 0
    for i := 1; i <= 10; i++ {
        sum += i
    }
    fmt.Println(sum)

    fmt.Println(convertToBin(10),
        convertToBin(32832),
        convertToBin(8),
    )

    printFile("test.txt")
    forever()
}

/**
 * 省略初始条件  相当于while
 */
func convertToBin(n int) string {
    res := ""
    for ; n > 0; n /= 2 {
        lsb := n % 2

        //strconv.Itoa(lsb) 转为字符串
        res = strconv.Itoa(lsb) + res
    }
    return res
}

/**
 * 没有初始条件和递增值
 */
func printFile(filename string) {
    file, err := os.Open(filename)
    if err != nil {
        panic(err)
    }

    scanner := bufio.NewScanner(file)

    for scanner.Scan() {
        fmt.Println(scanner.Text())
    }
}

/**
 * 无限循环
 */
func forever()  {
    for {
        fmt.Println("123")
    }
}

• 总结

1、for 循环的条件里不需要括号
2、for 的条件里可以省略初始条件，结束条件，递增表达式
3、没有while循环

六、函数

package main

import (
    "fmt"
    "math"
    "reflect"
    "runtime"
)

func calculate(a, b int, opt string) (int, error) {
    switch opt {
    case "+":
        return a + b, nil
    case "-":
        return a - b, nil
    case "*":
        return a * b, nil
    case "/":
        consult, _ := div(a, b)
        return consult, nil
    default:
        return 0, fmt.Errorf("unsupported opt: %s", opt)
    }
}

func apply(op func(int, int) int, a, b int) int {
    //通过反射获取函数名称
    pointer := reflect.ValueOf(op).Pointer()
    funcName := runtime.FuncForPC(pointer).Name()
    fmt.Printf("Calling function %s with args (%d, %d)\n", funcName, a, b)
    return op(a, b)
}

/**
 * 计算两数的商和余数 并返回
 */
func div(a, b int) (consult, remainder int) {
    return a / b, a % b
}

/**
 * a 的 b次方
 */
func pow(a, b int) int {
    return int(math.Pow(float64(a), float64(b)))
}

func sum(nums ...int) int {
    sum := 0
    for i := range nums {
        sum += nums[i]
    }
    return sum
}

func main() {

    res, err := calculate(7, 6, "X")
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println(res)
    }

    if res, err := calculate(1, 3, "X"); err != nil {
        fmt.Println("error:", err)
    } else {
        fmt.Println(res)
    }

    fmt.Println(calculate(5, 8, "/"))
    fmt.Println(div(10, 7))

    fmt.Println(apply(pow, 2, 3))
    fmt.Println(apply(func(a int, b int) int {
        return int(math.Pow(float64(a), float64(b)))
    }, 2, 3))

    fmt.Println(sum(1,4,5,6,3))
}

• 总结

1、函数可以返回多个值并可以起名字
2、仅用于非常简单的函数
3、对于调用者来说没有区别
4、函数可作为参数
5、没有默认参数，可选参数

七、指针

func swap(a, b *int) {
    *b, *a = *a, *b
}

func main() {
    a, b := 3, 4
    swap(&a, &b)
    fmt.Println(a, b)
}

• 总结

1、指针不能运算
2、只有值传递一种方式

八、数组

package main

import "fmt"

func arrays(arr [5]int)  {
    arr[0] = 10
    for i := range arr{
        fmt.Println(arr[i])
    }
}



func main() {

    //定义数组的方式
    //数量写在类型前
    var arr1 [3]int
    arr2 := [5]int{1, 2, 3, 4, 5}
    arr3 := [...]int{1, 3, 6, 4}
    fmt.Println(arr1, arr2, arr3)
    //遍历数组
    //方式一
    for i := 1; i < len(arr2); i++ {
        fmt.Println(arr2[i])
    }

    fmt.Println("--------------------------")
    //方式二
    for i := range arr2{
        fmt.Println(arr2[i])
    }
    fmt.Println("--------------------------")
    //方式三，获取值和下标
    for i,v := range arr2{
        fmt.Println(i,v)
    }

    fmt.Println("arrays------------------------")
    arrays(arr2)

    fmt.Println("arr2----------------")
    fmt.Print(arr2)
}

• range关键字

1、意义明确
2、任何地方都能通过'_'省略变量
3、可以同时获取下标和值

• 数组是值类型

1、[10] int 和 [20] int 是不同类型
2、调用 func f(arr [10] int ) 会 拷贝 数组
3、在go 语言中一般不直接使用数组

九、Slice（切片）---- 相当于java的list

image.png

Slice的实现

package main

import "fmt"

func updateVal(arr []int) {
    arr[0] = 10
}

func main() {

    array := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
    fmt.Println("array[2:6] = ", array[2:6])
    fmt.Println("array[2:] = ", array[2:])
    fmt.Println("array[:6] = ", array[:6])
    fmt.Println("array[:] = ", array[:])

    fmt.Println("update array before : ", array)
    updateVal(array[:])
    fmt.Println("update array after: ", array)

    s1 := array[1:5] //[1 2 3 4]
    fmt.Println("s1 = array[1:5] = ", s1)
    s2 := s1[3:5]
    fmt.Println("s2 = ", s2)
    fmt.Println("-------------------------------")
    fmt.Printf("s1=%v, len(s1)=%d, cap(s1)=%d\n", s1, len(s1), cap(s1)) //cap(s1) = [1, 2, 3, 4, 5, 6, 7]
    fmt.Printf("s2=%v, len(s2)=%d, cap(s2)=%d\n", s2, len(s2), cap(s2)) //cap(s2) = [4, 5, 6, 7]

}

1、Slice本身没有数据，是对底层array的一个view
2、Slice可以向后扩展，不可以向前扩展
3、s[i] 不可以超越 len(s) , 向后扩展不可以超越底层数组cap(s)

• 切片的操作
  1、向Slice添加元素时，如果超越cap，系统会重新分配更大的底层数组
  2、由于值传递的关系，必须接收append的返回值 例如 s = append(s,val)

package main

import "fmt"

func printSlice(s []int) {
    fmt.Printf("%v, len=%d, cap=%d\n", s, len(s), cap(s))
}



func main() {
    var s []int //zero val for slice is nil
    for i := 0; i < 10; i++ {
        printSlice(s)
        s = append(s, 2*i+1)
    }
    fmt.Println(s)

    s1 := []int{2, 4, 6, 8}
    printSlice(s1)

    s2 := make([]int, 10)
    s3 := make([]int, 8, 16)
    fmt.Println(s2)
    fmt.Println(s3)

    fmt.Println("Slice copy")
    copy(s2, s1)
    printSlice(s2)

    fmt.Println("Slice delete")
    s2 = append(s2[:3],s2[4:]...)
    printSlice(s2)

    fmt.Println("popping from front")
    front := s2[0]
    s2 = s2[1:]
    fmt.Println(front)
    printSlice(s2)


    fmt.Println("popping from back")
    back := s2[len(s2)-1]
    s2 = s2[:len(s2)-1]
    fmt.Println(back)
    printSlice(s2)
}

十、Map

• 定义
  变量名 [key type] value type {}
  例如：

m := map [string] string {
        "name": "hhh",
        "age": "18",
     }

• 复合map
  map[K1]map[K2]V

package main

import "fmt"

func main() {

    fmt.Println("定义map------------------------------------------")
    //定义map
    //方式一  m == nil   变量名称为m  key为string类型  value为string类型
    var m map[string]string
    fmt.Println("m = ", m)
    //方式二
    m2 := map[string]string{
        "course":  "golang",
        "article": "map",
        "test":    "delete",
    }
    fmt.Println("m2 = ", m2)
    //方式三  m3 == empty map
    m3 := make(map[int]string)
    fmt.Println("m3=", m3)

    fmt.Println("遍历map-------------------------")
    //遍历map
    for k, v := range m2 {
        fmt.Println("m2 的key和val: ", k, v)
    }
    for k := range m2 {
        fmt.Println("m2 的key: ", k)
    }
    for value := range m2 {
        fmt.Println("m2 的val: ", value)
    }

    fmt.Println("根据key获取元素----------------------------")
    //根据key值获取元素
    val := m2["course"]
    fmt.Println(val)

    fmt.Println("判断map中的元素是否存在-----------------------------")
    //判断map中的元素是否存在
    val2, ok := m2["course"]
    fmt.Println(val2, ok)

    if val3, ok := m2["course"]; ok {
        fmt.Println(val3)
    } else {
        fmt.Println("val is not exist")
    }

    fmt.Println("根据Key删除元素-----------------------")
    //根据Key删除元素
    fmt.Println("删除m2的元素前：",m2)
    delete(m2, "test")
    fmt.Println("删除m2的元素后：",m2)

}

• 总结

1、map是无序的
2、key不存在时，获得value类型的初始值
3、map使用哈希表，必须可以比较相等
4、除了slice，map，function的内建类型都可以作为key
5、Struct类型不包含上述字段，也可作为key

十一、字符和字符串

• rune （相当于go的char）

1、使用range 遍历pos,rune对
2、使用utf8.RuneCountInString获得字符数量
3、使用len获得字节长度
4、使用[]byte获得字节