GO 中 string 的实现原理

简介: GO 中 string 的实现原理

GO 中 string 的实现原理

上次我们分享的内容咱回顾一下

  • 分享了ETCD的简单单点部署,ETCD 使用到的包安装,以及会遇到的问题
  • ETCD 的设置 和 获取KEY
  • ETCD 的WATCH 监控 KEY的简化
  • ETCD 的租约 和保活机制
  • ETCD 的分布式锁的简单实现

要是对GO 对 ETCD 的编码还有点兴趣的话, 欢迎查看文章 GO 中 ETCD 的编码案例分享

字符串是什么?

他是一种基本类型(string 类型),并且是一个不可改变的UTF-8字符序列

在众多编程语言里面,相信都少不了字符串类型

字符串,顾名思义就是一串字符,我们要明白,字符也是分为中文字符和英文字符的

例如我们在 C/C++ 中 , 一个英文字符占 1 个字节,一个中文字符有的占 2 个字节,有的占3个字节

用到 mysql 的中文字符,有的占 4 个字节

回过来看 GO 里面的字符串,字符也是根据英文和中文不一样,一个字符所占用的字节数也是不一样的,大体分为如下 2

  • 英文的字符,按照ASCII 码来算,占用 1 个字节
  • 其他的字符,包括中文字符在内的,根据不同字符,占用字节数是 2 – 4个字节

字符串的数据结构是啥样的?

说到字符串的数据结构,我们先来看看 GO 里面的字符串,是在哪个包里面

不难发现,我们随便在 GOLANG 里面 定义个string 变量,就能够知道 string 类型是在哪个包里面,例如

var name  string

GO 里面的字符串对应的包是 builtin

// string is the set of all strings of 8-bit bytes, conventionally but not
// necessarily representing UTF-8-encoded text. A string may be empty, but
// not nil. Values of string type are immutable.
type string string
  • 字符串这个类型,是所有8-bits 字符串的集合,通常但不一定表示utf -8编码的文本
  • 字符串可以为空,但不能为 nil ,此处的字符串为空是 ""
  • 字符串类型的值是不可变的

另外,找到 string 在 GO 里面对应的源码文件中src/runtime/string.go , 有这么一个结构体,只提供给包内使用,我们可以看到string的数据结构 stringStruct 是这个样子的

type stringStruct struct {
    str unsafe.Pointer
    len int
}

整个结构体,就 2 个成员,**string **类型是不是很简单呢

  • str

是对应到字符串的首地址

  • len

这个就是不难理解,是字符串的长度

那么,在创建一个字符串变量的时候,stringStruct 是在哪里使用到的呢?

我们看看 GO string.go 文件中的源码

//go:nosplit
func gostringnocopy(str *byte) string {
   ss := stringStruct{str: unsafe.Pointer(str), len: findnull(str)}  // 构建成 stringStruct
   s := *(*string)(unsafe.Pointer(&ss))  // 强转成 string
   return s
}
//go:nosplit
func findnull(s *byte) int {
   if s == nil {
      return 0
   }
   // Avoid IndexByteString on Plan 9 because it uses SSE instructions
   // on x86 machines, and those are classified as floating point instructions,
   // which are illegal in a note handler.
   if GOOS == "plan9" {
      p := (*[maxAlloc/2 - 1]byte)(unsafe.Pointer(s))
      l := 0
      for p[l] != 0 {
         l++
      }
      return l
   }
   // pageSize is the unit we scan at a time looking for NULL.
   // It must be the minimum page size for any architecture Go
   // runs on. It's okay (just a minor performance loss) if the
   // actual system page size is larger than this value.
   const pageSize = 4096
   offset := 0
   ptr := unsafe.Pointer(s)
   // IndexByteString uses wide reads, so we need to be careful
   // with page boundaries. Call IndexByteString on
   // [ptr, endOfPage) interval.
   safeLen := int(pageSize - uintptr(ptr)%pageSize)
   for {
      t := *(*string)(unsafe.Pointer(&stringStruct{ptr, safeLen}))
      // Check one page at a time.
      if i := bytealg.IndexByteString(t, 0); i != -1 {
         return offset + i
      }
      // Move to next page
      ptr = unsafe.Pointer(uintptr(ptr) + uintptr(safeLen))
      offset += safeLen
      safeLen = pageSize
   }
}

