你如何使用 String.substringWithRange？ （或者，范围如何在 Swift 中工作？）

例如，在我的全名中查找名字（直到第一个空格）：

let name = "Joris Kluivers"

let start = name.startIndex
let end = find(name, " ")

if end {
    let firstName = name[start..end!]
} else {
    // no space found
}

start 和 end 在此处属于 String.Index 类型，用于创建 Range<String.Index> 并在下标访问器中使用（如果在原始字符串中完全找到空格）。

很难直接从开头帖子中使用的整数位置创建 String.Index。这是因为在我的名字中，每个字符的字节大小都是相等的。但是在其他语言中使用特殊重音的字符可能会使用更多的字节（取决于使用的编码）。那么整数应该指哪个字节呢？

可以使用方法 succ 和 pred 从现有的 String.Index 创建一个新的 String.Index，这将确保跳过正确的字节数以到达编码中的下一个代码点。但是在这种情况下，搜索字符串中第一个空格的索引以找到结束索引会更容易。

---

由于 String 是 NSString 的桥接类型，因此“旧”方法应该可以工作，但不清楚如何 - 例如，这也不起作用（似乎不是有效的语法）： let x = str.substringWithRange(NSMakeRange (0, 3))

对我来说，这是你问题中真正有趣的部分。 String 桥接到 NSString，所以大多数 NSString 方法都直接在 String 上工作。您可以不假思索地自由使用它们。因此，例如，这就像您期望的那样工作：

// delete all spaces from Swift String stateName
stateName = stateName.stringByReplacingOccurrencesOfString(" ", withString:"")

但是，正如经常发生的那样，“我的魔力起作用了，但它对你不起作用。”您只是碰巧选择了一种罕见的情况，其中存在一个并行的同名 Swift 方法，在这种情况下，Swift 方法使 Objective-C 方法黯然失色。因此，当你说 str.substringWithRange 时，Swift 认为你指的是 Swift 方法而不是 NSString 方法——然后你就被淹没了，因为 Swift 方法需要一个 Range<String.Index>，而你不知道如何制作其中一个.

最简单的方法是通过显式强制转换来阻止 Swift 像这样被掩盖：

let x = (str as NSString).substringWithRange(NSMakeRange(0, 3))

请注意，此处不涉及任何重要的额外工作。 “Cast”并不意味着“convert”； String 实际上是一个 NSString。我们只是告诉 Swift 为了这一行代码的目的如何查看这个变量。

整个事情真正奇怪的部分是导致所有这些麻烦的 Swift 方法没有记录。我不知道它是在哪里定义的；它不在 NSString 标头中，也不在 Swift 标头中。

---

简短的回答是，现在这在 Swift 中真的很难。我的预感是，Apple 仍有大量工作要做，以便为此类事情提供便利方法。

String.substringWithRange() 需要一个 Range<String.Index> 参数，据我所知，没有 String.Index 类型的生成器方法。您可以从 aString.startIndex 和 aString.endIndex 取回 String.Index 值并调用 .succ() 或 .pred() ，但这太疯狂了。

使用旧的 Int 对 String 类进行扩展怎么样？

extension String {
    subscript (r: Range<Int>) -> String {
        get {
            let subStart = advance(self.startIndex, r.startIndex, self.endIndex)
            let subEnd = advance(subStart, r.endIndex - r.startIndex, self.endIndex)
            return self.substringWithRange(Range(start: subStart, end: subEnd))
        }
    }
    func substring(from: Int) -> String {
        let end = countElements(self)
        return self[from..<end]
    }
    func substring(from: Int, length: Int) -> String {
        let end = from + length
        return self[from..<end]
    }
}

let mobyDick = "Call me Ishmael."
println(mobyDick[8...14])             // Ishmael

let dogString = "This 🐶's name is Patch."
println(dogString[5..<6])               // 🐶
println(dogString[5...5])              // 🐶
println(dogString.substring(5))        // 🐶's name is Patch.
println(dogString.substring(5, length: 1))   // 🐶

更新：Swift beta 4 解决了以下问题！

就目前而言 [在 beta 3 和更早版本中]，即使是 Swift 原生字符串在处理 Unicode 字符方面也存在一些问题。上面的狗图标有效，但以下无效：

