5.蛤蟆筆記go語言——基本類型

這是一個建立於 的文章，其中的資訊可能已經有所發展或是發生改變。

5.蛤蟆筆記go語言——基本類型

基本類型

Go 的基本類型有Basic types

bool

string

int int8  int16  int32 int64

uint uint8 uint16 uint32 uint64 uintptr

byte // uint8 的別名

rune // int32 的別名

    // 代表一個Unicode碼

float32 float64

complex64 complex128

同時與匯入語句一樣，變數的定義“打包”在一個文法塊中。

package main

import (

         "fmt"

         "math/cmplx"

)

var (

         ToBe   bool      = false

         MaxIntuint64     = 1<<64 - 1

         z      complex128 = cmplx.Sqrt(-5 + 12i)

)

func main() {

         const f= "%T(%v)\n"

         fmt.Printf(f,ToBe, ToBe)

         fmt.Printf(f,MaxInt, MaxInt)

         fmt.Printf(f,z, z)

}

執行如下：

         bool(false)

         uint64(18446744073709551615)

         complex128((2+3i))

零值

變數在定義時沒有明確的初始化時會賦值為_零值_。

零值是：

數實值型別為 `0`，

布爾類型為 `false`，

字串為 `""`（Null 字元串）。

package main

import "fmt"

func main() {

         var iint

         var ffloat64

         var bbool

         var sstring

         fmt.Printf("%v%v %v %q\n", i, f, b, s)

}

執行：

0 0 false ""

類型轉換

運算式 T(v) 將值 v 轉換為類型 `T`。

一些關於數值的轉換：

var i int = 42

var f float64 = float64(i)

var u uint = uint(f)

或者，更加簡單的形式：

i := 42

f := float64(i)

u := uint(f)

與 C 不同的是 Go 的在不同類型之間的項目賦值時需要顯式轉換。試著移除例子中 float64 或 int 的轉換看看會發生什麼。

package main

import (

         "fmt"

         "math"

)

func main() {

         var x,y int = 3, 4

         var ffloat64 = math.Sqrt(float64(x*x + y*y))

         var zint = int(f)

         fmt.Println(x,y, z)

}

執行：

         34 5

類型推導

在定義一個變數但不指定其類型時（使用沒有類型的 var 或 := 語句），變數的類型由右值推導得出。

當右值定義了類型時，新變數的類型與其相同：

var i int

j := i // j 也是一個 int

但是當右邊包含了未指名類型的數字常量時，新的變數就可能是 int 、 float64 或 `complex128`。這取決於常量的精度：

i := 42           // int

f := 3.142        // float64

g := 0.867 + 0.5i // complex128

嘗試修改示範代碼中 v 的初始值，並觀察這是如何影響其類型的。

package main

import "fmt"

func main() {

         v := 42// change me!

         fmt.Printf("vis of type %T\n", v)

}

執行：

         vis of type int

常量

常量的定義與變數類似，只不過使用 const 關鍵字。

常量可以是字元、字串、布爾或數字類型的值。

常量不能使用 := 文法定義。

package main

import "fmt"

const Pi = 3.14

func main() {

         constWorld = "世界"

         fmt.Println("Hello",World)

         fmt.Println("Happy",Pi, "Day")

         constTruth = true

         fmt.Println("Gorules?", Truth)

}

執行：

         Hello世界

         Happy3.14 Day

         Gorules? true

數值常量

數值常量是高精度的 _值_。

一個未指定類型的常量由上下文來決定其類型。

也嘗試一下輸出 needInt(Big) 吧。

package main

import "fmt"

const (

         Big   = 1 << 100

         Small =Big >> 99

)

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

func needFloat(x float64) float64 {

         returnx * 0.1

}

func main() {

         fmt.Println(needInt(Small))

         fmt.Println(needFloat(Small))

         fmt.Println(needFloat(Big))

}

執行輸出：

21

         0.2

         1.2676506002282295e+29