简单分为 2 步:

  • 先将字符数据构建程 stringStruct
  • 再通过 gostringnocopy 函数 转换成 string

字符串中的数据为什么不能被修改呢?

从上述官方说明中,我们可以看到,字符串类型的值是不可变的

可是这是为啥呢?

我们以前在写C/C++的时候,为啥可以开辟空间存放多个字符,并且还可以修改其中的某些字符呢?

可是在 C/C++里面的字面量也是不可以改变的

GO 里面的 string 类型,是不是也和 字面量一样的呢?我们来看看吧

字符串类型,本身也是拥有对应的内存空间的,那么修改string类型的值应该是要支持的。

可是,XDM 在 Go 的实现中,string 类型是不包含内存空间,只有一个内存的指针,这里就有点想C/C++里面的案例:

char * str = "XMTONG"

上述的 str是绝对不能做修改的,str只是作为可读,不能写的

在GO 里面的字符串,就与上述类似

这样做的好处是 string 变得非常轻量,可以很方便的进行传递而不用担心内存拷贝(这也避免了内存带来的诸多问题)

GO 中的 string类型一般是指向字符串字面量

字符串字面量存储位置是在虚拟内存分区的只读段上面,而不是堆或栈上

因此,GO 的 string 类型不可修改的

可是我们想一想,要是在GO 里面字符串全都是只读的,那么我们如何动态修改一些我们需要改变的字符呢,这岂不是缺陷了

别慌

GO 里面还有byte数组,[]byte

这里顺带说一下

上述 char * str = "XMTONG"

  • 字符串长度,就是字符的个数,为 6
  • 计算str所占字节数(C/C++中是通过 sizeof() 来计算的)的话,那就是 7 ,因为尾巴后面还有一个’\0’

计算机中有这样的对应关系,简单提一下:

1 Bytes = 8 bit

1 K = 1024 Bytes

1 M = 1024 K

1 G = 1024 M

为什么有了字符串 还要 []byte?

原因正如上述我们说到的,如果全是一些只读的字面量,那么我们编码的时候就没得玩了

另外,也是根据使用字符串的场景原因,单是string无法满足所有的场景,因此得有一个我们可以修改里面值的 []byte 来弥补一下

说到这里,我们应该就知道了,string[]byte都是可以表示字符串,没毛病 ,

不过,他们毕竟对应不同的数据结构,使用方式也有一定的区别,GO 提供的对应方法也是不尽相同

我们来看看什么场景用 string 类型, 啥场景 使用 []byte 类型

使用到 string 类型的 地方:

  • 需要对字符串进行比较的时候,使用string 类型非常方便,直接使用操作符进行比较即可
  • string 类型 类型,为空的时候是 “”,他不能和nil做比较,因此,不用到nil的时候,也可以使用 string 类型

使用到 []byte 类型的 地方:

  • 需要修改字符串中字符的应用场景,使用**[]byte 类型**就相当灵活了,用起来很香
  • []byte 类型 为空的话,会是返回 nil ,需要使用到 nil 的时候,就可以使用他
  • []byte 类型 本身就可以按照切片的方式来玩,因此需要操作切片的时候,也可以用他

就上述场景来看,好像使用 []byte 更加实在和灵活,为啥还要用 string

原因如下:

  • string 类型看起来直观,用起来简单
  • []byte,byte 数组,我们可以知道,里面都是一个字节一个字节的,这个会比较多的用在底层,对操作字节比较关注的时候

字符串 和 []byte 如何互相转换?

看到这里,分别了解了 string 类型, 和 []byte 类型的应用场景

毋庸置疑,我们编码过程中,肯定少不了对他们做相互转换,我们来看看在 GO ,里面如何使用

字符串转 []byte

package main
import (
   "fmt"
)
func main(){
    var str string
    str = "XMTONG"
    strByte := []byte(str)
    for _,v :=range strByte{
        fmt.Printf("%x ",v)
    }
}