let harderString = "1:1️⃣"
for character in harderString {
    println(character)
}

输出：

1
:
1
️
⃣

---

在新的 Xcode 7.0 中使用

//: Playground - noun: a place where people can play

import UIKit

var name = "How do you use String.substringWithRange?"
let range = name.startIndex.advancedBy(0)..<name.startIndex.advancedBy(10)
name.substringWithRange(range)

//OUT:

https://i.stack.imgur.com/1wYAl.png

---

您可以使用此扩展来改进 substringWithRange

斯威夫特 2.3

extension String
{   
    func substringWithRange(start: Int, end: Int) -> String
    {
        if (start < 0 || start > self.characters.count)
        {
            print("start index \(start) out of bounds")
            return ""
        }
        else if end < 0 || end > self.characters.count
        {
            print("end index \(end) out of bounds")
            return ""
        }
        let range = Range(start: self.startIndex.advancedBy(start), end: self.startIndex.advancedBy(end))
        return self.substringWithRange(range)
    }

    func substringWithRange(start: Int, location: Int) -> String
    {
        if (start < 0 || start > self.characters.count)
        {
            print("start index \(start) out of bounds")
            return ""
        }
        else if location < 0 || start + location > self.characters.count
        {
            print("end index \(start + location) out of bounds")
            return ""
        }
        let range = Range(start: self.startIndex.advancedBy(start), end: self.startIndex.advancedBy(start + location))
        return self.substringWithRange(range)
    }
}

斯威夫特 3

extension String
{
    func substring(start: Int, end: Int) -> String
    {
        if (start < 0 || start > self.characters.count)
        {
            print("start index \(start) out of bounds")
            return ""
        }
        else if end < 0 || end > self.characters.count
        {
            print("end index \(end) out of bounds")
            return ""
        }
        let startIndex = self.characters.index(self.startIndex, offsetBy: start)
        let endIndex = self.characters.index(self.startIndex, offsetBy: end)
        let range = startIndex..<endIndex

        return self.substring(with: range)
    }

    func substring(start: Int, location: Int) -> String
    {
        if (start < 0 || start > self.characters.count)
        {
            print("start index \(start) out of bounds")
            return ""
        }
        else if location < 0 || start + location > self.characters.count
        {
            print("end index \(start + location) out of bounds")
            return ""
        }
        let startIndex = self.characters.index(self.startIndex, offsetBy: start)
        let endIndex = self.characters.index(self.startIndex, offsetBy: start + location)
        let range = startIndex..<endIndex

        return self.substring(with: range)
    }
}

用法：

let str = "Hello, playground"

let substring1 = str.substringWithRange(0, end: 5) //Hello
let substring2 = str.substringWithRange(7, location: 10) //playground

---

如何在 Swift 2.0 中获取子字符串的示例代码

(i) 起始索引的子串

输入：-

var str = "Swift is very powerful language!"
print(str)

str = str.substringToIndex(str.startIndex.advancedBy(5))
print(str)

输出：-

Swift is very powerful language!
Swift

(ii) 来自特定索引的子串

输入：-

var str = "Swift is very powerful language!"
print(str)

str = str.substringFromIndex(str.startIndex.advancedBy(6)).substringToIndex(str.startIndex.advancedBy(2))
print(str)

输出：-

Swift is very powerful language!
is

我希望它会帮助你！

---

用很少的代码简单的解决方案。

制作一个包含几乎所有其他语言都有的基本 subStringing 的扩展：

extension String {
    func subString(start: Int, end: Int) -> String {
        let startIndex = self.index(self.startIndex, offsetBy: start)
        let endIndex = self.index(startIndex, offsetBy: end)

        let finalString = self.substring(from: startIndex)
        return finalString.substring(to: endIndex)
    }
}

只需调用它

someString.subString(start: 0, end: 6)

---

这适用于我的操场:)

String(seq: Array(str)[2...4])

---

为 Xcode 7 更新。添加字符串扩展：

利用：

var chuck: String = "Hello Chuck Norris"
chuck[6...11] // => Chuck

执行：

extension String {

