我一直在更新我的一些旧代码和答案与Swift 3,但当我得到Swift字符串和索引子字符串的事情变得令人困惑。

具体来说,我尝试了以下几点:

let str = "Hello, playground"
let prefixRange = str.startIndex..<str.startIndex.advancedBy(5)
let prefix = str.substringWithRange(prefixRange)

第二行给出了如下错误

String类型的值没有成员substringWithRange

我看到String现在确实有以下方法:

str.substring(to: String.Index)
str.substring(from: String.Index)
str.substring(with: Range<String.Index>)

这些一开始让我很困惑,所以我开始摆弄索引和范围。这是子字符串的后续问题和答案。我在下面添加了一个答案来说明它们是如何使用的。


当前回答

我发现了这个相当简单的方法。

var str = "Hello, World"
let arrStr = Array(str)
print(arrStr[0..<5]) //["H", "e", "l", "l", "o"]
print(arrStr[7..<12]) //["W", "o", "r", "l", "d"]
print(String(arrStr[0..<5])) //Hello
print(String(arrStr[7..<12])) //World

其他回答

斯威夫特5 let desiredIndex: Int = 7 let substring = str[字符串]。指数(encodedOffset: desiredIndex)…] 这个子字符串变量会给你结果。 这里Int被转换为Index,然后你可以拆分字符串。除非你会得到错误。

我创建了这样一个简单的函数:

func sliceString(str: String, start: Int, end: Int) -> String {
    let data = Array(str)
    return String(data[start..<end])
}

你可以用以下方法来使用它

print(sliceString(str: "0123456789", start: 0, end: 3)) // -> prints 012

下面的所有示例都使用

var str = "Hello, playground"

斯威夫特4

在Swift 4中,字符串进行了相当大的修改。当你从String中获取子字符串时,你得到的是substring类型而不是String类型。为什么会这样?字符串是Swift中的值类型。这意味着如果你使用一个字符串来创建一个新的字符串,那么它必须被复制。这有利于稳定性(没有人会在你不知情的情况下改变它),但不利于效率。

另一方面,Substring是返回到它所来自的原始String的引用。下面是文档中的一张图片说明了这一点。

不需要复制,所以使用起来更有效率。但是,假设您从100万个字符字符串中获得了10个字符的子字符串。因为Substring引用了String,只要Substring存在,系统就必须保留整个String。因此,当你完成对Substring的操作时,将其转换为String。

let myString = String(mySubstring)

这将只复制子字符串,保留旧字符串的内存可以被回收。子字符串(作为一种类型)意味着生命周期很短。

Swift 4的另一个重大改进是字符串是集合(再次)。这意味着你可以对Collection做什么,也可以对String做什么(使用下标、遍历字符、过滤器等)。

下面的例子展示了如何在Swift中获取子字符串。

获得子字符串

您可以通过使用下标或许多其他方法(例如,前缀、后缀、split)从字符串中获得子字符串。您仍然需要使用String。索引,而不是范围的Int索引。(如果你需要帮助,请参阅我的另一个答案。)

字符串的开头

你可以使用下标(注意Swift 4的单边范围):

let index = str.index(str.startIndex, offsetBy: 5)
let mySubstring = str[..<index] // Hello

或前缀:

let index = str.index(str.startIndex, offsetBy: 5)
let mySubstring = str.prefix(upTo: index) // Hello

或者更简单:

let mySubstring = str.prefix(5) // Hello

字符串的结尾

使用下标:

let index = str.index(str.endIndex, offsetBy: -10)
let mySubstring = str[index...] // playground

或后缀:

let index = str.index(str.endIndex, offsetBy: -10)
let mySubstring = str.suffix(from: index) // playground

或者更简单:

let mySubstring = str.suffix(10) // playground

注意,当使用后缀(from: index)时,我必须使用-10从末尾开始计数。当只使用后缀(x)时,这是不必要的,它只接受字符串的最后x个字符。

字符串中的范围

同样,我们在这里使用了下标。

let start = str.index(str.startIndex, offsetBy: 7)
let end = str.index(str.endIndex, offsetBy: -6)
let range = start..<end

let mySubstring = str[range]  // play

将子字符串转换为字符串

不要忘记,当你准备保存你的子字符串时,你应该把它转换成一个字符串,这样旧的字符串的内存就可以被清理。

let myString = String(mySubstring)

使用Int索引扩展?

在阅读Airspeed Velocity和Ole Begemann的文章《Strings in Swift 3》后,我犹豫是否要使用基于Int的索引扩展。虽然在Swift 4中,字符串是集合,但Swift团队故意没有使用Int索引。它仍然是String.Index。这与Swift字符由不同数量的Unicode码点组成有关。实际索引必须为每个字符串唯一地计算。

我不得不说,我希望Swift团队能找到一种方法来抽象String。未来的指数。但在那之前,我选择使用他们的API。它帮助我记住String操作不仅仅是简单的Int索引查找。

我最初的反应也一样。我也对语法和对象在每个主要版本中发生如此巨大的变化感到沮丧。

然而,我从经验中意识到,我总是在努力对抗“变化”的过程中最终遭受后果,比如处理多字节字符,如果你面对的是全球受众,这是不可避免的。

因此,我决定承认并尊重苹果工程师所付出的努力,并尽我所能,理解他们在想出这种“可怕”方法时的心态。

与其创建扩展,这只是一个让你的生活更容易的解决方案(我不是说他们是错误的或昂贵的),为什么不弄清楚字符串现在是如何设计工作的。

例如,我在Swift 2.2上有这样的代码:

let rString = cString.substringToIndex(2)
let gString = (cString.substringFromIndex(2) as NSString).substringToIndex(2)
let bString = (cString.substringFromIndex(4) as NSString).substringToIndex(2)

在放弃尝试使用相同的方法工作后,例如使用Substrings,我终于理解了将字符串作为双向集合的概念,为此我最终得到了这个版本的相同代码:

let rString = String(cString.characters.prefix(2))
cString = String(cString.characters.dropFirst(2))
let gString = String(cString.characters.prefix(2))
cString = String(cString.characters.dropFirst(2))
let bString = String(cString.characters.prefix(2))

我希望这有助于……

在上面的基础上,我需要在非打印字符处分割字符串,删除非打印字符。我开发了两种方法:

var str = "abc\u{1A}12345sdf"
let range1: Range<String.Index> = str.range(of: "\u{1A}")!
let index1: Int = str.distance(from: str.startIndex, to: range1.lowerBound)
let start = str.index(str.startIndex, offsetBy: index1)
let end = str.index(str.endIndex, offsetBy: -0)
let result = str[start..<end] // The result is of type Substring
let firstStr = str[str.startIndex..<range1.lowerBound]

我用上面的一些答案组合在一起。

因为字符串是一个集合,然后我做了以下工作:

var fString = String()
for (n,c) in str.enumerated(){

*if c == "\u{1A}" {
    print(fString);
    let lString = str.dropFirst(n + 1)
    print(lString)
    break
   }
 fString += String(c)
}*

这对我来说更直观。哪个是最好的?我不知道 它们都使用Swift 5