Go笔记(一)：基本数据类型

前言

　　Go官方编程指南：https://golang.google.cn/doc/tutorial/

            

　　选择中文阅读go的官方文档。

           

　　查看官方提供的go的包的函数使用，即API(application program interface)应用程序接口，就是go的各个包的各个函数：https://golang.google.cn/doc/tutorial/getting-started

            

一、常量

1、语法格式

　　常量，编译阶段已经确定了值，程序在运行时无法改变常量的值。定义一个常量使用const关键字，语法格式如下：

const constantName [type] = value

　　const: 定义常量关键字；

　　constantName: 常量名称；

　　type: 常量类型；

　　value: 常量的值

2、示例代码

package main

import "fmt"

/**
   声明单个变量：指定类型、类型推导
 */
func defineSingleConst() {
   // 指定类型
   const CONST01 int8 = 1
   fmt.Printf("指定类型：CONST01: %v\n", CONST01)

   // 类型推导
   const CONST02 = 3.1415926
   fmt.Printf("类型推导：CONST02: %v\n", CONST02)
}

/**
   const同时声明多个变量，如果省略了值则表示和上面一行的值相同。
 */
func defineMultiConst() {
   // 批量声明常量
   const (
      W = 10
      H = 20
   )
   fmt.Printf("定义多常量：W: %v, H: %v\n", W, H)

   // 省略了值则表示和上面一行的值相同。
   const (
      PRICE01 = 20.00
      PRICE02 = 30.00
      //PRICE02
      PRICE03
   )
   fmt.Printf("PRICE01: %v, PRICE02: %v, PRICE03: %v\n", PRICE01, PRICE02, PRICE03)
}

/**
   iota关键字，可被编译器修改的常量，默认值为0
      每次调用常量值加1
      遇到const关键字，会被重置为0
 */
func iotaKeys() {
   // 默认值为0，每次调用加 1
   const (
      x = iota
      y = iota
      z = iota
   )
   fmt.Printf("x: %v, y: %v, z: %v\n", x, y, z)
   fmt.Println("=================================================")

   // 遇到const关键字，会被重置为0
   // 使用 '_' 跳过某些值
   const (
      a = iota
      _
      c = iota
   )
   fmt.Printf("a: %v, c: %v\n", a, c)
   fmt.Println("=================================================")

   // iota 声明使用中间插队的场景
   const (
      q = iota
      w = 200
      s = iota
   )
   fmt.Printf("q: %v, w: %v, s: %v\n", q, w, s)
}


func main() {
   defineSingleConst()
   defineMultiConst()
   iotaKeys()
}

二、变量

1、语法格式

　　变量：内存中的一块存储区域，该区域中存储 变量名 、数据类型、变量值。定义一个变量使用 var 关键字。声明变量语法结构如下：

var varName [type]

　　var: 定义变量关键字；

　　varName: 变量名称；

　　type: 变量类型

2、示例代码

package main

import "fmt"

// ===== 全局变量的声明 =====
// 方式一
var var10 = 10
var var11 = 6.8
var var12 = "jack"
// 方式二
var (
   var20 = 80
   var21 = 5.20
   var22 = "tom"
)

// ===== 局部变量的声明 =====
/**
   声明单个变量
 */
func defineSingleLocalVar() {
   // ===== 指定类型 =====
   // 声明变量
   var var01 int
   // 变量赋值
   var01 = 3
   // 使用变量
   fmt.Println("声明单变量 -> var01 = ", var01)

   // ===== 类型推导：根据值自行判断数据类型 =====
   var02 := 3.1415926
   fmt.Println("声明单变量 -> var02 = ", var02)

   // 变量不赋值，使用默认值
   var y int
   fmt.Println("声明单变量 -> y = ", y)

   // 变量在同一作用域(在一个函数或者代码)内不能重名
   //var var10 int = 3

   // var 与 := 不能一起使用
   //var x := 3
   //fmt.Println("声明单变量 -> x = ", x)

}

/**
   声明多个变量
 */
func defineMultiLocalVar() {
   // 指定类型
   var var01, var02 int
   var01 = 4
   var02 = 5
   fmt.Printf("多局部变量声明方式一 -> var03 = %v, var03 = %v\n", var01, var02)

   // 类型推导
   var var03, var04, var05 = 4, "tom", 4.5
   fmt.Println("多局部变量声明方式二 -> var03 = ", var03, ",var04 = ", var04, ",var05 = ", var05)

   // 方式三：类型推导
   var06, var07, var08 := 6, "tuoni", 7.8
   fmt.Println("多局部变量声明方式三 -> var06 = ", var06, ",var07 = ", var07, ",var08 = ", var08)
}

