Go基礎01

1.go

1.Go是靜態（編譯型）強類型語言，是區別於解析型語言的弱類型語言(靜態：類型固定 強類型：不一樣類型不容許直接運算)。
	python動態強類型語言
2.哪些是編譯，哪些是解釋
    編譯：java，c，c++，c#，go
    解析型：python，js，php...
    編譯型語言涉及到跨平臺，由於它須要編譯成該平臺的可執行文件，java--》運行在jvm之上
    go：跨平臺編譯，交叉編譯，在windows平臺編譯出mac上可執行
    解釋型：不存在跨平臺問題，有解釋器
    跨平臺的編譯型語言，交叉編譯
核心:
    管道（channel），切片（slice），併發（routine）
    有垃圾回收的機制
    支持面向對象和麪向過程的編程模式（go的面向對象沒有類的概念）

2 開發環境搭建

#1  ide,集成開發環境（goland等同於pycharm）
	-goland（jetbrains全家桶），vscode
    -推薦用goland，pycharm，idea，androidstudio
    一路下一步
#2 開發環境 sdk
一路下一步
# 測試安裝成功
go version  把版本打印出來就裝成功了

# 3注意事項（重點）
	-goland建立項目，選擇go的安裝路徑（默認選中了）
    -gopath：全部的go代碼必須放在這個路徑下的src文件夾下，不然沒法執行，默認建立到用戶家目錄下的go文件夾（mac,windows,linux）
   	-建立項目路徑，go文件都不要出現中文
 
# 3 go命令

# 必須記住的
go env  # go的環境變量
	-GO111MODULE=空的，如今沒有使用MODULE模式
    -GOPATH=C:\Users\oldboy\go #代碼存放路徑
    -GOROOT=c:\go # go sdk安裝路徑
go build  # 編譯型語言，須要先編譯再執行，編譯成可執行文件，執行可執行文件
go run  # 編譯並執行，開發階段用，兩步並做一步

# 其餘不太須要記得
go get # 下載並安裝包和依賴等同於pip install
go version
go fmt  #運行gofmt進行格式化（go fmt ：自動將代碼格式）

3 helloword

1.go語言的註釋
//單行註釋

/*
...
 */

2.重點
//go（全部編譯型語言）項目要運行，必須有一個入口
//go的入口是main包下的main函數
// main包下可不能夠有多個main函數：不能夠
package main   //聲明包名，包名是main，每個go文件都屬於某個包

import "fmt"    //導入包，內置包

func main() {   //定義了一個main函數，大括號包裹是函數體的內容
	fmt.Println("hello world") //打印函數等同與print()
}
// 編譯
go build s1.go
// 執行
s1.exe
// 編譯並執行
go run s1.go
// 在goland中，右鍵，運行便可

4 變量(非全局變量定義了就必須使用，若是不使用就報錯)

package main
func main() {
	1 定義變量的第一種方式：全定義
	//var關鍵字 變量名 變量類型 = 變量值
	var age int =10     
	fmt.Println(age)

	2 定義變量的第二種方式：類型推導（類型不須要寫了）
	var age =10
	age=100
	var name ="lqz"
	fmt.Println(age)  //打印並換行
	fmt.Print(name)   //打印不換行
	fmt.Printf("%T\n",age)  //查看變量類型
	fmt.Printf("%T",name)
	fmt.Printf("%p",&name)

	3 定義變量的第三種方式：簡略聲明（類型和var關鍵字都不寫）這種用的多,冒號和等號是一家
	a:=10
	var a int =100  //重複定義
	var a =99    //重複定義
	a  :=                    99        //重複定義
	a=99
	fmt.Println(a)

	4 其餘變形方式
	//4.1  只定義不賦值
	var age int   //定義變量	//若是是隻定義，不賦值，只能用這種
	
	//4.2 聲明多個變量
	var width, height int = 100, 50 // 聲明多個變量
	var width,height =100,50      // 聲明多個變量
	var width,height =100,"lqz"      // 聲明多個變量
	width,height :=100,"qz"           // 聲明多個變量

	//4.3 聲明多個變量,並賦初值
	var (
		name   = "naveen"
		age  int  = 29
		height int
	     )
	fmt.Println(name,age,height)

	4.4 小坑
	var a int =10
	var b =99
	b,a:=99,100    //這個不報錯，咱們以爲是重複定義，冒號左側，只要有一個沒有定義過的變量，就能夠
	fmt.Println(b)
	fmt.Print(a)
	/*
	總結：
		1 變量類型在定義階段就肯定了，一旦肯定，不容許改變
		2 變量不能夠重複定義
		3 變量要先定義再使用
	 */
}

