下面的所有示例都使用

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的标准，并暗示一个完整的字符。

extension String
{
    func subString <R> (_ range: R) -> String? where R : RangeExpression, String.Index == R.Bound
    {
        return String(self[range])
    }

    func index(at: Int) -> Index
    {
        return self.index(self.startIndex, offsetBy: at)
    }
}

从第3个字符开始子字符串:

let item = "Fred looks funny"
item.subString(item.index(at: 2)...) // "ed looks funny"

我已经使用驼峰subString表示它返回一个字符串，而不是一个subString。

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

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

String的特殊性在其他答案中已经讨论过了。解释一下:字符串有一个特定的索引，它不是Int类型，因为字符串元素在一般情况下没有相同的大小。因此，String不符合RandomAccessCollection，访问特定索引意味着遍历集合，这不是O(1)操作。

许多答案都提出了使用范围的变通方法，但它们会导致代码效率低下，因为它们使用的String方法(index(from:)， index(:offsetBy:)，…)不是O(1)。

要像在数组中一样访问字符串元素，您应该使用array:

let array = Array("Hello, world!")
let letter = array[5]

这是一个权衡，数组创建是一个O(n)操作，但数组访问是O(1)。当你想用String(数组)时，你可以转换回String。

我对Swift的字符串访问模型感到非常沮丧:所有东西都必须是索引。我想要的只是使用Int访问字符串的第I个字符，而不是笨拙的索引和推进(这恰好随着每个主要版本的发布而改变)。所以我对String做了一个扩展:

extension String {
    func index(from: Int) -> Index {
        return self.index(startIndex, offsetBy: from)
    }

    func substring(from: Int) -> String {
        let fromIndex = index(from: from)
        return String(self[fromIndex...])
    }

    func substring(to: Int) -> String {
        let toIndex = index(from: to)
        return String(self[..<toIndex])
    }

    func substring(with r: Range<Int>) -> String {
        let startIndex = index(from: r.lowerBound)
        let endIndex = index(from: r.upperBound)
        return String(self[startIndex..<endIndex])
    }
}

let str = "Hello, playground"
print(str.substring(from: 7))         // playground
print(str.substring(to: 5))           // Hello
print(str.substring(with: 7..<11))    // play

同样的挫折，这应该不难…

我编译了这个从较大文本中获取子字符串位置的示例:

//
// Play with finding substrings returning an array of the non-unique words and positions in text
//
//

import UIKit

let Bigstring = "Why is it so hard to find substrings in Swift3"
let searchStrs : Array<String>? = ["Why", "substrings", "Swift3"]

FindSubString(inputStr: Bigstring, subStrings: searchStrs)


func FindSubString(inputStr : String, subStrings: Array<String>?) ->    Array<(String, Int, Int)> {
    var resultArray : Array<(String, Int, Int)> = []
    for i: Int in 0...(subStrings?.count)!-1 {
        if inputStr.contains((subStrings?[i])!) {
            let range: Range<String.Index> = inputStr.range(of: subStrings![i])!
            let lPos = inputStr.distance(from: inputStr.startIndex, to: range.lowerBound)
            let uPos = inputStr.distance(from: inputStr.startIndex, to: range.upperBound)
            let element = ((subStrings?[i])! as String, lPos, uPos)
            resultArray.append(element)
        }
    }
    for words in resultArray {
        print(words)
    }
    return resultArray
}

返回 ("Why" 0,3) ("substrings"， 26, 36) (“Swift3”，40,46)