1、通脉标识符与关头字

在体味数据圭表类型之前，据圭先体味一下go的表类标识符和关头字

1.1 标识符

在编程言语中标识符就是定义的具有某种意义的词，比如变量名 、型概常量名 、通脉函数名等等。据圭 Go言语中标识符准予由字母数字和_(下划线）构成 ，表类并且只能以字母和_开首：abc ,型概 _ , _123, a123
。

1.2 关头字

关头字是通脉指言语过后定义好的具有出格含义的标识符。 关头字和保管字都不建议用作变量名。据圭

Go言语有25个关头字：

break        default      func         inte***ce    select    case         defer        go           map          struct    chan         else         goto         package      switch    const        fallthrough  if           range        type    continue     for          import       return       var

Go言语中有37个保管字

Constants:    true  false  iota  nil         Types:    int  int8  int16  int32  int64                    uint  uint8  uint16  uint32  uint64  uintptr                  float32  float64  complex128  complex64                  bool  byte  rune  string  error     Functions:   make  len  cap  new  append  copy  close  delete                 complex  real  imag                 panic  recover

2、表类变量

2.1 甚么是型概变量

法度圭表类型运转过程中的数据都是保管在内存中
，想要在代码中独霸某个数据时就需求往内存上找到这个变量，通脉可是据圭假定直接在代码中经由过程内存地址往独霸变量的话
，代码的表类可读性会特别很是差并且还随便犯错
，所以就独霸变量将这个数据的内存地址保管起来
，往后直接经由过程这个变量就可以找到内存上对应的数据了 。

所以变量的本质就是一小块内存 ，用于存储数据，在法度圭表类型运转过程中数值可以改削

变量是为存储特定圭表类型的值而供给给内存职位的称号。在go中声明变量有多种语法
。

2.2 变量圭表类型

变量（Variable）的下场是存储数据。不合的变量保管的数据圭表类型大年夜大年夜约会不一样。罕有变量的数据圭表类型有：整型、浮点型 、布尔型等 。

Go言语中的每个变量都有本身的圭表类型，并且变量必须经由声明才调最早独霸。

2.3 变量声明

Go言语中的变量需求声明后才调独霸，不合感染域内不支撑几反响明。 并且Go言语的变量声明后必须独霸，不然没法经由过程编译。

标准声明
：

Go言语的变量声明格式为：

var 变量名 变量圭表类型

变量声明以关头字var开首 ，变量圭表类型放在变量的后背 ，行尾无需分号
：

var name stringvar age intvar isTrue bool

批量声明：

每声明一个变量就需求写var关头字会斗劲繁琐 ，go言语中还支撑批量变量声明
：

var (    a string    b int    c bool    d float32)

变量的初始化：

Go言语在声明变量的时辰，会主动对变量对应的内存区域举办初始化独霸。每个变量会被初始化成其圭表类型的默许值
，即零值
 ，比如 ： 整型和浮点型变量的默许值为0。 字符串变量的默许值为空字符串。 布尔型变量默许为false 。 切片、函数  、指针变量的默许为nil 。

当然也可在声明变量的时辰为其指定初始值。变量初始化的标准格式以下
：

var 变量名 圭表类型 = 表达式var name string = "golang"var age int = 18

或一次初始化多个变量

var name, age = "golang", 20

圭表类型推导 ：

有时光会将变量的圭表类型省略，这个时辰编译器会屈就等号右边的值来推导变量的圭表类型完成初始化 。

var name = "golang"var age = 18

短变量声明 ：

在函数内部 ，可独霸更复杂的 := 编制声明并初始化变量 。

// 全局变量mvar m = 100 func main() {  n := 10 m := 200 // 此处声明部分变量m fmt.Println(m, n)}

匿名变量：

在独霸多重赋值时，假定想要忽视某个值，可独霸匿名变量（anonymous variable）
。 匿名变量用一个下划线_展示 ，比如
：

func foo() (int, string) {  return 10, "golang"}func main() {  x, _ := foo() _, y := foo() fmt.Println("x=", x) fmt.Println("y=", y)}

匿名变量不占用定名空间 ，不会分拨内存，所以匿名变量之间不存在几反响明
。

寄看事项 ：

• 函数外的每个语句都必须以关头字最早（var、const、func等）
• :=不克不及独霸在函数外，不克不及定义全局变量，并且右边的变量名起码有一个是新的。
• _多用于占位，展示忽视值 。
• 变量必须先定义才调独霸 ，定义了就必定要独霸。
• 变量的圭表类型和赋值的圭表类型必须齐截。
• 变量名在不合个感染于域内不克不及冲突。

3、常量

绝对变量，常量是恒定晃荡的值 ，多用于定义法度圭表类型运转时代不会改削的那些值
。 常量的声明和变量声明特别很是近似 ，只是把var换成了const，常量在定义的时辰必须赋值。

const pi = 3.1415const e = 2.7182

声了然pi和e这两个常量此后 ，在全数法度圭表类型运转时代它们的值都不克不及再产生发火改削了。

多个常量也可以一同声明：

const (    pi = 3.1415    e = 2.7182)

const同时声明多个常量时 
，假定省略了值则展示和上面一行的值不异
。 比如：

const (    n1 = 100    n2    n3)

上面示例中 ，常量n1、n2 、n3的值都是100 。

常量可以作为列举 ，常量组

const (    Unknown = 0    Female = 1    Male = 2)

常量组中如不指定圭表类型和初始化值 ，则与上一行非空常量右值不异

func main() {  const (  x uint16 = 16  y  s = "abc"  z ) fmt.Printf("%T,%v\n", y, y) //uint16,16 fmt.Printf("%T,%v\n", z, z) //string,abc}

常量的寄看事项：

• 常量中的数据圭表类型只可所以布尔型、数字型（整数型、浮点型和双数）和字符串型
• 不曾独霸的常量，在编译的时辰，是不会报错的
• 展示指定圭表类型的时辰，必须确保常量放置值圭表类型齐截，需求时可做显示类型转换。这与变量就不一样了，变量是可所以不合的圭表类型值

3.1 iota

iota是go言语的常量计数器，是出格的常量 ，只能在常量的表达式中独霸 。

iota在const关头字展示时将被重置为0。const中每新增一行常量声明将使iota计数一次(iota可邃晓为const语句块中的行索引)
。 独霸iota能简化定义 ，在定义列举时很有效。

const (  n1 = iota //0  n2        //1  n3        //2  n4        //3 )

几个罕有的iota示例:

独霸_跳过某些值

const (  n1 = iota //0  n2        //1  _  n4        //3 )

iota声明中心插队

const (  n1 = iota //0  n2 = 100  //100  n3 = iota //2  n4        //3 ) const n5 = iota //0

定义数量级 （这里的<<展示左移独霸，1<<10展示将1的二进制展示向左移10位，也就是由1变成了10000000000
，也就是十进制的1024
。同理2<<2展示将2的二进制展示向左移2位 ，也就是由10变成了1000 ，也就是十进制的8。）

const (  _  = iota  KB = 1 << (10 * iota)  MB = 1 << (10 * iota)  GB = 1 << (10 * iota)  TB = 1 << (10 * iota)  PB = 1 << (10 * iota) )

多个iota定义在一行

const (  a, b = iota + 1, iota + 2 //iota = 0、a = 1, b = 2  c, d                      //iota = 1
、c = 2, d = 3  e, f                      //iota = 2
、e = 3, f = 4 )

Go言语中有丰富的数据圭表类型 ，除根本的整型 、浮点型、布尔型、字符串外，还罕有组、切片、筹划体 、函数 、map 、通道（channel）等。

4
、根本数据圭表类型

4.1 整型

整型分为以下两个除夜类： 按长度分为：int8、int16 、int32、int64 对应的无标识表记标帜整型：uint8 、uint16 、uint32
、uint64

个中 ，uint8就是byte型，int16对应C言语中的short型
，int64对应C言语中的long型
。

寄看：在独霸int和 uint圭表类型时
，不克不及假定它是32位或64位的整型 ，而是思虑int和uint大年夜大年夜约在不合平台上的不合
。除非需求独霸特定大年夜小的整数，不然但凡理应独霸int来展示整数。 大年夜小:32位琐细32位 ，64位琐细64位 。 局限:-2147483648到2147483647的32位琐细和-9223372036854775808到9223372036854775807的64位琐细 。

寄看事项 掉落踪掉落踪对象的长度的内建len()函数前去的长度可以屈就不合平台的字节长度举办改削。理论独霸中
，切片或 map 的元素数量等都可以用int来展示
。在触及到二进制传输、读写文件的筹划描摹时 ，为了贯穿连接文件的筹划不会遭到不合编译方针平台字节长度的影响  ，不要独霸int和 uint
 。

数字字面量语法（Number literals syntax）

Go1.13版本此后引进了数字字面量语法，多么便于斥地者以二进制、八进制或十六进制浮点数的格式定义数字，比如：

v := 0b00101101
， 代表二进制的 101101，相当于十进制的 45 。 v := 0o377
，代表八进制的 377，相当于十进制的 255。 v := 0x1p-2
，代表十六进制的 1 除以 2²，也就是 0.25
。

并且还准予用 _ 来离开数字
，比如说
： v := 123_456 展示 v 的值等于 123456。

将一个整数以不合进制编制展示
 ：

func main(){  // 十进制 var a int = 10 fmt.Printf("%d \n", a)  // 10 fmt.Printf("%b \n", a)  // 1010  占位符%b展示二进制  // 八进制  以0开首 var b int = 077 fmt.Printf("%o \n", b)  // 77  // 十六进制  以0x开首 var c int = 0xff fmt.Printf("%x \n", c)  // ff fmt.Printf("%X \n", c)  // FF}

4.2 浮点型

Go言语支撑两种浮点型数 ：float32和float64
。这两种浮点型数据格式屈就IEEE 754标准 ： float32 的浮点数的最除夜局限约为 3.4e38，可独霸常量定义：math.MaxFloat32 。 float64 的浮点数的最除夜局限约为 1.8e308
，可独霸一个常量定义：math.MaxFloat64。

打印浮点数时 ，可独霸fmt包合营动词%f
：

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

4.3 双数

complex64和complex128

var c1 complex64c1 = 1 + 2ivar c2 complex128c2 = 2 + 3ifmt.Println(c1)fmt.Println(c2)

双数有实部和虚部
，complex64的实部和虚部为32位 ，complex128的实部和虚部为64位
。

4.4 布尔值

Go言语中以bool圭表类型举办声明布尔型数据，布尔型数据只需true（真）和false（假）两个值 。

寄看：

• 布尔圭表类型变量的默许值为false 。
• 禁尽予将整型强逼转换为布尔型.
• 布尔型没法介入数值运算 ，也没法与其他圭表类型举办转换。

4.5 字符串

Go言语中的字符串以原生数据圭表类型展示，独霸字符串就像独霸其他原生数据圭表类型（int、bool、float32、float64 等）一样 。字符串的内部完成独霸UTF-8编码。 字符串的值为双引号(")中的内容，可以在源码中直接添加非ASCII码字符：

s1 := "hello"s2 := "你好"

字符串本义符 ：

Go 言语的字符串罕有本义符包含回车、换行、单双引号 、制表符等 ，以下表所示
。

func main() {     fmt.Println("str := \"d:\\go\\go.exe\"")}

多行字符串：

定义一个多行字符串时 ，就必须独霸反引号字符：

s1 := `第一行第二行第三行`fmt.Println(s1)

反引号间换即将被作为字符串中的换行 ，可是全数的本义字符均有效，文本将会原样输进。

字符串的经常独霸独霸：

4.6 byte和rune圭表类型

构成每个字符串的元素叫做“字符”，可以经由过程遍历或单个掉落踪掉落踪字符串元素掉落踪掉落踪字符 。 字符用单引号（'）包裹起来，如：

var a := '中'var b := 'x'

Go 言语的字符有以下两种 ：

• uint8圭表类型，或叫 byte 型，代表了ASCII码的一个字符
  。
• rune圭表类型，代表一个 UTF-8字符。
  

当需求措置中文、日文或其他复合字符时，则需求用到rune圭表类型。rune圭表类型理论是一个int32 。

Go 独霸了出格的 rune 圭表类型来措置 Unicode，让基于 Unicode 的文本措置愈加利便 ，也可独霸 byte 型举办默许字符串措置，功用和扩大年夜大年夜大年夜大年夜性都有赐顾帮衬。

因为UTF8编码下一个中文汉字由3~4个字节构成，所以不克不及复杂的屈就字节往遍历一个包含中文的字符串

字符串底层是一个byte数组
 ，所以可以和[]byte圭表类型彼此转换 。字符串是不克不及改削的 字符串是由byte字节构成，所以字符串的长度是byte字节的长度。 rune圭表类型用来展示utf8字符，一个rune字符由一个或多个byte构成 。

改削字符串 ：

要改削字符串，需求先将其转换成[]rune或[]byte，完成后再转换为string
。非论哪一种转换 ，都邑从头分拨内存 ，并复制字节数组。

func changeString() {  s1 := "big" // 强逼圭表类型转换 byteS1 := []byte(s1) byteS1[0] = 'p' fmt.Println(string(byteS1))  s2 := "白萝卜" runeS2 := []rune(s2) runeS2[0] = '红' fmt.Println(string(runeS2))}

4.7 圭表类型转换

Go言语中只需强逼圭表类型转换，没有隐式圭表类型转换。该语法只能在两个圭表类型之间支撑彼此转换的时辰独霸 。

强逼圭表类型转换的根本语法以下 ：

T(表达式)

个中，T展示要转换的圭表类型 。表达式包含变量
、宏壮算子和函数前去值等.

func sqrtDemo() {  var a, b = 3, 4 var c int // math.Sqrt()领受的参数是float64圭表类型	，需求强逼转换 c = int(math.Sqrt(float64(a*a + b*b))) fmt.Println(c)}

运算符用于在法度圭表类型运转时奉行数学或逻辑运算。

5、运算符

Go 言语内置的运算符有：

• 算术运算符
• 相干运算符
• 逻辑运算符
• 位运算符
• 赋值运算符

5.1 算数运算符

寄看  ：++ （自增）和--（自减）在Go言语中是孤单的语句，真实不是运算符 
。

5.2 相干运算符

5.3 逻辑运算符

5.4 位运算符

位运算符对整数在内存中的二进制位举办独霸。

5.5 赋值运算符

5.6 运算符优先级

有些运算符具有较高的优先级，二元运算符的运算标的方针均是从左至右。由上至下代表优先级由高到低
：

当然 ，可以经由过程独霸括号到且则汲引某个表达式的集团运算优先级。

到此这篇关于Golang通脉之数据圭表类型概略的文章就引见到这了,更多相干Go言语 数据圭表类型内容请搜刮完竣下载之前的文章或延续不雅不雅不雅不雅鉴赏上面的相干文章希看大年夜师往后多多支撑完竣下载
！