5 變量定義規範

/*
變量命名規範
	-變量命令建議用駝峯，（大小寫有特殊意義）
	-go文件命名建議用 下劃線
    - 一個名字必須以一個字母（Unicode字母）或下劃線開頭，後面能夠跟任意數量的字母、數字或下劃線
    -大寫字母和小寫字母是不一樣的：Name和name是兩個不一樣的變量
    -關鍵字和保留字都不建議用做變量名
*/

/*
Go語言中關鍵字有25個
break      default       func     interface   select
case       defer         go       map         struct
chan       else          goto     package     switch
const      fallthrough   if       range       type
continue   for           import   return      var

go語言中有37個保留字，主要對應內建的常量、類型和函數
內建常量: true false iota nil
內建類型:  int int8 int16 int32 int64
          uint uint8 uint16 uint32 uint64 uintptr
          float32 float64 complex128 complex64
          bool byte rune string error

內建函數: make len cap new append copy close delete
          complex real imag
          panic recover
 */

 

5類型(go只要數據類型不同就不可運算)

/*
		基礎數據類型
		數字：
			有符號整形
				-int：在32位機器是int32，在64位機器是int64
				-int8：表示整數範圍是：8個比特位，8個bit是1byte ，負數和0， 2的7次方-1 的範圍
				-int16 2的15次方減一
				-int32
				-int64
				定義8進制的數 var a = 010   // 十進制的8
				定義16進制的數 var a = 0xf   //十進制的15	
				fmt.Printf("%d \n", a)  // 10進制
				fmt.Printf("%b \n", a)  // 1010  佔位符%b表示二進制
				fmt.Printf("%o \n", b)  // 77
				fmt.Printf("%X \n", c)  // FF
			無符號整型
				-uint8   2的8次方減一  定義一我的的年齡
				-uint16
				-uint32
				-uint64

			浮點型（小數），表示小數點後長度多少位
				-float32
				-float64
			複數
				-complex64
				-complex128
			byte：是int8的別名  單引號包裹
			rune：是int32的別名  單引號包裹
		字符串
			雙引號包裹
			反引號包裹  ` `
		布爾
			bool true 和 false
		數據類型默認值：
			數字類型是0
			字符串類型是 空字符串
			布爾類型   false

	*/

6 常量

package main

//常量
func main() {
	1.第一種,常量的定義，
	//const  變量名  變量類型 = 變量值
	const  age int8 = 99
	//修改就報錯
	//age=199
	fmt.Println(age)

	2.第二種方式類型推導
	const age = 99
	age=88
	fmt.Println(age)

	3.其餘定義方式
	const name,age = "zhangsan",99
	const (
		name string ="lqz"
		age =99
	)
}
//const 關鍵字定義，不容許改變
iota 在const關鍵字出現時將被重置爲0。const中每新增一行常量聲明將使iota計數一次(iota可理解爲const語句塊中的行索引)。 使用iota能簡化定義，在定義枚舉時頗有用。

7 函數基礎

package main

import "fmt"