代码输出为:

58 4d 54 4f 4e 47

上述代码转成 []byte 之后是一个字节,一个字节的

将每一个字节的值用十六进制打印出来,我们可以看到,XMTONG 对应 584d544f4e47

[]byte 转字符串

[]byte转字符串在GO 里面那就更简单了

func main(){
   name := []byte("XMTONG")
   fmt.Println(string(name))
}

GO 中 字符串都会涉及到哪些函数?

无论什么语言,对于字符串大概涉及如下几种操作,若有偏差,还请指正:

  • 计算字符串长度
  • 拼接
  • 切割
  • 找到字串进行替换,找到字符串的具体位置和出现的次数
  • 统计字符串
  • 字符串进制转换

具体的函数使用方法也比较简单,推荐大家感兴趣的可以直接看go 的开发文档,需要的时候去查一下即可。

GO 的标准开发文档,在搜索引擎里面还是比较容易搜索到的

总结

  • 分享了字符串具体是啥
  • GO 中字符串的特性,为什么不能被修改
  • 字符串 GO 源码是如何构建的
  • 字符串 和 []byte 的由来和应用场景
  • 字符串与 []byte 相互转换
  • 顺带提了GO 的标准开发文档,大家可以用起来哦

欢迎点赞,关注,收藏

朋友们,你的支持和鼓励,是我坚持分享,提高质量的动力

好了,本次就到这里,下一次 GO 中 slice 的实现原理分享

技术是开放的,我们的心态,更应是开放的。拥抱变化,向阳而生,努力向前行。

我是小魔童哪吒,欢迎点赞关注收藏,下次见~

相关文章
|
5月前
|
Go
Go string bytes、strings、strconv和unicode包相关方法
Go string bytes、strings、strconv和unicode包相关方法
48 0
|
11月前
|
Go
go string to int 字符串与整数型的互换
go string to int 字符串与整数型的互换
54 0
|
2月前
|
分布式计算 安全 Java
简单易懂的 Go 泛型使用和实现原理介绍
简单易懂的 Go 泛型使用和实现原理介绍
|
4月前
|
存储 安全 测试技术
【Go语言精进之路】构建高效Go程序:了解map实现原理并高效使用
【Go语言精进之路】构建高效Go程序:了解map实现原理并高效使用
53 3
|
4月前
|
存储 监控 Go
【Go语言精进之路】构建高效Go程序:了解切片实现原理并高效使用
【Go语言精进之路】构建高效Go程序:了解切片实现原理并高效使用
59 3
|
2月前
|
Go
Go - 学习 grpc.Dial(target string, opts …DialOption) 的写法
Go - 学习 grpc.Dial(target string, opts …DialOption) 的写法
47 12
|
2月前
|
存储 安全 Go
Go 面试题:string 是线程安全的吗?
Go 面试题:string 是线程安全的吗?
|
5月前
|
存储 缓存 编译器
Go语言解析Tag:深入探究实现原理
【2月更文挑战第20天】
232 2
|
5月前
|
存储 安全 Java
Go Slice的底层实现原理深度解析
在Go语言的世界里,切片(Slice)是一种极其重要的数据结构,它以其灵活性和高效性在众多编程场景中扮演着核心角色。本文将深入探讨Go切片的底层实现原理,通过实例和源码分析,带你领略Go语言设计之美。
|
5月前
|
存储 编译器 Go
GO闭包实现原理(汇编级讲解)
函数闭包一点也不神秘,它就是函数和引用环境而组合的实体。在Go中,闭包在底层是一个结构体对象,它包含了函数指针与自由变量。Go编译器的逃逸分析机制,会将闭包对象分配至堆中,这样自由变量就不会随着函数栈的销毁而消失,它能依附着闭包实体而一直存在。因此,闭包使用的优缺点是很明显的:闭包能够避免使用全局变量,转而维持自由变量长期存储在内存之中;但是,这种隐式地持有自由变量,在使用不当时,会很容易造成内存浪费与泄露。附着闭包实体而一直存在。
72 0
GO闭包实现原理(汇编级讲解)