    /**
     Subscript to allow for quick String substrings ["Hello"][0...1] = "He"
     */
    subscript (r: Range<Int>) -> String {
        get {
            let start = self.startIndex.advancedBy(r.startIndex)
            let end = self.startIndex.advancedBy(r.endIndex - 1)
            return self.substringWithRange(start..<end)
        }
    }

}

---

在操场上试试这个

var str:String = "Hello, playground"

let range = Range(start:advance(str.startIndex,1), end: advance(str.startIndex,8))

它会给你“你好，p”

但是，真正有趣的是，如果您使最后一个索引大于 Playground 中的字符串，它将显示您在 str 之后定义的任何字符串：o

Range() 似乎是一个通用函数，因此它需要知道它正在处理的类型。

您还必须为它提供您对游乐场感兴趣的实际字符串，因为它似乎将所有的字符串一个接一个地保存在一个序列中，然后使用它们的变量名。

所以

var str:String = "Hello, playground"

var str2:String = "I'm the next string"

let range = Range(start:advance(str.startIndex,1), end: advance(str.startIndex,49))

给出“你好，playground�str���我是下一个字符串�str2�”

即使 str2 用 let 定义也有效

:)

---

Rob Napier 已经使用下标给出了一个很棒的答案。但我觉得有一个缺点，因为没有检查越界条件。这可能会崩溃。所以我修改了扩展名，就在这里

extension String {
    subscript (r: Range<Int>) -> String? { //Optional String as return value
        get {
            let stringCount = self.characters.count as Int
            //Check for out of boundary condition
            if (stringCount < r.endIndex) || (stringCount < r.startIndex){
                return nil
            }
            let startIndex = self.startIndex.advancedBy(r.startIndex)

            let endIndex = self.startIndex.advancedBy(r.endIndex - r.startIndex)

            return self[Range(start: startIndex, end: endIndex)]
        }
    }
}

下面的输出

var str2 = "Hello, World"

var str3 = str2[0...5]
//Hello,
var str4 = str2[0..<5]
//Hello
var str5 = str2[0..<15]
//nil

所以我建议总是检查 if let

if let string = str[0...5]
{
    //Manipulate your string safely
}

---

在 Swift3 中

例如：变量“Duke James Thomas”，我们需要得到“James”。

let name = "Duke James Thomas"
let range: Range<String.Index> = name.range(of:"James")!
let lastrange: Range<String.Index> = img.range(of:"Thomas")!
var middlename = name[range.lowerBound..<lstrange.lowerBound]
print (middlename)

---

借鉴 Rob Napier 的经验，我开发了这些 Common String Extensions，其中两个是：

subscript (r: Range<Int>) -> String
{
    get {
        let startIndex = advance(self.startIndex, r.startIndex)
        let endIndex = advance(self.startIndex, r.endIndex - 1)

        return self[Range(start: startIndex, end: endIndex)]
    }
}

func subString(startIndex: Int, length: Int) -> String
{
    var start = advance(self.startIndex, startIndex)
    var end = advance(self.startIndex, startIndex + length)
    return self.substringWithRange(Range<String.Index>(start: start, end: end))
}

用法：

"Awesome"[3...7] //"some"
"Awesome".subString(3, length: 4) //"some"

---

这是从字符串中获取范围的方式：

var str = "Hello, playground"

let startIndex = advance(str.startIndex, 1)
let endIndex = advance(startIndex, 8)
let range = startIndex..<endIndex
let substr = str[range] //"ello, pl"

关键是您传递的是 String.Index 类型的值范围（这是 Advance 返回的值）而不是整数。

这是必要的，因为 Swift 中的字符串没有随机访问（因为基本上 Unicode 字符的长度可变）。你也不能做str[1]。 String.Index 旨在与它们的内部结构一起工作。

不过，您可以创建一个带有下标的扩展，它会为您执行此操作，因此您可以只传递一个整数范围（参见例如 Rob Napier's answer）。

---

我试图想出一些 Pythonic 的东西。

这里所有的下标都很棒，但是我真正需要一些简单的东西的时候通常是我想从后面数，例如 string.endIndex.advancedBy(-1)

它支持开始索引和结束索引的 nil 值，其中 nil 表示开始索引为 0，结束索引为 string.characters.count。

