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`，

字符串为 `""`（空字符串）。

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

 

 

---