Erhalten Sie das n-te Zeichen eines Strings in Swift

Question

Wie kann ich das n-te Zeichen einer Zeichenkette erhalten? Ich habe es mit dem eckigen Klammern ([]) Operator versucht, aber es hat nicht geklappt.

var string = "Hallo, Welt!"

var firstChar = string[0] // Wirft einen Fehler

FEHLER: 'subscript' ist nicht verfügbar: String kann nicht mit einem Int indiziert werden, siehe den Dokumentationskommentar für weitere Informationen

Answer 1

Swift 3

extension String {

    public func charAt(_ i: Int) -> Character {
        return self[self.characters.index(self.startIndex, offsetBy: i)]
    }

    public subscript (i: Int) -> String {
        return String(self.charAt(i) as Character)
    }

    public subscript (r: Range) -> String {
        return substring(with: self.characters.index(self.startIndex, offsetBy: r.lowerBound)..) -> String {
        return substring(with: self.characters.index(self.startIndex, offsetBy: r.lowerBound)..

`

Verwendung

let str = "Hello World"
let sub = str[0...4]

Hilfreiche Programmier-Tipps und Tricks (von mir verfasst)

`

Answer 2

Ich denke, dass eine schnelle Antwort für das erste Zeichen sein könnte:

let firstCharacter = aString[aString.startIndex]

Es ist viel eleganter und leistungsfähiger als:

let firstCharacter = Array(aString.characters).first

Aber.. wenn du Strings manipulieren und mehr Operationen damit durchführen möchtest, könntest du darüber nachdenken, eine Erweiterung zu erstellen..hier ist eine Erweiterung mit diesem Ansatz, die ziemlich ähnlich zu der bereits hier geposteten ist:

extension String {
var length : Int {
    return self.characters.count
}

subscript(integerIndex: Int) -> Character {
    let index = startIndex.advancedBy(integerIndex)
    return self[index]
}

subscript(integerRange: Range) -> String {
    let start = startIndex.advancedBy(integerRange.startIndex)
    let end = startIndex.advancedBy(integerRange.endIndex)
    let range = start..

`

}

ABER ES IST EINE SCHRECKLICHE IDEE!!

Die untenstehende Erweiterung ist furchtbar ineffizient. Jedes Mal, wenn auf einen String mit einem Integer zugegriffen wird, wird eine O(n)-Funktion ausgeführt, um seinen Startindex zu erhöhen. Das Ausführen einer linearen Schleife innerhalb einer anderen linearen Schleife bedeutet, dass diese Schleife versehentlich O(n2) ist - mit zunehmender Länge des Strings steigt die Zeit, die diese Schleife benötigt, quadratisch an.

Anstatt das zu tun, könntest du die Zeichenfolgensammlung des Strings verwenden.

`

Answer 3

Swift 4.2

Diese Antwort ist ideal, weil sie String und all seine Subsequences (Substring) in einer Erweiterung erweitert

public extension StringProtocol {

    public subscript (i: Int) -> Element {
        return self[index(startIndex, offsetBy: i)]
    }

    public subscript (bounds: CountableClosedRange) -> SubSequence {
        let start = index(startIndex, offsetBy: bounds.lowerBound)
        let end = index(startIndex, offsetBy: bounds.upperBound)
        return self[start...end]
    }

    public subscript (bounds: CountableRange) -> SubSequence {
        let start = index(startIndex, offsetBy: bounds.lowerBound)
        let end = index(startIndex, offsetBy: bounds.upperBound)
        return self[start..) -> SubSequence {
        let end = index(startIndex, offsetBy: bounds.upperBound)
        return self[startIndex..) -> SubSequence {
        let end = index(startIndex, offsetBy: bounds.upperBound)
        return self[startIndex...end]
    }

    public subscript (bounds: CountablePartialRangeFrom) -> SubSequence {
        let start = index(startIndex, offsetBy: bounds.lowerBound)
        return self[start..

`### Verwendung

var str = "Hello, playground"

print(str[5...][...5][0])
// Prints ","`

Answer 4

Aktualisierung für Swift 2.0 subString

public extension String {
    public subscript (i: Int) -> String {
        return self.substringWithRange(self.startIndex..) -> String {
        get {
            return self.substringWithRange(self.startIndex.advancedBy(r.startIndex)..

Answer 5

Hier ist eine Erweiterung, die Sie verwenden können, die mit Swift 3.1 funktioniert. Ein einzelner Index gibt ein Character zurück, was intuitiv erscheint, wenn Sie auf einen String indexieren, und ein Range gibt einen String zurück.

extension String {
    subscript (i: Int) -> Character {
        return Array(self.characters)[i]
    }

    subscript (r: CountableClosedRange) -> String {
        return String(Array(self.characters)[r])
    }

    subscript (r: CountableRange) -> String {
        return self[r.lowerBound...r.upperBound-1]
    }
}

Einige Beispiele für die Erweiterung in Aktion:

let string = "Hello"

let c1 = string[1]  // Character "e"
let c2 = string[-1] // Fataler Fehler: Index außerhalb des Bereichs

let r1 = string[1..<4] // String "ell"
let r2 = string[1...4] // String "ello"
let r3 = string[1...5] // Fataler Fehler: Array-Index außerhalb des Bereichs

---

Hinweis: Sie könnten eine zusätzliche Methode zur obigen Erweiterung hinzufügen, um einen String mit einem einzelnen Zeichen zurückzugeben, wenn gewünscht:

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

Beachten Sie, dass Sie dann den Typ explizit angeben müssten, den Sie beim Indexieren des Strings möchten:

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