为什么在Swift中应使用String.Index而非Int作为字符串字符索引？

Great question—this is one of the most common gotchas when working with Swift strings, and it all boils down to how Swift handles Unicode and character representation. Let's break it down.

First: Why someString[2] Throws an Error #

Swift's String type doesn't support integer subscripting (like someString[2]) because what we perceive as a single "character" can take up varying amounts of storage space under the hood.

In Swift, a Character represents an Extended Grapheme Cluster—this is the Unicode term for a single user-visible character. For example:

• Simple characters like "A" or "省" might take 2 UTF-16 code units.
• Emojis like "" or "" could also take 2 code units, but some complex emojis (like family combinations 👨‍👩‍👧) are made from multiple Unicode code points stitched together into one Character.

Since the size of each Character isn't fixed, Swift can't directly map an integer like 2 to a specific position in the string's underlying storage. It would have to scan the string from the start to count out 2 grapheme clusters every time you use an integer index, which is inefficient and would hide the actual performance cost from developers.

What's the Point of String.Index? #

String.Index is Swift's way of giving you a precise, efficient reference to a position in the string's underlying storage. Here's why it matters:

• It points directly to a specific UTF-16 code unit position, so accessing a character via String.Index is an O(1) operation once you have the index.
• To get the index for the nth character, you use index(_:offsetBy:), which explicitly scans the string from a starting point (like startIndex) to count out the required number of grapheme clusters. This makes the performance cost (O(n) time) obvious—you know you're traversing the string to find the position.
• It prevents bugs that could come from assuming every character takes up the same amount of space. For example, if you tried to use integer indices on a string with variable-length characters, you might end up splitting a grapheme cluster in half and getting invalid Unicode data.

Let's Walk Through Your Example #

For your string:

let someString = "省"

• To get the third character (""), you first calculate its index by starting at startIndex and offsetting by 2:

  let strawberryIndex = someString.index(someString.startIndex, offsetBy: 2)
  

• Then you use that index to access the character:

  someString[strawberryIndex] // Returns Character("")
  

This works because index(_:offsetBy:) properly counts through each grapheme cluster, stopping at the exact position where the third character begins in the underlying storage.

Wrap-Up #

Swift's approach might feel more verbose at first, but it's designed to be safe and explicit. By forcing you to use String.Index, it ensures you understand that character positions aren't fixed offsets, and it avoids silent performance hits or invalid data issues that come with naive integer indexing.

内容的提问来源于stack exchange，提问作者Kirill Semenov