/**
   变量
 */
func main() {
   fmt.Println("全局变量声明方式一 -> var10 = ", var10, ",var11 = ", var11, ",var12 = ", var12)

   fmt.Println("全局变量声明方式二 -> var20 = ", var20, ",var21 = ", var21, ",var22 = ", var22)

   defineSingleLocalVar()
   defineMultiLocalVar()
}

3、变量使用注意事项

　　1、声明的变量不赋值，变量使用默认值；

　　2、变量在同一作用域(在一个函数或者代码)内不能重名

　　3、关键字 var 与 := 不能一起使用

三、数据类型

　　Go中的数据类型整体分为两大类型：基本数据类型、复杂数据类型。详情如下：

    

　　先介绍Go中的基本数据类型，复杂数据类型后面再做详细描述。

1、整型

　　整型，也被称为整数型。分为有符号整数、无符号整数。有符号整数：int8 [-2^7, (2^7) - 1]、int16、int32、int64。无符号整数：uint8[0, 2^7 - 1]、uint16、uint32、uint64。

　　Go语言中，不指定整型类型，默认为int类型，默认值为0，占8字节。验证代码如下：

package main

import (
   "fmt"
   "unsafe"
)
/**
   变量占用字节的大小和数据类型
 */
func main() {

   // 整型默认为int型，占8个字节
   n := 10
   fmt.Printf("n 的类型 %T ，n占用的字节数是 %d \n", n, unsafe.Sizeof(n))
   
   // 默认值为 0 
   var int01 int
   fmt.Printf("int01 = %v \n", int01)
   
   // 占1字节
   var n1 int8 = 10
   fmt.Printf("n1 的类型 %T ，n1占用的字节数是 %d \n", n1, unsafe.Sizeof(n1))

   // 占2字节
   var n2 int16 = 10
   fmt.Printf("n2 的类型 %T ，n2占用的字节数是 %d \n", n2, unsafe.Sizeof(n2))

   // 占4字节
   var n3 int32 = 10
   fmt.Printf("n3 的类型 %T ，n3占用的字节数是 %d \n", n3, unsafe.Sizeof(n3))

   // 占8字节
   var n4 int64 = 10
   fmt.Printf("n4 的类型 %T ，n4占用的字节数是 %d \n", n4, unsafe.Sizeof(n4))

   // 占1字节
   var m1 uint8 = 10
   fmt.Printf("m1 的类型 %T ，m1占用的字节数是 %d \n", m1, unsafe.Sizeof(m1))

   // 占2字节
   var m2 uint16 = 10
   fmt.Printf("m2 的类型 %T ，m2占用的字节数是 %d \n", m2, unsafe.Sizeof(m2))

   // 占4字节
   var m3 uint32 = 10
   fmt.Printf("m3 的类型 %T ，m3占用的字节数是 %d \n", m3, unsafe.Sizeof(m3))

   // 占8字节
   var m4 uint64 = 10
   fmt.Printf("m4 的类型 %T ，m4占用的字节数是 %d \n", m4, unsafe.Sizeof(m4))
}

2、浮点型

　　浮点型：单精度 - float32、双精度 - float64。验证代码如下：

package main

import (
   "fmt"
   "unsafe"
)

/**
   浮点型
 */
func main() {
   // 浮点型默认为float型，8个字节
   float := 3.14159
   fmt.Printf("float 的类型 %T ，float占用的字节数是 %d \n", float, unsafe.Sizeof(float))
   
   // 4字节
   var float01 float32 = 3.14159
   fmt.Printf("float01 的类型 %T ，float01占用的字节数是 %d \n", float01, unsafe.Sizeof(float01))
   
   // 8字节
   var float02 float64 = 3.14159
   fmt.Printf("float02 的类型 %T ，float02占用的字节数是 %d \n", float02, unsafe.Sizeof(float02))

   // 默认值为 0.000000
   var float04 float64
   fmt.Printf("float04 = %f \n", float04)
}

　　Go语言中不指定浮点型类型，默认为float64类型，默认值为0.000000，占8个字节，float64位精度比float32精度的要准确。

3、布尔型

　　布尔型只有两个值：true 和 false。布尔型的默认值为false，占1个字节。常用在条件控制语句、逻辑表达式中。验证代码如下：

package main

import (
   "fmt"
   "unsafe"
)

/**
   布尔数据类型
 */
