注釋

給別人看的，機器并不會執行這行陳述句

1.單行注釋

// 我是單行注釋

2.多行注釋

/*
我是多行注釋
我是多行注釋
我是多行注釋
我是多行注釋
*/

// 這是一個main函式，這個是go語言啟動的入口
func main() {
   //fmt.Println ：列印一句話，然后執行完畢后，進行換行
   fmt.Println("Hello,Word")
}

變數

字面理解為變數就是會變化的量

package main

import "fmt"

func main() {
   var name string = "DuPeng"
   fmt.Println(name)
}

注意：如果在點擊這里執行會出錯

出錯提示：專案里有多個main方法

正確執行方式：滑鼠單擊右鍵執行，一定要在main方法外！ 一定要在main方法外 ！一定要在main方法外，重要事情說三遍

變數的定義

var name type

name

name 為變數，它指向的是地址，而這個地址指向記憶體空間，而記憶體空間的資料是可以更換的

var

宣告變數的關鍵字，固定的寫法，記住即可

type

代表變數的型別

定義多個變數

package main

import "fmt"
// “=” 賦值符號 將等號右邊的值賦值給等號左邊
func main() {
   var (
      //姓名
      name string
      //年齡
      age int
      //地址
      addr string
   )
    //string 默認值：空
	//int 默認值：0
   fmt.Println(name, age, addr)
}

變數的初始化

標準格式

var 變數名 型別 =值(運算式)

也可以先定義，再賦值

package main

import "fmt"

func main() {
   // “=” 賦值符號
   var (
      //姓名
      name string
      //年齡
      age int
      //地址
      addr string
   )
   name = "dupeng"
   age = 22
   addr = "成都"
   //string 默認值：空
   //int 默認值：0
   fmt.Println(name, age, addr)
}

短變數宣告并初始化

import "fmt"

func main() {
   //    :=自動推導
   name := "dupeng"
   age := 18
   fmt.Println(name, age)
   //列印輸出name和age的型別
   fmt.Printf("%T,%T", name, age)
}

列印輸出宣告型別

記憶體地址

列印記憶體地址

import "fmt"

func main() {
   var num int
   num = 100
   fmt.Printf("num：%d,記憶體地址：%p", num, &num)
}

不要忘記取地址符

值發生變換而記憶體地址不會發生改變，但每次重啟系統就會重新分配一個新的地址空間

變數交換

package main

import "fmt"

func main() {
   /*
      在其他語言中 變數的交換為下列代碼
      a=100
      b=200
      temp=0

      temp=a
      a=b
      b=temp
   */
   // 而在go語言中
   var a int = 100
   var b int = 200
   b, a = a, b
   fmt.Println(a, b)
}

匿名變數

特點是"_","_"本身就是一個特殊字符

被稱為空白識別符號，任何賦值給這個識別符號的值都會被拋棄，這樣可以加強代碼的靈活性

package main

import "fmt"

func test() (int, int) {
   return 100, 200
}

func main() {
   a, b := test()
   fmt.Println(a, b)
}

當我們不想接收第二個值時可以廢棄掉

package main

import "fmt"

func test() (int, int) {
   return 100, 200
}

func main() {
   a,_ := test()
   fmt.Println(a)
}

變數的作用域

一個變數（常量、型別或函式)在程式中都有一定的作用范圍，稱之為作用域，

區域變數

在函式體宣告的變數，只作用在函式體內

全域變數

在函式體外宣告的變數為全域變數

全域變數必須以var關鍵字開頭，如果要在外部包使用全域變數的首字母必須大寫

常量

是一個簡單值得識別符號，在程式運行時，不會被修改的量

資料型別：布爾型，數字型，（整數型、浮點型和復數型）和字串型

const

當定義完常量后，常量不允許被修改，否則會出錯

示例：

iota

特殊常量，可以認為是一個被編譯器修改的常量

iota是go語言的常量計數器 從0開始 依次遞增

直至const出現之時將被重置

package main

import "fmt"

func main() {
   const (
      a = iota //0
      b        //1
      c        //2
      d = "dd" // dd   iota=3
      e        //4
      f = 100  //100 iota=5
      g        //6
      h = iota //haha    iota=7
      i        //8
   )
   const (
      j = iota
      k
   )
   fmt.Println(a, b, c, d, e, f, g, h, i, j, k)
}
//輸出結果：0 1 2 dd dd 100 100 7 8 0 1

基本資料型別

在Go編程語言中，資料型別用于宣告函式和變數，

資料型別的出現是為了把資料分成所需記憶體大小不同的資料，編程的時候需要用大資料的時候才需要申請大記憶體，就可以充分利用記憶體，

編譯器在進行編譯的時候，就要知道每個值的型別，這樣編譯器就知道要為這個值分配多少記憶體，并且知道這段分配的記憶體表示什么，

