go var 一个整数_Golang之常量与基本数据类型

1.1 Go常量

常量代表只读的， 不可修改的值，用 const 关键字定义

常量和变量一样，可以批量声明，或者一组相关的常量。

常量的计算都是在编译期间完成的， 并非运行期间！从而减少运行时的工作。

未使用的常量不会应发编译错误。(这点和变量不一样)

package main

import (

"fmt"

"unsafe"

)

// 常量定义且赋值

const World string = "世界"

// 多常量初始化

const x,y int = 1,2

// 常量类型推断，字符串类型

const s1 = "Hello world"

// 常量组

const (

e = 2.7182818284590452353

pi = 3.14159

b bool = true

)

// 1. 常量组，可以除了第一个外其他的常量右边的初始化表达式可省略

// 2. 如果省略初始化表达式，默认使用前面常量的表达式

// 3. 遇上一个常量相同

const (

c1 =1

c2

c3

c4='c4444'

c5

)

/*

1

1

1

c4444

c4444

*/

// 常量也可以定义函数的返回值

const(

f1="abc" // 长度为3的字符串的类型

f2 = len(f1) // 返回长度的函数结果

f3 = unsafe.Sizeof(f2) // 返回f2所占用的内存大小

)

/*

输出结果：

abc

3

8

*/

func main(){

fmt.Println(f1)

fmt.Println(f2)

fmt.Println(f3)

}

1.2 Go常量之iota常量生成器

iota 用于生成一组相似规则的初始化的常量，在const常量声明的语句中，第一个常量所在行，iota 值为0，之后每一个常量声明加一。

例如time 包的例子，一周七天，每天可以定义为常量，1-6，周日为0，这种类型也称为 枚举。

package main

import (

"fmt"

)

const(

Sunday = iota

Monday // 通常省略后续行表达式

Tuesday

Wednesday

Thursday

Friday

Saturday

)

func main(){

fmt.Println(Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday)

}

注：如果iota 表达式被打断，需要显示恢复

package main

import (

"fmt"

)

const (

A= iota // 初始化0

B // +1

C = "c"

D // c,与上面相同

E = iota //4 ,显式恢复。注意计数包含了C、D 两个，此时为4

F // 5 恢复iota +1

)

func main() {

fmt.Println(A, B, C, D, E, F)

}

// 输出结果

// 0 1 c c 4 5

1.3 Go 整数类型

Go语言的数值类型包含不同大小的整数类型、浮点数和负数，美中数值类型都有大小范围以及正负符号。

package main

imprort "fmt"

func mainz(){

var n1 = 100

fmt.Printf("n1的类型: %T \n",n1)

}

输出结果

n1 的类型：int

1、查看变量的字节大小，和数据类型

package main

import (

"fmt"

"unsafe"

)

func main(){

var n2 int64 = 100

// unsafe 包地下的Sizeof函数， 返回变量占用字节数

fmt.Printf("n2的类型是：%T，占用的字节数是%d"，n2，unsafe.Sizeof(n2))

}

输出结果

n2的类型是 int64， 占用的字节数是8

1.4 数字类型

序号

类型和描述

1

uint8 无符号 8 位整型 (0 到 255)

2

uint16 无符号 16 位整型 (0 到 65535)

3

uint32 无符号 32 位整型 (0 到 4294967295)

4

uint64 无符号 64 位整型 (0 到 18446744073709551615)

5

int8 有符号 8 位整型 (-128 到 127)

6

int16 有符号 16 位整型 (-32768 到 32767)

7

int32 有符号 32 位整型 (-2147483648 到 2147483647)

8

int64 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)

1.5 Go浮点型

Go语言提供两种精度的浮点数，float32和 float64 ,编译器默认声明为float64

小数类型就存放小数的， 如 1.2,0.005,-2.32

package main

import "fmt"

func main(){

var price float32 = 100.02

fmt.Printf("price 类型是：%T，值是%v"，price,price) // %T 是类型， %v 是默认值

}

类型

占用存储空间

表述范围

单精度float32

4 字节

-3.403E38 ~ 3.403E38

双精度float64

8字节

-1.798E308~1.798E308

浮点数的形式 : 浮点数 = 符号位 + 指数位 + 位数位

package main

import "fmt"

func main(){

var price float32 = 11.22 // 正数符号

fmt.Println("price=",price)

var num1 float32 = -3.4 // 负数符号

var num2 float64 = -8.23

fmt.Println("num1=",num1,"num2=",num2)

// 尾数可能丢失，精度缺失

var num3 float32 = -123.11111111105//精度丢失了

var num4 float64 = -123.11111111105//float64的精度高于float32

fmt.Println("num3=", num3, "num4=", num4)

// 输出结果

// num3= -123.111115 num4= -123.11111111105

}

1.6 Go字符类型

Golang 中没有专门的 字符 类型，如果要存储单个 字符(字母)，一般使用 byte 来保存。

普通字符串就是一串固定长度的字符连接起来的字符序列

Go的 字符串 是由 单个 字节 连接起来的。

也就是说对于传统的 字符串 是由 字符组成的，而Go的字符串不同，它是由字节组成的。

Go的字符用的 单引号 表示

Go的字符串用 双引号 表示

package main

import "fmt"

func main(){

var c1 byte = 'a'

var c2 byte = '2' // 字符的2

// 直接输出byte的值，也就是输出对应的字符的码值

fmt.Println("c1=",c1)

fmt.Println("c2=",c2)

// 输出字符的值，需要格式化输出

fmt.Printf("c1值%c c2值=%c\n",c1,c2)

}

/*

输出结果：

c1= 97

c2= 50

c1值a c2值=2

*/

Go 变量保存的byte对应值ASCII表，范围在 [0-1,a-z,A-Z]

如果保存的饿字符对应码大于255，应该使用int而不是byte,否则 overflows byte 异常

var c3 int = '皮' // 正确

var c4 byte = '皮' // overflows byte 报错

Go语言默认字符编码UTF-8，统一规定

Go字符的本质是一个整数，直接打印是UTF-8编码的值

给与变量赋值整数，按 %c格式化输出得到的是unicode字符

var c4 int = 22269

fmt.Printf("c4=%c\n",c4)

// 输出的结果是c4=国

Go语言允许使用转义符号""

Go语言字符类型允许计算，相当于整数运算，因为字符拥有对应的Unicode码

1.7 Go布尔值

一个布尔冷的值只有两种：true 和 false

if和for 语句的条件部分都是布尔类型的值，并且 == 和 < 等比较操作也会产生布尔类型的值。

package main

import (

"fmt"

"unsafe"

)

func main(){

var b = true

fmt.Println("b=",b)

fmt.Println("b字节数=", unsafe.Sizeof(b))

}

// 输出结果：

// b= true

// b字节数=1