Golang - 基本数据类型

---

基本数据类型

int

• 取值范围
  • int8: -(2^8-1-1) ~ 2^8-1-1
  • int16: -(2¹⁵-1) ~ 2¹⁵-1
  • int32: -(2³¹-1) ~ 2³¹ -1
  • int64: -(2⁶³-1) ~ 2⁶³ -1
• 示例

  package main
  
  import (
  	"fmt"
  	"unsafe"
  )
  
  func main() {
  	// 定义整型
  	var a int8
  	var b int64
  
  	// 验证整型大小
  	fmt.Println(unsafe.Sizeof(a)) // 1, *8 后得到实际位数
  	fmt.Println(unsafe.Sizeof(b)) // 8
  
  	// 定义不同进制的 16
  	c10 := 16   // 10 进制
  	c8 := 020   // 8 进制
  	c16 := 0x10 // 16 进制
  
  	fmt.Printf("%b, %[1]d, %[1]o, %[1]x\n", c10) // 10000, 16, 20, 10
  	fmt.Printf("%b, %[1]d, %[1]o, %[1]x\n", c8)  // 10000, 16, 20, 10
  	fmt.Printf("%b, %[1]d, %[1]o, %[1]x\n", c16) //10000, 16, 20, 10
  }
  

---

float

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Printf("%f\n", math.Pi)
	fmt.Printf("%.2f\n", math.Pi) // 保留两位小数
}

---

bool

• true 和 false, 默认为false
• 不允许强制转换
• 无法参与运算
• 无法与其他类型转换

---

string

常用方法

中文文档

描述	方法
求字符串长度	len(str)
拼接字符串	+ 或 fmt.Sprintf("%s, %s", strA, strB) 或 strings.Join(Slice, sep)
切片转字符串	strings.Join(Slice, sep)
切割字符串	strings.Split(str, sep)
判断是否包含	strings.contains(str, sep)
判断前后缀	strings.HasPrefix(str, sep); strings.HasSuffix(str, sep)
求子串出现位置	strings.Index(str, sep); strings.LastIndex(str, sep)

---

示例

package main

import (
	"fmt"
	"strings"
)

func main() {
	// 使用utf-8编码, 双引号中的内容

	// 多行字符串
	s1 := `
	a
	`
	fmt.Println(s1)

	// 求字符串长度
	s2 := "abc"
	fmt.Println(len(s2))

	// 拼接字符串
	m := "a"
	n := "b"
	i := m + n                        // 无特殊处理
	j := fmt.Sprintf("%s - %s", m, n) // 有特殊处理
	fmt.Println(i, j)

	// 字符串分割
	s3 := "a b c d"
	ret := strings.Split(s3, " ")
	fmt.Println(ret) // [a b c d]

	// 判断包含和前后缀
	s4 := "abc"
	r1 := strings.Contains(s4, "b")
	r2 := strings.HasPrefix(s4, "a")
	r3 := strings.HasSuffix(s4, "a")
	fmt.Println(r1, r2, r3)

	// 求子串出现的位置
	s5 := "abac"
	x := strings.Index(s5, "a")     // 第一次出现的索引
	y := strings.LastIndex(s5, "a") // 最后一次出现的索引
	fmt.Println(x, y)
}

---

byte和 rune 类型

package main

import (
	"fmt"
)

func main() {
	s1 := "golang"
	c1 := 'g' // ascii 1个字节(一个字节 8bit)

	s2 := "中国"
	c2 := '中' // utf-8 3个字节

	fmt.Println(s1, c1) // t1输出的是字符串, c1输出的是ascii码号
	fmt.Println(s2, c2)

	s3 := "hello 中国"

	// 按照bytes类型去遍历
	for i := 0; i < len(s3); i++ {
		fmt.Printf("%[1]v: %[2]v(%[2]c)\n", i, s3[i])
	}

	// 按照rune类型去遍历, 用于整个字符串遍历
	for k, v := range s3 {
		fmt.Printf("%v: %c\n", k, v)
	}
}

---

转换示例

str --> []byte/[]rune

package main

import (
	"fmt"
)

func main() {
	// string --> []byte
	s := "hello world"
	b := []byte(s)
	fmt.Println(b)

    // []byte --> string
	b1 := []byte{104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100}
	s1 := string(b1)
	fmt.Println(s1)
}

---

str --> int

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// string --> int
	s := "123"
	n, _ := strconv.Atoi(s)
	fmt.Println(n)

	// string --> int64
  // 第二个参数是 进制(十进制, 八进制, 十六进制)
  // 第三个参数不是 int64 的 64, 而是最大数值, 比如填3, 那得到的最大值为(2^2)-1, 如果填 4, 则得到最大值为(2^3)-1, 类型都是 int64
	n1, _ := strconv.ParseInt(s, 10, 64)
	fmt.Printf("%T, %[1]v", n1)

	// int --> string
	s1 := strconv.Itoa(n)
	fmt.Println(s1)

	// int64 --> string
	var n2 int64
	n2 = 299
	s2 := strconv.FormatInt(n2, 10)
	fmt.Println(s2)
}

---

str --> []string

package main

import (
	"fmt"
	"strings"
)

func main() {
	// []string --> string
	sliceA := []string{"a", "b", "c"}
	r := strings.Join(sliceA, "-")
	fmt.Println(r)  // a-b-c

    // string --> []string
    sliceB := strings.Split(r, "-")
    fmt.Println(sliceB)  // []string{"a", "b", "c"}
}

---

取模及范围限定

// 结果数值范围为 [−2^31,  2^31−1], 如果超出范围返回 0 
// 1<<31 表示 2^31
// -(1<<31) --> -2^31, 1<<31 --> 2^31
// !() --> 整体取反, 拿到两边的取值范围
if !(-(1<<31) <= r && r <= (1<<31)-1) {
	return 0
}

// 需要以 1e9 + 7 (1000000007) 为底取模，如：计算初始结果为：1000000008，请返回 1
r %= (1e9 + 7)
// 或
r %= 1000000007

---

练习

修改字符串

package main

import "fmt"

func changeAlph() {
	// 定义一个纯英文字符串
	s := "aaa"

	// 转为 []byte
	b := []byte(s)

	//b[1] = 98
	b[1] = 'b'

	fmt.Println(string(b))
}

func changeChar() {
	// 定义一个纯英文字符串
	s := "beijing北京"

	// 转为 []rune
	b := []rune(s)

	// 这里可以根据索引修改为对应的 byte 数字, 也可以用单引号修改字符
	b[7] = 21335
	//b[7] = '南'

	fmt.Println(string(b))
}

func main() {
	changeAlph()
	changeChar()
}

---

字符串反序

package main

import "fmt"

func main() {
	s3 := "abcde"

	// 方法一
	r1 := ""
	for i := len(s3) - 1; i >= 0; i-- {
		r1 += string(s3[i])
	}
	fmt.Println(r1)
	
	// 方法二
	bArr := []byte(s3)
	// bArr[1], bArr[5] = bArr[5], bArr[1]
	// bArr[2], bArr[4] = bArr[4], bArr[2]
	for i := 0; i < len(s3)/2; i++ {
		bArr[i], bArr[len(s3)-1-i] = bArr[len(s3)-1-i], bArr[i]
	}
	r2 := string(bArr)
	fmt.Println(r2)
}