GO学习-基础概念01

第一节

任何GO程序都是由包组成，程序的入口

package main

如何导入包？有两种形式：

import "fmt"

package main

import (
	"fmt"
	"math/rand"
	"time"
	"sync"
)

包名与导入路径的最后一个元素一直，比如math / rand导入的是rand这个包

导出名称

在GO里面，导出名称由大写字母开头，例如Pi是一个导出名称。

函数

可以有0个或者多个参数

package main

import "fmt"

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

func main() {
	fmt.Println(add(43, 13))
}

仔细看参数部分， 参数类型是跟在参数后面的 。为什么要这么做呢？GO官方的解释是说为了更方便阅读，在写复杂的式子的时候阅读性会明显比C语言高，地址https ：//blog.golang.org/gos-declaration-syntax

当参数类型是一样的时候，可以简化写

x int , y int  简写为 x , y int

同时，一个函数可以有多个返回结果，返回结果的类型在函数头部分声明。

package main

import "fmt"

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

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

如果返回值的名字在函数头部分声明了，那么就可以直接写返回不接东西了。不过记住这样的写法只在一些短小的函数种使用。

package main

import "fmt"

func split(sum int) (x, y int) {
	x = sum * 4 / 9
	y = sum - x
	return
}

func main() {
	fmt.Println(split(17))
}

变量

用var声明变量，变量类型写在变量后面， var可以在函数外面声明，也可以在函数里面声明

package main

import "fmt"

var c, python, java bool

func main() {
	var i int
	fmt.Println(i, c, python, java)
}

还可以在声明时候对变量初始化， 如果初始参数是确切的类型，那么可以省略类型声明

package main

import "fmt"

var i, j int = 1, 2

func main() {
	var c, python, java = true, false, "no!"
	fmt.Println(i, j, c, python, java)
}

更简单的一种声明方式，但是 只能在函数体内使用 ，而不能在函数体外使用

package main

import "fmt"

func main() {
	var i, j int = 1, 2
	k := 3
	c, python, java := true, false, "no!"

	fmt.Println(i, j, k, c, python, java)
}

GO语言的基本变量类型有

bool

string

int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr

byte // alias for uint8

rune // alias for int32
     // represents a Unicode code point

float32 float64

complex64 complex128

同时，在全局声明变量也可以这样简化声明，在正常情况下，一般都是声明int类型的整数

package main

import (
	"fmt"
	"math/cmplx"
)

var (
	ToBe   bool       = false
	MaxInt uint64     = 1<<64 - 1
	z      complex128 = cmplx.Sqrt(-5 + 12i)
)

func main() {
	fmt.Printf("Type: %T Value: %v\n", ToBe, ToBe)
	fmt.Printf("Type: %T Value: %v\n", MaxInt, MaxInt)
	fmt.Printf("Type: %T Value: %v\n", z, z)
}

即使不赋值 ，也会由初值

package main

import "fmt"

func main() {
	var i int
	var f float64
	var b bool
	var s string
	fmt.Printf("%v %v %v %q\n", i, f, b, s)
}

类型的强制转换格式：T（v），记住与C语言不同，GO里没有自动强制转换，所以两个类型不同的东西之间，一定要写强制转换

package main

import (
	"fmt"
	"math"
)

func main() {
	var x, y int = 3, 4
	var f float64 = math.Sqrt(float64(x*x + y*y))
	var z uint = uint(f)
	fmt.Println(x, y, z)
}

类型引用，其实就是类型有传递性

var i int //我有确切的类型
j：= i // j会引用我的类型int

package main

import "fmt"

func main() {
	v := false // change me!
	fmt.Printf("v is of type %T\n", v)
}

常量

常量是由const来声明的，且const在名称之前，常量可以是字符，数字，布尔型

常量是不能以：=这种简化模式声明的！

package main

import "fmt"

const Pi = 3.14

func main() {
	const World = "世界"
	fmt.Println("Hello", World)
	fmt.Println("Happy", Pi, "Day")

	const Truth = true
	fmt.Println("Go rules?", Truth)
}

如果一个常量在声明的时候是无符号的，那么其类型将在其被使用的时候的形参所确定

package main

import "fmt"

const (
	// Create a huge number by shifting a 1 bit left 100 places.
	// In other words, the binary number that is 1 followed by 100 zeroes.
	Big = 1 << 100
	// Shift it right again 99 places, so we end up with 1<<1, or 2.
	Small = Big >> 99
)

func needInt(x int) int { return x*10 + 1 }
func needFloat(x float64) float64 {
	return x * 0.1
}

func main() {
	fmt.Println(needInt(Small))
	fmt.Println(needFloat(Small))
	fmt.Println(needFloat(Big))
}