布爾型

布爾型的值只可以是常量true或者false

布爾型別的值默認為false

package main

import "fmt"

func main() {

   // var 變數名 資料型別
   var isFlang bool
   fmt.Println(isFlang)
}
//輸出結果為：false

數字型

整形

整形int和浮點型float32、float64、Go語言支持整形和浮點型數字，并且支持負數，其中位 的運算采用補碼

package main

import "fmt"

func main() {
   //定義一個整形
    //byte uint8
	//rune int32
	//int int64
   var age int = 18
   fmt.Printf("%T,%d\n", age, age)

   //定義一個浮點型
   var money float32 = 300.15
   //這里列印浮點數型別為%f
    //默認是6位小數列印
   fmt.Printf("%T,%f\n", money, money)
}
//輸出結果：int,18
//float32,300.149994

浮點型

1、關于浮點數在機器中存放形式的簡單說明，浮點數=符號位+指數位+尾數位

2、尾數數部分可能丟失，造成精度損失，-123.0000901

型別別名

字符和字串

字串就是一串固定長度的字符連接起來的字符序列，

Go的字串是由單個位元組連接起來的，

Go語言的字串的位元組使用UTF-8編碼標識Unicode文本，

package main

import "fmt"

func main() {
	//字串 雙引號
	var str string
	str = "hello,word"
	//輸出列印的型別和值
	fmt.Printf("%T,%s\n", str, str)

	//	字符 單引號
	//字符為數值型別，需要%d列印
	//所有中國字的編碼表：GBK
	//全世界的編碼表：Unicode編碼表
	v1 := 'A'
	v2 := "B"
	v3 := '中'

	//編碼表 ASCII字符嗎
	fmt.Printf("%T,%d\n", v1, v1)
	fmt.Printf("%T,%s\n", v2, v2)
	fmt.Printf("%T,%d\n", v3, v3)

	//字串拼接
	fmt.Printf("hello" + "學相伴\n")
	//轉義字符 \
	fmt.Printf("hello\"學相伴\"\n")

	//間隔符 \t tab
	fmt.Printf("hello\"學相伴\t")

}

資料型別轉換

在必要以及可行的情況下，一個型別的值可以被轉換成另一種型別的值，

由于Go語言不存在隱式型別轉換，因此所有的型別轉換都必須顯式的宣告

package main

import "fmt"

func main() {
   a := 3   //int
   b := 4.0 //float64

   //需求：將a轉換為float64位
   c := float64(a)

   //boll 整形是不能轉換為bool的
   //cannot convert a (variable of type int) to type bool
   //e := bool(a)
   fmt.Printf("%T\n", a)
   fmt.Printf("%T\n", b)
   fmt.Printf("%T\n", c)
   //fmt.Printf("%T\n", e)
}
/*
	輸出結果為：
	int
	float64
	float64
	*/

型別轉換只能在定義正確的情況下轉換成功，例如從一個取值范圍較小的型別轉換到一個取值范圍較大的型別(將int16轉換為int32)，

當從一個取值范圍較大的型別轉換到取值范圍較小的型別時(將int32轉換為int16或將 float32轉換為 int)，會發生精度丟失（截斷）的情況，

運算子

算術運算子

下表列出了所有Go語言的算術運算子，假定A值為10，B值為20，

package main

import "fmt"

func main() {
   var a int = 10
   var b int = 3

   // + - * / % ++ --
   fmt.Println(a + b)
   fmt.Println(a - b)
   fmt.Println(a * b)
   fmt.Println(a / b)
   a++ //a=a+1
   fmt.Println(a)
   a-- //a=a-1
   fmt.Println(a)
}
/*輸出結果為：
13
7
30
3
11
10
*/

關系運算子

下表列出了所有Go語言的關系運算子，假定A值為10，B值為20，

package main

import "fmt"

func main() {
	var A int = 10
	var B int = 20
	//關系運算子，結果都是bool
	fmt.Println(A == B)
	fmt.Println(A != B)
	fmt.Println(A > B)
	fmt.Println(A < B)
	fmt.Println(A >= B)
	fmt.Println(A <= B)
/*
輸出結果：
   false
   true
   false
   true
   false
   true
*/
}

邏輯運算子

下表列出了所有Go語言的邏輯運算子，假定A值為true，B值為false，

邏輯與&&

package main

import "fmt"

func main() {
   var a bool = true
   var b bool = false

   //如果a和b同時為真
   if a && b {
      //那么我們輸出為 true
      fmt.Println(a)
   } else {
      //否則輸出為 false
      fmt.Println(b)
      // 輸出的結果為 ：false
   }
   
}

邏輯或||

遇真則真，全假則假

package main

import "fmt"

