数据类型用于声明函数和变量

eh

package main

import "fmt"

func main() {
	var name string = "cq"
	age := 15
	isGoodBoy := true

	// %T输出类型
	fmt.Printf("name %T \n", name)
	fmt.Printf("age %T \n", age)
	fmt.Printf("isGoodBoy %T \n", isGoodBoy)
	
	a:= 10
	p := &a // 取a的地址 指针类型
	fmt.Printf("p %T \n", p) 

	// 定义数组
	ay := [...]int{1,2,3} // 三个点代表不限制长度
	fmt.Printf("ay %T \n", ay)

	// 切片类型
	ay1 := []int {1,2,3}
	fmt.Printf("ay1 %T \n", ay1)

	// 函数类型
	fmt.Printf("%T", testFun)
}

// 函数类型
func testFun(){

}

运行结果

name string 
age int 
isGoodBoy bool 
p *int 
ay [3]int 
ay1 []int 
func()

其他类型

浮点类型

其他数字类型

布尔类型

布尔类型仅有两个常量值true 和false，常用在条件判断、循环和逻辑表达式中

package main

import "fmt"

func main() {
	var bool1 bool=true
	var bool2 bool= false
	var bool3 =true
	var bool4 =false

	bool5 :=true
	bool6 :=false

	// %v 代表任意类型的占位符
	fmt.Printf("bool1 %v \n", bool1)
	fmt.Printf("bool2 %v \n", bool2)
	fmt.Printf("bool3 %v \n", bool3)
	fmt.Printf("bool4 %v \n", bool4)
	fmt.Printf("bool5 %v \n", bool5)
	fmt.Printf("bool6 %v \n", bool6)
}

运行结果

bool1 true 
bool2 false 
bool3 true 
bool4 false 
bool5 true 
bool6 false 

在if中使用

package main

import "fmt"

func main() {
	score := 80
	pass := score >= 60

	if pass {
		fmt.Printf("成绩及格")
	}else {
		fmt.Printf("成绩不及格")
	}
}

运行结果

成绩及格

循环语句

package main

import "fmt"

func main() {
	count := 2
	for i := 0; i < count; i++ {
		fmt.Printf("第 %v 次\n", i+1)
	}
}

运行结果

第 1 次
第 2 次

应用在逻辑表达式中

package main

import "fmt"

func main() {
	age := 18
	sex := "男"
	if age >= 18 && sex == "男" {
		fmt.Printf("您可以观看")
	}
}

运行结果

您可以观看

不可以使用0和非0表示真假

package main

import "fmt"

func main() {
	i := 1
	if i {
		fmt.Printf("%v",i)
		// 编译会报错
	}
}

运行结果

# command-line-arguments
.\a09.go:7:5: non-boolean condition in if statement

数字类型

go语言除了支持整型和浮点型数字还原生支持复数，其中位的运算采用的是补码
有些类型根据结构不同占用的内存大小也不相同如：int、uint和 uintptr，在不同的操作系统下运行，这些类型的长度由操作系统类型决定

• int和unint在32位系统上都是32位(4个字节)，在64位系统上，都是64位(8个字节)
• uintptr的长度被设定位足够存放一个指针

go语言中没有float类型，只有float32和float64没有double类型

与操作系统无关的类型都有固定的大小，在类型明星中表示

整数

• int8
• int16
• int32
• int64

无符号整数

• uint8
• uint16
• uint32
• uint64

浮点型

• float32
• float64

int型是计算最快的一种类型
整型的零值为0，浮点型的零值为0.0

package main

import(
	"fmt"
	"math"
	"unsafe"
)

func main() {
	var i8 int8
	var i16 int16
	var i32 int32
	var i64 int64
	var ui8 uint8
	var ui16 uint16
	var ui32 uint32
	var ui64 uint64

	fmt.Printf("%T %dB %v~%v \n", i8,unsafe.Sizeof(i8),math.MinInt8,math.MaxInt8)
	fmt.Printf("%T %dB %v~%v \n", i16,unsafe.Sizeof(i16),math.MinInt16,math.MaxInt8)
	fmt.Printf("%T %dB %v~%v \n", i32,unsafe.Sizeof(i32),math.MinInt32,math.MaxInt8)
	fmt.Printf("%T %dB %v~%v \n", i64,unsafe.Sizeof(i64),math.MinInt64,math.MaxInt8)
	fmt.Printf("%T %dB %v~%v \n", ui8,unsafe.Sizeof(ui8),0,math.MaxUint8)
	fmt.Printf("%T %dB %v~%v \n", ui16,unsafe.Sizeof(ui16),0,math.MaxUint16)
	fmt.Printf("%T %dB %v~%v \n", ui32,unsafe.Sizeof(ui32),0,math.MaxUint32)
	fmt.Printf("%T %dB %v~%v \n", ui64,unsafe.Sizeof(ui64),0,uint64(math.MaxUint64))

	var f32 float32
	var f64 float64
	fmt.Printf("%T %dB %v~%v \n", f32,unsafe.Sizeof(f32),-math.MaxFloat32,math.MaxFloat32)
	fmt.Printf("%T %dB %v~%v \n", f64,unsafe.Sizeof(f64),-math.MaxFloat64,math.MaxFloat64)

	var ui uint
	ui = uint(math.MaxUint64) // 最大值加1会报错
	fmt.Printf("%T %dB %v~%v \n", f32,unsafe.Sizeof(ui),0,ui)

	var imax,imin int
	imax = int(math.MaxInt64) // 最大值加1会报错
	imin = int(math.MinInt64) // 最大值减1会报错
	fmt.Printf("%T %dB %v~%v \n", imax,unsafe.Sizeof(imax),imin,imax)
}

运行结果

int8 1B -128~127 
int16 2B -32768~127 
int32 4B -2147483648~127 
int64 8B -9223372036854775808~127 
uint8 1B 0~255 
uint16 2B 0~65535 
uint32 4B 0~4294967295 
uint64 8B 0~18446744073709551615 
float32 4B -3.4028234663852886e+38~3.4028234663852886e+38 
float64 8B -1.7976931348623157e+308~1.7976931348623157e+308 
float32 8B 0~18446744073709551615 
int 8B -9223372036854775808~9223372036854775807 

二进制 八进制 十六进制

package main

import "fmt"

func main() {
	// 十进制
	var a int = 10
	fmt.Printf("%d \n", a)
	fmt.Printf("%b \n", a) //%b 表示二进制

	// 八进制
	var b int = 077
	fmt.Printf("%o \n", b)

	// 十六进制
	var c int = 0xff
	fmt.Printf("%x \n", c) // ff
	fmt.Printf("%X \n", c) //FF
}

运行结果

10 
1010 
77 
ff 
FF 

浮点型

go语言支撑两种浮点型数：float32和float64，这两种类型的数据格式遵循IEEE 754标准
float32的最大范围为 3.4e38，可以使用常量定义 math.MaxFloat32
float64的最大范围为 1.8e308，可以使用常量定义 math.MaxFloat64

输出浮点数可以使用fmt的%f占位符

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Printf("%f \n", math.Pi)
	fmt.Printf("%.2f \n", math.Pi)
}

运行结果

3.141593 
3.14 

复数

complex64和complex128

package main

import "fmt"

func main() {
	var c1 complex64
	c1 = 1 +2i
	var c2 complex128
	c2 = 1 + 2i
	fmt.Printf("%v \n",c1)
	fmt.Printf("%v \n",c2)
}

运行结果

(1+2i) 
(1+2i)