Swift进阶-String源码解析
Swift进阶-类与结构体
Swift-函数派发
Swift进阶-属性
Swift进阶-指针
Swift进阶-内存管理
Swift进阶-TargetClassMetadata和TargetStructMetadata数据结构源码分析
Swift进阶-Mirror解析
Swift进阶-闭包
Swift进阶-协议
Swift进阶-泛型
Swift进阶-String源码解析
Swift进阶-Array源码解析
1.String在内存中是如何存储的
创建一个空的字符串发生了什么？
var empty = ""
print(empty) // 断点在这里调试看
断点调试x/8g
这里并不能看出String的内存结构。那么接下来就借助Swift源码的方式看看String在内存中到底是如何存储的。
打开swift源码 -> stdib里的String.swift
@frozen
public struct String {
public // @SPI(Foundation)
var _guts: _StringGuts
@inlinable @inline(__always)
internal init(_ _guts: _StringGuts) {
self._guts = _guts
_invariantCheck()
}
// This is intentionally a static function and not an initializer, because
// an initializer would conflict with the Int-parsing initializer, when used
// as function name, e.g.
// [1, 2, 3].map(String.init)
@_alwaysEmitIntoClient
@_semantics("string.init_empty_with_capacity")
@_semantics("inline_late")
@inlinable
internal static func _createEmpty(withInitialCapacity: Int) -> String {
return String(_StringGuts(_initialCapacity: withInitialCapacity))
}
/// Creates an empty string.
///
/// Using this initializer is equivalent to initializing a string with an
/// empty string literal.
///
/// let empty = ""
/// let alsoEmpty = String()
@inlinable @inline(__always)
@_semantics("string.init_empty")
public init() { self.init(_StringGuts()) }
}
最直观地可以看到String是一个结构体，就是我们所说的值类型；它有一个成员变量_StringGuts
其中最后有一个创建空字符串初始化方式 self.init(_StringGuts())：
空字符串初始化
接下来看看这个_StringGuts到底是什么东西？
同样找到swift源码 -> stdib里的StringGuts.swift
@frozen
public // SPI(corelibs-foundation)
struct _StringGuts: @unchecked Sendable {
@usableFromInline
internal var _object: _StringObject
@inlinable @inline(__always)
internal init(_ object: _StringObject) {
self._object = object
_invariantCheck()
}
// Empty string
@inlinable @inline(__always)
init() {
self.init(_StringObject(empty: ()))
}
}
_StringGuts也是一个结构体，它有一个成员变量是_StringObject类型的实例；
并且在最后是通过初始化出一个_StringObject类型的实例来初始化_StringGuts的。
所以真正swift的String的实质就是_StringObject。接下来看看_StringObject到底是什么玩意儿？
找到swift源码 -> stdib里的StringObject.swift，可以看到_StringObject是一个结构体，再找到空字符串的初始化函数：
_StringObject空字符串初始化函数
ps: 注意这里初始化时的传参，下面会说到这几个成员
最终找到字符串最终初始化函数，该函数是对成员的初始化赋值，那么只要搞懂这几个成员是代表什么意思，那就能搞清楚字符串的底层实质了。
_StringObject最终初始化函数
_StringObject存储着一些成员变量，文章最开始使用x/8g格式化输出一个空字符串对象empty的时候，那我猜测：输出的内容应该就是_StringObject里的_count、_variant、_discriminator、_flags。
@usableFromInline
internal var _count: Int // 字符串大小
@usableFromInline
internal var _variant: Variant // 枚举值 默认0
@usableFromInline
internal var _discriminator: UInt8 // 在初始化的时候传递了一个Nibbles.emptyString
@usableFromInline
internal var _flags: UInt16
internal var _variant: Variant是一个枚举值，默认是immortal 0：
@usableFromInline @frozen
internal enum Variant {
case immortal(UInt) // 原始字符串
case native(AnyObject) // AnyObject
case bridged(_CocoaString) // NSString
@inlinable @inline(__always)
internal static func immortal(start: UnsafePointer<UInt8>) -> Variant {
let biased = UInt(bitPattern: start) &- _StringObject.nativeBias
return .immortal(biased)
}
@inlinable @inline(__always)
internal var isImmortal: Bool {
if case .immortal = self { return true }
return false
}
}
internal var _discriminator: UInt8 在初始化的时候传递了一个Nibbles.emptyString（Nibbles是一个枚举类型）：
extension _StringObject.Nibbles {
// The canonical empty string is an empty small string
@inlinable @inline(__always)
internal static var emptyString: UInt64 {
return _StringObject.Nibbles.small(isASCII: true)
}
}
// Discriminator for small strings
@inlinable @inline(__always)
internal static func small(isASCII: Bool) -> UInt64 {
// 是ASCII就用0xE000_0000_0000_0000否则用0xA000_0000_0000_0000
return isASCII ? 0xE000_0000_0000_0000 : 0xA000_0000_0000_0000
}
0xE000_0000_0000_0000 与文章最上面截图相对应起来了：
x/8g空字符串对象地址
那接下来我们就能测试一下字符串了：
字符a的ASCII编码是97，97的16进制是61，注意那个2的字节位的输出
小于等于15个字符串时，会记录字符串的位数。
对于小字符串(小于等于15个字符串)来说，是优先直接存到内存当中，无需另外分配内存空间的。（和NSString差不多类似）
接下来看看中文字符
中文字符串
中文字符不是ASCII编码，一个中文字符占据3个字节（24位），也是我们上面通过源码分析得出的使用了 0xA000_0000_0000_0000
所以_StringObject.Nibbles是一个识别器，去识别字符串是不是ASCII编码。
对于大字符串(大于15个字符串)来说，原本的小字符串占据的15个字节已经不足以存储字符串了，那就会发生改变：
来看看0x8000000000000000在源码中出现的定义是一个大原始字符串：
那剩下的 0x000000010000b860 到底是什么东西呢？它是字符串的内存相对地址；
那应该偏移多少呢？来看源码里的注解
image.png
意思是0x10000b860需要加上偏移量nativeBias即32，32的16进制是0x20:
0x10000b860 + 0x20 = 0x10000b880
在源码注解里找到大字符串标志位
大字符串标志位
大字符串前8位就记录着这些标志位信息，0xd000000000000012就是大字符串前8位，拿到科学计算器里看看标志位：
所以count是0x12，转换成10进制就是18，正好对应18个字符。
总结：
小字符串：大小在15字节以内(包含15)，直接存到内存当中，无需另外分配内存空间的（和NSString差不多类似）。
大字符串：大小在15字节以上，会另外开辟内存去存储字符串内容。字符串对象的第一个8字节存储的是标志位信息；第二个最高位标识大字符串，剩下的是相对偏移地址信息，需要偏移0x20才是真实另外开辟的内存地址。
二、String.Index
对于String来说，它并不支持通过下标的方式获取字符
只能通过String.Index的方式来访问
var str = "hello world"
// str.index(str.startIndex, offsetBy: 1) 从开始位置向后偏移1，返回结果是String.Index类型
print(str[str.index(str.startIndex, offsetBy: 1)]) // e
对于 Swift 来说，String 是一系列字符的集合，也就意味着 String 中的每一个元素是不等长的。那也就意味着我们在进行内存移动的时候步长是不一样的，什么意思？
比如我们有一个 Array 的数组（Int 类型），当我们遍历数组中的元素的时候，因为每个元素的内存大小是一致的，所以每次的偏移量就是 8 个字节。
但是对于字符串来说不一样，比如我要方位 str[1] 那么我是不是要把我这个字段遍历完成之后才能够确定是的偏移量？
依次内推每一次都要重新遍历计算偏移量，这个时候无疑增加了很多的内存消耗。这就是为什么我们不能通过 Int 作为下标来去访问 String。
可以很直观的看到 Index 的定义：
String.Index64位的位域信息的内容
position aka encodedOffset一个 48 bit 值，用来记录码位偏移量；
transcoded offset: 一个 2 bit 的值，用来记录字符使用的码位数量；
grapheme cache: 一个 6 bit 的值，用来记录下一个字符的边界；
reserved : 7 bit 的预留字段；
scalar aligned : 一个 1 bit 的值，用来记录标量是否已经对齐过。
String.Index的本质就是一个64位的位域信息，这个位域信息展示的就是上面的解释。
创建String.Index实际上就是通过encodedOffset 或者 transcoded offset，encodedOffset就是方便我们从内存中通过下标访问到字符串。