extension String {
    var subString: (Int?) -> (Int?) -> String {
        return { (start) in
            { (end) in
                let startIndex = start ?? 0 < 0 ? self.endIndex.advancedBy(start!) : self.startIndex.advancedBy(start ?? 0)
                let endIndex = end ?? self.characters.count < 0 ? self.endIndex.advancedBy(end!) : self.startIndex.advancedBy(end ?? self.characters.count)

                return startIndex > endIndex ? "" : self.substringWithRange(startIndex ..< endIndex)
            }
        }
    }
}

let dog = "Dog‼🐶"
print(dog.subString(nil)(-1)) // Dog!!

编辑

更优雅的解决方案：

public extension String {
    struct Substring {
        var start: Int?
        var string: String

        public subscript(end: Int?) -> String {
            let startIndex = start ?? 0 < 0 ? string.endIndex.advancedBy(start!) : string.startIndex.advancedBy(start ?? 0)
            let endIndex = end ?? string.characters.count < 0 ? string.endIndex.advancedBy(end!) : string.startIndex.advancedBy(end ?? string.characters.count)

            return startIndex > endIndex ? "" : string.substringWithRange(startIndex ..< endIndex)
        }
    }

    public subscript(start: Int?) -> Substring {
        return Substring(start: start, string: self)
    }
}

let dog = "Dog‼🐶"
print(dog[nil][-1]) // Dog!!

---

首先创建范围，然后创建子字符串。您可以像这样使用 fromIndex..<toIndex 语法：

let range = fullString.startIndex..<fullString.startIndex.advancedBy(15) // 15 first characters of the string
let substring = fullString.substringWithRange(range)

---

这是一个从整个 URL 快速获取 video-Id .ie (6oL687G0Iso) 的示例

let str = "https://www.youtube.com/watch?v=6oL687G0Iso&list=PLKmzL8Ib1gsT-5LN3V2h2H14wyBZTyvVL&index=2"
var arrSaprate = str.componentsSeparatedByString("v=")
let start = arrSaprate[1]
let rangeOfID = Range(start: start.startIndex,end:start.startIndex.advancedBy(11))
let substring = start[rangeOfID]
print(substring)

---

let startIndex = text.startIndex
var range = startIndex.advancedBy(1) ..< text.endIndex.advancedBy(-4)
let substring = text.substringWithRange(range)

您可以看到的完整示例 here

---

http://www.learnswiftonline.com/reference-guides/string-reference-guide-for-swift/ 表明这很有效：

var str = "abcd"
str = str.substringToIndex(1)

---

好吧，我遇到了同样的问题并用“bridgeToObjectiveC()”函数解决了：

var helloworld = "Hello World!"
var world = helloworld.bridgeToObjectiveC().substringWithRange(NSMakeRange(6,6))
println("\(world)") // should print World!

请注意，在示例中，substringWithRange 与 NSMakeRange 结合使用从索引 6 开始（字符“W”）并在索引 6 + 6 位置结束（字符“！”）结束的字符串部分

干杯。

---

您可以在我编写的 Swift 字符串扩展中使用任何子字符串方法 https://bit.ly/JString。

var string = "hello"
var sub = string.substringFrom(3) // or string[3...5]
println(sub)// "lo"

---

如果您有 NSRange，则可以无缝桥接到 NSString。例如，我正在使用 UITextFieldDelegate 做一些工作，当它询问是否应该替换范围时，我很快想计算新的字符串值。

func textField(textField: UITextField, shouldChangeCharactersInRange range: NSRange, replacementString string: String) -> Bool {
    let newString = (textField.text as NSString).stringByReplacingCharactersInRange(range, withString: string)
    println("Got new string: ", newString)
}

---

String 的简单扩展：

extension String {

    func substringToIndex(index: Int) -> String {
        return self[startIndex...startIndex.advancedBy(min(index, characters.count - 1))]
    }
}

---

如果你不关心性能......这可能是 Swift 4 中最简洁的解决方案

extension String {
    subscript(range: CountableClosedRange<Int>) -> String {
        return enumerated().filter{$0.offset >= range.first! && $0.offset < range.last!}
            .reduce(""){$0 + String($1.element)}
    }
}

它使您能够执行以下操作：

let myStr = "abcd"
myStr[0..<2] // produces "ab"

---