这是最好最简单的方法之一

        let yourString = "thisString"
        print(Array(yourString)[8])

将字符串中的每个字母放入数组 然后选择第9个

如果你看到不能下标一个类型为'String'的值…使用这个扩展:

斯威夫特3

extension String {
    subscript (i: Int) -> Character {
        return self[self.characters.index(self.startIndex, offsetBy: i)]
    }

    subscript (i: Int) -> String {
        return String(self[i] as Character)
    }

    subscript (r: Range<Int>) -> String {
        let start = index(startIndex, offsetBy: r.lowerBound)
        let end = index(startIndex, offsetBy: r.upperBound)
        return self[start..<end]
    }

    subscript (r: ClosedRange<Int>) -> String {
        let start = index(startIndex, offsetBy: r.lowerBound)
        let end = index(startIndex, offsetBy: r.upperBound)
        return self[start...end]
    }
}

斯威夫特2.3

extension String {
    subscript(integerIndex: Int) -> Character {
        let index = advance(startIndex, integerIndex)
        return self[index]
    }

    subscript(integerRange: Range<Int>) -> String {
        let start = advance(startIndex, integerRange.startIndex)
        let end = advance(startIndex, integerRange.endIndex)
        let range = start..<end
        return self[range]
    }
}

来源:http://oleb.net/blog/2014/07/swift-strings/

这是一个你可以使用的扩展，与Swift 3.1一起工作。单个索引将返回一个字符，这在索引字符串时似乎很直观，而范围将返回一个字符串。

extension String {
    subscript (i: Int) -> Character {
        return Array(self.characters)[i]
    }
    
    subscript (r: CountableClosedRange<Int>) -> String {
        return String(Array(self.characters)[r])
    }
    
    subscript (r: CountableRange<Int>) -> String {
        return self[r.lowerBound...r.upperBound-1]
    }
}

扩展的一些例子:

let string = "Hello"

let c1 = string[1]  // Character "e"
let c2 = string[-1] // fatal error: Index out of range

let r1 = string[1..<4] // String "ell"
let r2 = string[1...4] // String "ello"
let r3 = string[1...5] // fatal error: Array index is out of range

如果需要的话，你可以在上面的扩展中添加一个额外的方法来返回一个包含单个字符的String:

subscript (i: Int) -> String {
    return String(self[i])
}

注意，在索引字符串时，你必须显式地指定你想要的类型:

let c: Character = string[3] // Character "l"
let s: String = string[0]    // String "H"

Swift的String类型没有提供characterAtIndex方法，因为Unicode字符串有几种编码方式。你要用UTF8, UTF16，还是别的?

您可以通过检索String来访问CodeUnit集合。utf8和String。utf16属性。您还可以通过检索String来访问UnicodeScalar集合。unicodeScalars财产。

在NSString实现的精神中，我返回一个unichar类型。

extension String
{
    func characterAtIndex(index:Int) -> unichar
    {
        return self.utf16[index]
    }

    // Allows us to use String[index] notation
    subscript(index:Int) -> unichar
    {
        return characterAtIndex(index)
    }
}

let text = "Hello Swift!"
let firstChar = text[0]

斯威夫特4

String(Array(stringToIndex)[index]) 

这可能是一次性解决这个问题的最好方法。您可能希望首先将String转换为数组，然后再将结果转换为String。否则，将返回字符而不是字符串。

示例String(Array("HelloThere")[1])将返回"e"作为字符串。

(数组("HelloThere")[1]将返回"e"作为字符。

Swift不允许字符串像数组一样被索引，但这就完成了工作，用蛮力的方式。

斯威夫特3:

extension String {
    func substring(fromPosition: UInt, toPosition: UInt) -> String? {
        guard fromPosition <= toPosition else {
            return nil
        }

        guard toPosition < UInt(characters.count) else {
            return nil
        }

        let start = index(startIndex, offsetBy: String.IndexDistance(fromPosition))
        let end   = index(startIndex, offsetBy: String.IndexDistance(toPosition) + 1)
        let range = start..<end

        return substring(with: range)
    }
}

"ffaabbcc".substring(fromPosition: 2, toPosition: 5) // return "aabb"