func main() {
   // 默认值为false
   var bool01 bool
   fmt.Printf("bool01: %v \n", bool01)

   // 占 1 字节
   bool02 := false
   fmt.Printf("bool02: %v %T %d\n", bool02, bool02, unsafe.Sizeof(bool02))

   // 条件控制语句、逻辑表达式
   count := 10
   r := count >= 18
   if r {
      fmt.Println("===== 已成年 =====")
   }else {
      fmt.Println("===== 未成年 =====")
   }

   // 循环语句
   for i := 0; i < count; i++ {
      if i == count - 1 {
         fmt.Printf("i = %v \n", i)
      }else {
         fmt.Printf("i = %v ", i)
      }
   }
}

4、byte类型

　　Go语言中，byte默认值为0，占用1个字节。byte与uint8等价，当要存储字符时，建议选用byte。验证代码如下：

package main

import (
   "fmt"
   "unsafe"
)

func main() {
   // byte 默认值是 0 , 占用1个字节
   var b byte
   fmt.Printf("b 默认值 %v ，b占用的字节数是 %d \n", b, unsafe.Sizeof(b))

   // byte 类型不可以用类型推导，默认int类型
   b01 := 1
   fmt.Printf("b01 默认值 %T ，b01占用的字节数是 %d \n", b01, unsafe.Sizeof(b01))

   // 两个byte相加，类型变为uint8，可得出结论byte与uint8等价，当要存储字符时，建议byte
   var b02 byte
   b02 = 3
   var b03 byte
   b03 = b + b02
   fmt.Printf("b03 默认值 %T ，b03占用的字节数是 %d \n", b03, unsafe.Sizeof(b03))

}

5、字符串类型

　　Go语言中，string类型默认值为 空字符串，占16个字节，可通过双引号、反引号来创建字符串。注意：反引号不支持转义字符。验证代码如下：

package main

import (
   "bytes"
   "fmt"
   "strings"
   "unsafe"
)

// 字符串拼接
func stringBond() {
   var str string = "hello "
   var str1 = "world!"
   // 拼接方式一 ： +
   fmt.Println("content: ", str+str1)

   // 拼接方式二：Sprintf
   content1 := fmt.Sprintf("%s%s", str, str1)
   fmt.Printf("content1: %v\n", content1)

   // 拼接方式三 ： 数组 + join函数
   content2 := strings.Join([]string{str, str1}, " ")
   fmt.Printf("content2: %v\n", content2)

   // 拼接方式四： buf.WriteString
   var buf bytes.Buffer
   buf.WriteString("hello")
   buf.WriteString(" ")
   buf.WriteString("world！")
   fmt.Printf("buf: %v\n", buf.String())
}

// 字符串截取
func stringCutout() {
   str := "yfghchafydsaduaigdaiugkauekagdjasdyadiadhjaf"
   start := 6
   end := 14

   // 获取字符串索引位置为start的原始字节
   fmt.Println(str[start])
   // 获取字符串索引位置从 start 到 end - 1 的字符串
   fmt.Println(str[start:end])
   // 获取字符串索引位置从 start 到 len(s) - 1 的字符串
   fmt.Println(str[start:])
   // 获取字符串索引位置从 0 到 end - 1 的字符串
   fmt.Println(str[:end])
}

// 热点方法
func hotMethod() {
   str := "hello world"
   // 字符串长度
   fmt.Printf("len(str): %v\n", len(str))
   // 字符串分割
   fmt.Printf("strings.Split(str, \" \"): %v\n", strings.Split(str, " "))
   // 字符串包含
   fmt.Printf("strings.Contains(str, \"lo\"): %v\n", strings.Contains(str, "lo"))
   // 字符串前缀
   fmt.Printf("strings.HasPrefix(\"he\"): %v\n", strings.HasPrefix(str, "he"))
   // 字符串后缀
   fmt.Printf("strings.HasSuffix(\"ld\"): %v\n", strings.HasSuffix(str, "ld"))
   // 字符串索引
   fmt.Printf("strings.Index(str, wo): %v\n", strings.Index(str, "wo"))
   // 字符串字母小写转大写
   fmt.Printf("strings.ToUpper(str): %v\n", strings.ToUpper(str))
}

func main() {

   // string类型默认值为 空字符串，占16个字节
   var str string
   fmt.Printf("str: %v, %d \n", str, unsafe.Sizeof(str))

   // 字符串可通过 双引号 、反引号创建，反引号创建的字符串不支持转义字符
   var str01 = "hello world!\n"
   var str02 = `hello world!\n`
   var str03 = "hello world!"
   fmt.Printf("%v, %v, %v", str01, str02, str03)

   // 拼接
   stringBond()
   // 截取
   stringCutout()
   // 热点方法
   hotMethod()
}