注釋

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

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
*/
}

標籤：其他

上一篇：SpringCloudAlibaba 微服務組件 Nacos 之配置中心原始碼深度決議

下一篇：dubbo 筆記