Go语言中的字符串

字符串

字符串是 Go 语言中的基础数据类型，虽然字符串往往被看做一个整体，但是它实际上是一片连续的内存空间，我们也可以将它理解成一个由字符组成的数组，本节会介绍字符串的实现原理、转换过程以及常见操作的实现。

1.字符串它实际上是由字符组成的数组，Go 语言中的字符串只是一个只读的字节数组，下图展示了 “hello” 字符串在内存中的存储方式：

只读只意味着字符串会分配到只读的内存空间，但是 Go 语言只是不支持直接修改 string 类型变量的内存空间，我们仍然可以通过在
string 和 []byte 类型之间反复转换实现修改这一目的

1.字符串数据结构
字符串在 Go 语言中的接口其实非常简单，每一个字符串在运行时都会使用如下的 reflect.StringHeader 表示，其中包含指向字节数组的指针和数组的大小：

type StringHeader struct {
	Data uintptr
	Len  int
}

与切片的结构体相比，字符串只少了一个表示容量的 Cap 字段，而正是因为切片在 Go 语言的运行时表示与字符串高度相似，所以我们经常会说字符串是一个只读的切片类型。

type SliceHeader struct {
	Data uintptr
	Len  int
	Cap  int
}

因为字符串作为只读的类型，我们并不会直接向字符串直接追加元素改变其本身的内存空间，所有在字符串上的写入操作都是通过拷贝实现的。

2.Go 语言处理标准字符串的逻辑

1. 标准字符串使用双引号表示开头和结尾；
2. 标准字符串需要使用反斜杠 \ 来逃逸双引号；
3. 标准字符串不能出现如下所示的隐式换行 \n；

转义字符：

3.字符串与数值相互转换

package main

import (
"fmt"
"strconv"
)

func main() {
	// 字符串转数值
	var str string = "100"
	/**
	 * param:string
	 * return:int,error
	 */
	num, _ := strconv.Atoi(str)
	fmt.Printf("%T\n", num)
	
	/*
	 * param str,进制,类型
	 * return int64,err
	 */
	num1, _ := strconv.ParseInt(str, 0, 64)
	fmt.Printf("%T\n", num1)
	
	// 数值转字符串
	var number int = 200
	/*
	 * param int
	 * return string
	 */
	str1 := strconv.Itoa(number)
	fmt.Printf("%T\n", str1)
	
	var number2 int64 = 500
	/*
	 * param int64, 进制
	 * return string
	 */
	str2 := strconv.FormatInt(number2, 10)
	fmt.Printf("%T\n", str2)
}

4.字符串基本操作

package main

import (
"fmt"
"strings"
)

func main() {
	var str string = "hello"
	fmt.Println(len(str))
	// 字符串截取
	str1 := str[0]
	fmt.Println(str1)
	fmt.Printf("%T\n", str1)
	str2 := fmt.Sprintf("%c", str1)
	// 取字符
	fmt.Printf("%T\n", str2)
	fmt.Println(str2)
	
	// 范围截取
	str3 := str[0:2]
	fmt.Printf("%T\n", str3)
	fmt.Println(str3)
	str4 := str[:3]
	fmt.Printf("%T\n", str4)
	fmt.Println(str4)
	str5 := str[5:]
	fmt.Printf("%T\n", str5)
	fmt.Println(str5)
	
	// 字符串转切片
	s1 := []rune(str)
	fmt.Printf("%T\n", s1)
	fmt.Println(len(s1))
	fmt.Println(s1[0])
	// 取字符
	fmt.Printf("%c\n", s1[0])
	fmt.Printf("%c\n", s1[5])
	
	// 遍历字符串
	for i, n := range str {
	// fmt.Println(i, n)
	// 打印字符
	fmt.Printf("%d=>%c\n", i, n)
	}
	
	// 常用字符串函数
	// HasPrefix 前缀
	// isOk := strings.HasPrefix(str, "fr")
	// HasSuffix 后缀
	// isOk := strings.HasSuffix(str, "博")
	// Contains 包含子串
	// isOk := strings.Contains(str, "an")
	// fmt.Printf("%t\n", isOk)
	// Index 子串第一次出现的位置
	// index := strings.Index(str, "r")
	// LastIndex 子串最后出现的位置
	index := strings.LastIndex(str, "a")
	fmt.Printf("%d\n", index)
	// ToLower 转小写
	strL := strings.ToLower(str)
	fmt.Printf("%s\n", strL)
	// ToUpper 转大写
	strU := strings.ToUpper(str)
	fmt.Printf("%s\n", strU)
	// Replace 替换
	strNew := strings.Replace(str, "a", "b", 1)
	fmt.Printf("%s\n", strNew)
	// Trim 去除字符串前后的指定字符
	strNew2 := strings.Trim(str, "f")
	fmt.Printf("%s\n", strNew2)
	// Split 字符串切分成切片
	slice := strings.Split(str, "")
	fmt.Println(slice)
	// Join 切片组合成字符串
	strSlice := strings.Join(slice, "+")
	fmt.Printf("%s\n", strSlice)

}

5.时间类型&时间类型与字符串类型互相转换

package main

import (
"fmt"
"time"
)

func main() {
	// time 包
	// 声明 Time 类型
	var t time.Time
	fmt.Println(t)
	// time.Now()函数，获取当前时间
	t1 := time.Now()
	fmt.Printf("%T\n", t1)
	fmt.Println(t1)
	
	/*
	 * 通过纳秒时间戳创建时间变量
	 * param: 秒，纳秒
	 * return:time.Time
	 */
	t2 := time.Unix(0, t1.UnixNano())
	fmt.Println(t2)
	
	// 根据自己要求创建时间
	t3 := time.Date(2020, 6, 10, 16, 51, 03, 123, time.Local)
	fmt.Println(t3)
	// 其它函数
	year := t3.Year()
	month := t3.Month()
	monthInt := int(month)
	day := t3.Day()
	hour := t3.Hour()
	minute := t3.Minute()
	second := t3.Second()
	nanosec := t3.Nanosecond()
	fmt.Println(year)
	fmt.Println(month)
	fmt.Println(monthInt)
	fmt.Println(day)
	fmt.Println(hour)
	fmt.Println(minute)
	fmt.Println(second)
	fmt.Println(nanosec)
	y, m, d := t3.Date()
	fmt.Println(y, m, d)
	fmt.Println(t3.Clock())
	// 时间类型转换字符串
	timeStr := t1.Format("2006-01-02 15:04:05")
	fmt.Printf("%T\n", timeStr)
	fmt.Printf("%s\n", timeStr)
	// 字符串类型转换成时间类型
	str := "1990-11-16 07:30:08"
	t4, _ := time.Parse("2006-01-02 15:04:05", str)
	fmt.Printf("%T\n", t4)
	fmt.Println(t4)
}