//給類型命別名
type MyFunc func(a,b int)(int,string)
type Myint  int
//函數
func main() {
	var a int =10
	var b Myint=9
	fmt.Println(a+int(b))

	//定義方式
	/*
		func 名字(參數名 類型，參數名 類型)(返回值類型，返回值類型){
			函數體內容
			return 返回值1，返回值2
		}
	*/
	//1 調用函數
	//add(2,3,"xxx")
	//var a int =add(2,3)
	//a := add(2, 3)
	//fmt.Println(a)
	//多返回值就須要用多變量接收
	//a,b:=add(3,4)
	//fmt.Println(a,b)
	//多返回值，忽略一個返回值
	//a,_:=add(3,4)
	//fmt.Println(a)
	//fmt.Println(_)


	//匿名函數(定義在函數內部的函數，不能是有名函數)，頭等函數
	//var a func()
	//a = func (){
	//	fmt.Println("我是匿名函數")
	//}
	//a()
	//函數返回值是函數
	//a:=test()
	//fmt.Println(a)  // 函數內存地址
	//a()
	//8 函數返回值爲函數,返回的函數帶參數
	//a:=test()
	//a("xxx")

	//9 函數返回值爲函數,返回的函數帶參數,帶返回值
	//var a func(a,b int)int
	//a=test()
	//fmt.Println(a(2,3))

	//10 函數參數爲函數類型，返回值爲帶參數，帶返回值的函數類型
	//a,b:=test(func() {
	//	fmt.Println("我是函數參數")
	//})(3,4)
	//f:= func() {
	//	fmt.Println("我是函數參數")
	//}
	//
	//f1:=test(f)
	//a,b:=f1(3,4)
	//fmt.Println(a,b)

	//閉包函數的使用
	//a:=test(19)
	////a是閉包函數
	//a()

	//裝飾器是閉包函數的典型應用（go中沒有裝飾器的語法糖），經過閉包實現裝飾器

	//類型重命名
	//var a MyFunc =test()
	//c,d:=a(1,2)
	//fmt.Println(c,d)


}

1 有參數無返回值(定義函數)
func add(a int,b int)  {
	fmt.Println(a+b)
}

2 有參數無返回值,有多個相同類型參數
func add(a ,b int)  {
	fmt.Println(a+b)
}
3 有參數無返回值,有多個相同類型參數，也有不一樣類型
func add(a ,b int,msg string)  {
	fmt.Println(a+b)
	fmt.Print(msg)
}

4 多個參數，一個返回值
func add(a, b int) int {
	return a + b
}


4 多個參數，多個返回值
func add(a, b int) (int,int) {
	return a + b,a*b
}

5 命名返回值
func add(a, b int) (c int,d int) {
	c=a+b
    d=a*b
	return時，不須要再寫c,d了
	return
}


6  函數是一等公民，函數能夠賦值給變量

7 函數返回值爲函數
func test() func() {
	return func() {
		fmt.Println("我是返回函數")
	}
}

8 函數返回值爲函數,返回的函數帶參數
 類型只要有不同的地方，就不是一個類型
func test() func(msg string) {
	return func(msg string) {
		fmt.Println(msg)
	}
}

9 函數返回值爲函數,返回的函數帶參數,帶返回值
func test() func(a,b int) int{
	return func(a,b int) int {
		return a+b
	}
}

10 函數參數爲函數類型，返回值爲帶參數，帶返回值的函數類型
func test(f func()) func(a,b int) (int,int){
	return func(a,b int) (int,int) {
		f()
		return a+b,a*b

}
}

11 閉包函數：1 定義在函數內部  2對外部做用域有引用
閉包函數就是多了一種函數傳參的方法，包進去了
func test(age int) func()  {
	a:= func() {
		fmt.Println(age)
	}
    	return a
}

12
func test()MyFunc  {
	return func(a,b int)(int,string) {
		fmt.Println("xxx")
		return 10,"ok"
	}

}

8 變量做用域範圍

package main

import "fmt"

//變量的做用域範圍
var a int   // 全局變量，全局有效，只要改了，就是改了
func main() {
	var a int
	fmt.Println(a)  //0
	a=19
	fmt.Println(a) //19
	test1()  // 0
	fmt.Println(a) //19
}

func test1()  {
	fmt.Println(a)

}