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)
}