func main() {
   var a bool = true
   var b bool = false

   //當a或者b其中一個為真那么結果為真，
   if a || b {
      //那么我們輸出為 true
      fmt.Println(a)
   }
//輸出結果： true
}

邏輯非！

非也，也可以理解取反，表示否定的意思

package main

import "fmt"

func main() {
   var a bool = true
   var b bool = false

   //非b  那么！b=ture
   if !b {
      //那么我們輸出為 a，因為a=true
      fmt.Println(a)
   }
//輸出結果： true
}

位運算子（二進制）

package main

import "fmt"

func main() {

	//	二進制 逢二進一

	//位運算：二進制
	//	60  0011 1100
	//	13  0000 1101
	//----------------進行&運算
	//  12  0000 1100 我和你 同時滿足
	//----------------進行|運算
	//  61	0011 1101  我或你 一個滿足即可
	//	49	0011 0001  不同為1 相同為0

	var a uint = 60
	var b uint = 13

	//與運算結果
	fmt.Printf("%d,二進制：%b\n", a&b, a&b)

	//或運算結果
	fmt.Printf("%d,二進制：%b\n", a|b, a|b)

	//非運算結果
	fmt.Printf("%d,二進制：%b\n", a^b, a^b)

	//a向左移動兩位
	//	60  0011 1100
	// 移動之后 1111 0000
	fmt.Printf("左移動后后的十進制：%d,左移動后的二進制：%b\n", a<<2, a<<2)

	//a向右移動兩位
	//	60  0011 1100
	// 移動之后 0000 1111
	fmt.Printf("右移動后后的十進制：%d,右移動后的二進制：%b\n", a>>2, a>>2)

	/*
	   	輸出結果：
	      12,二進制：1100
	61,二進制：111101
	49,二進制：110001
	左移動后后的十進制：240,左移動后的二進制：11110000
	右移動后后的十進制：15,右移動后的二進制：1111

	*/
}

賦值運算子

下表列出了所有的Go語言的賦值運算子

package main

import "fmt"

func main() {
   var A int = 10
   var B int = 20
   var C int
   // 賦值運算子 =
   C = A + B
   fmt.Println(C) //結果為30

   //     相加后再賦值
   C += A //注意這里初始值為：C=30  C= C+A=30+10
   fmt.Println(C)
/*
輸出結果：
   30
   40

*/
}

其他運算子

拓展：鍵盤輸入輸出

package main

import "fmt"

func main() {
	var a int
	var b float32

	//定義了兩個變數，想用鍵盤來錄入這個兩個變數
	//fmt.Println() 列印并換行
	//fmt.Printf() 格式化輸出
	//fmt.Printf() 列印輸出

	fmt.Printf("請輸入兩個數：1.整數 2.浮點數\n")
	fmt.Scanln(&a, &b)
	fmt.Printf("輸出的兩個數的結果為：\n")
	fmt.Println("a:", a, "b:", b)
	
	//	fmt.Scanln（） 接受輸入scan
	//	fmt.Scanf（） 接受輸入  格式化輸入 作業
	//	fmt.Scan（） 接受輸入 作業

}

編碼規范

為什么需要代碼規范

• 代碼規范不是強制的，也就是你不遵循代碼規范寫出來的代碼運行也是完全沒有問題的
• 代碼規范目的是方便團隊形成一個統一的代碼風格，提高代碼的可讀性，規范性和統一性，本規范將從命名規范，注釋規范，代碼風格和Go語言提供的常用的工具這幾個方面做一個說明，
• 規范并不是唯一的，也就是說理論上每個公司都可以制定自己的規范，不過一般來說整體上規范差異不會很大，

代碼規范

命名規范

命名是代碼規范中很重要的一部分，統一的命名規則有利于提高的代碼的可讀性，好的命名僅僅通過命名就可以獲取到足夠多的資訊，

• 當命名(包括常量、變數、型別、函式名、結構欄位等等)以一個大寫字母開頭，如:Group1，那么使用這種形式的識別符號的物件就可以被外部包的代碼所使用(客戶端程式需要先匯入這個包)，這被稱為匯出（像面向物件語言中的public) ;
• 命名如果以小寫字母開頭，則對包外是不可見的，但是他們在整個包的內部是可見并且可用的(像面向物件語言中的private )

包名：package

保持package的名字和目錄名保持一致，盡量采取有意義的包名，簡短，有意義，盡量和標準庫不要沖突，包名應該為小寫單詞，不要使用下劃線或者混合大小寫，

package model
package main

檔案名

盡量采取有意義的檔案名，簡短，有意義，應該為小寫單詞，使用下劃線分隔各個單詞(蛇形命名)，

標籤：其他

上一篇：每日演算法題之二叉樹的深度

下一篇：04python基礎知識02