Go語言學習Part1：包、變量和函數

明日就可以用Go做leetcode的題目，有點小激動hhhh
https://tour.go-zh.org/list

包引入

import fmt
import math

分組包引入

import {
    "fmt"
    "math/rand"
    "math"
}

相關的函數

rand.Intn(10)
math.Sqrt(10)

Printf

fmt.Printf("res is %g.\n", math.Sqrt(10))
fmt.Printf("res is %d.", rand.Intn(4))

導出名

• 如果一個名字以大寫字母開頭，那它就是導出的，導出的才能在包外部訪問

fmt.Printf("res is %g.\n", math.Pi)

函數

• 類型在變量名之後

package main    

import "fmt"

func add(x int, y int) int{
    return x+y
}

func main() {
    fmt.Println(add(10, 12))
}

• 變量名類型一致，則除了最後一個均可以省略

func add(x, y int) int{
    return x+y
}

• 函數可以返回多個值， 返回值類型用括號括起來且用,分割
  • 賦值語句用:=

package main

import "fmt"

func swap(x, y string) (string, string) {
    return y, x
}

func main() {
    a, b := swap("my", "yours")
    fmt.Println(a, b)
}

• 函數返回值可以被命名，函數主體返回空也木有關係

package main

import "fmt"

func swap(x, y string) (a, b string) {
    a = y
    b = x
    return 
}

func main() {
    fmt.Println(swap("my", "yours"))
}

變量

變量列表

• var生成一個變量列表，變量類型在最後
• 可以在函數，也可以在包裏面

package main
import "fmt"

var a, b, c bool

func main() {
    var d int
    fmt.Println(a,b,c,d)
}

變量初始化

• 變量在聲明的過程中可以進行初始化
• 如果初始化值存在，可以不寫類型，因爲可以從初始化值裏面獲取類型

package main
import "fmt"

var a, b, c bool = true, false, true

func main() {
    var d = "hello"
    fmt.Println(a,b,c,d)
}

短變量聲明

• 簡潔賦值 :=可以代替var聲明
• 函數外的每一個語句都要以關鍵字開始，所以:=不能寫在函數外

package main
import "fmt"

var a, b, c bool = true, false, true

func main() {
    d := "hello"
    fmt.Println(a,b,c,d)
}

變量

變量的基本類型

• 複數complex64，實部和虛部都是float32
• int uint uintptr在32系統是32位，在64位系統是64位

bool
int int8 int16 int32 int64 
uint uint8 uint16 uint32 uint64 uintptr
string
float32 float64
complex64 complex128

byte // uint8別名
rune //int32別名

舉個mini 的沒咋見過的複數例子哈哈【略微震驚的不行】

package main
import "fmt"
import "math/cmplx"
var (
    a int = 1 << 32
    b complex128 =  cmplx.Sqrt(-5+12i)
)
func main() {
    fmt.Println(a)
    fmt.Println(b)
	fmt.Printf("Type is %T, value is %v", b, b)
}

變量的零值

• 聲明之後沒有初始化，會賦予零值

bool false
int 0
string ""

變量類型轉換

• 必須顯示轉換，就是強行轉換下

package main

import "fmt"

var (
    b int = 2
    c float32 = float32(b)
    d uint = uint(c)
)
func main() {
    fmt.Printf("Type is %T, Value is %v\n", b, b)
    fmt.Printf("Type is %T, Value is %v\n", c, c)
    fmt.Printf("Type is %T, Value is %v\n", d, d)
}

類型推導

• 聲明一個變量但是沒有指定類型，類型可以從右邊的值推導

package main

import "fmt"

var (
    a int
    b = a
)
func main() {
    fmt.Printf("Type is %T\n", b)
}

常量

• 常量只能用const關鍵字，不能用:=語法聲明

package main
import "fmt"

const Pi = 3.141592657

func main() {
    fmt.Printf("Type is %T\n", Pi)
	const name = "liming"
    fmt.Println("hello ", name, ", welcome")
}

數值常量是高精度的值

• 下面代碼中的const改爲var就不行了

package main
import "fmt"

const (
    a = 1 << 100
    b = a >> 98
)

func getFloat(x float64) float64 {
    return x * 0.1
}
func main() {
    fmt.Println(getFloat(a))
    fmt.Println(getFloat(b))
}

Printf的種類，就看你見過沒

package main

import "fmt"

var (
    a complex128 = (-5+12i)
    b int = 2
    c float32 = 0.33
    d string = "nice"
)
func main() {
    fmt.Printf("Type is %T\n", a)
    fmt.Printf("Value is %v\n", a)
    fmt.Printf("Value is %d\n", b)
    fmt.Printf("Value is %g\n", c)
    fmt.Printf("Value is %q\n", d)
}