Wie kann ich das n-te Zeichen einer Zeichenfolge erhalten? Ich habe versucht, Bracket ( []) Accessor ohne Glück.

var string = "Hello, world!"

var firstChar = string[0] // Throws error

FEHLER: 'tiefgestellt' ist nicht verfügbar: Zeichenkette kann nicht mit einem Int abonniert werden. Weitere Informationen finden Sie im Dokumentationskommentar

Achtung: Bitte beachten Sie Leo Dabus' Antwort für eine ordnungsgemäße Durchführung für Swift 4 und Swift 5.

Swift 4 oder höher

Der SubstringTyp wurde in Swift 4 eingeführt, um Teilzeichenfolgen schneller und effizienter zu machen, indem der Speicher mit der ursprünglichen Zeichenfolge geteilt wird. Daher sollten die Indexfunktionen dies zurückgeben.

Probieren Sie es hier aus

extension StringProtocol {
    subscript(offset: Int) -> Character { self[index(startIndex, offsetBy: offset)] }
    subscript(range: Range<Int>) -> SubSequence {
        let startIndex = index(self.startIndex, offsetBy: range.lowerBound)
        return self[startIndex..<index(startIndex, offsetBy: range.count)]
    }
    subscript(range: ClosedRange<Int>) -> SubSequence {
        let startIndex = index(self.startIndex, offsetBy: range.lowerBound)
        return self[startIndex..<index(startIndex, offsetBy: range.count)]
    }
    subscript(range: PartialRangeFrom<Int>) -> SubSequence { self[index(startIndex, offsetBy: range.lowerBound)...] }
    subscript(range: PartialRangeThrough<Int>) -> SubSequence { self[...index(startIndex, offsetBy: range.upperBound)] }
    subscript(range: PartialRangeUpTo<Int>) -> SubSequence { self[..<index(startIndex, offsetBy: range.upperBound)] }
}

Um das Substringin ein zu konvertieren String, können Sie dies einfach tun String(string[0..2]), aber Sie sollten dies nur tun, wenn Sie vorhaben, die Teilzeichenfolge beizubehalten. Ansonsten ist es effizienter, es zu behalten Substring.

Es wäre großartig, wenn jemand einen guten Weg finden könnte, diese beiden Erweiterungen zu einer zusammenzuführen. Ich habe versucht, StringProtocol ohne Erfolg zu erweitern, da die indexMethode dort nicht existiert. Hinweis: Diese Antwort wurde bereits bearbeitet, ist ordnungsgemäß implementiert und funktioniert jetzt auch für Teilzeichenfolgen. Stellen Sie einfach sicher, dass Sie einen gültigen Bereich verwenden, um Abstürze beim Abonnieren Ihres StringProtocol-Typs zu vermeiden. Für die Subskription mit einem Bereich, der nicht mit Werten außerhalb des Bereichs abstürzt, können Sie diese Implementierung verwenden

Warum ist das nicht eingebaut?

Die Fehlermeldung lautet "Siehe den Dokumentationskommentar zur Diskussion" . Apple bietet die folgende Erklärung in der Datei UnavailableStringAPIs.swift :

Das Abonnieren von Zeichenfolgen mit Ganzzahlen ist nicht verfügbar.

Das Konzept des " ith-Zeichens in einer Zeichenfolge" hat unterschiedliche Interpretationen in verschiedenen Bibliotheken und Systemkomponenten. Die richtige Interpretation sollte entsprechend dem Anwendungsfall und den beteiligten APIs ausgewählt werden, daher String kann keine Ganzzahl verwendet werden.

Swift bietet verschiedene Möglichkeiten, auf die in Zeichenfolgen gespeicherten Zeichendaten zuzugreifen.

• String.utf8ist eine Sammlung von UTF-8-Codeeinheiten in der Zeichenfolge. Verwenden Sie diese API, wenn Sie die Zeichenfolge in UTF-8 konvertieren. Die meisten POSIX-APIs verarbeiten Zeichenfolgen in UTF-8-Codeeinheiten.

• String.utf16ist eine Sammlung von UTF-16-Codeeinheiten in Zeichenfolge. Die meisten Cocoa- und Cocoa-Touch-APIs verarbeiten Zeichenfolgen in UTF-16-Codeeinheiten. Zum Beispiel Instanzen von NSRangemit NSAttributedStringund NSRegularExpressionSpeichern von Teilzeichenfolgen-Offsets und -Längen in Form von UTF-16-Codeeinheiten.

• String.unicodeScalarsist eine Sammlung von Unicode-Skalaren. Verwenden Sie diese API, wenn Sie Zeichendaten auf niedriger Ebene bearbeiten.

• String.characters ist eine Sammlung erweiterter Graphemcluster, die eine Annäherung an vom Benutzer wahrgenommene Zeichen darstellen.

Beachten Sie, dass bei der Verarbeitung von Zeichenfolgen, die für Menschen lesbaren Text enthalten, die Verarbeitung von Zeichen zu Zeichen so weit wie möglich vermieden werden sollte. Verwenden Sie High-Level - locale-sensitive Unicode Algorithmen statt, zum Beispiel String.localizedStandardCompare(), String.localizedLowercaseString, String.localizedStandardRangeOfString()usw.

Swift 5.2

let str = "abcdef"
str[1 ..< 3] // returns "bc"
str[5] // returns "f"
str[80] // returns ""
str.substring(fromIndex: 3) // returns "def"
str.substring(toIndex: str.length - 2) // returns "abcd"

Sie müssen diese String-Erweiterung zu Ihrem Projekt hinzufügen (es ist vollständig getestet):

extension String {

    var length: Int {
        return count
    }

    subscript (i: Int) -> String {
        return self[i ..< i + 1]
    }

    func substring(fromIndex: Int) -> String {
        return self[min(fromIndex, length) ..< length]
    }

    func substring(toIndex: Int) -> String {
        return self[0 ..< max(0, toIndex)]
    }

    subscript (r: Range<Int>) -> String {
        let range = Range(uncheckedBounds: (lower: max(0, min(length, r.lowerBound)),
                                            upper: min(length, max(0, r.upperBound))))
        let start = index(startIndex, offsetBy: range.lowerBound)
        let end = index(start, offsetBy: range.upperBound - range.lowerBound)
        return String(self[start ..< end])
    }
}

Auch wenn Swift für dieses Problem immer eine sofort einsatzbereite Lösung hatte (ohne die unten angegebene String-Erweiterung), würde ich die Verwendung der Erweiterung nachdrücklich empfehlen . Warum? Weil es mir Dutzende Stunden schmerzhafter Migration von früheren Versionen von Swift erspart hat, bei denen die Syntax von String fast jede Version geändert hat, aber alles, was ich tun musste, war, die Implementierung der Erweiterung zu aktualisieren, anstatt das gesamte Projekt umzugestalten. Treffen Sie Ihre Wahl.

let str = "Hello, world!"
let index = str.index(str.startIndex, offsetBy: 4)
str[index] // returns Character 'o'

let endIndex = str.index(str.endIndex, offsetBy:-2)
str[index ..< endIndex] // returns String "o, worl"

String(str.suffix(from: index)) // returns String "o, world!"
String(str.prefix(upTo: index)) // returns String "Hell"

Ich habe mir gerade diese nette Problemumgehung ausgedacht

var firstChar = Array(string)[0]

Keine Indizierung mit ganzen Zahlen, nur mit String.Index. Meist mit linearer Komplexität. Sie können damit auch Bereiche erstellen String.Indexund Teilzeichenfolgen abrufen.

Swift 3.0

let firstChar = someString[someString.startIndex]
let lastChar = someString[someString.index(before: someString.endIndex)]
let charAtIndex = someString[someString.index(someString.startIndex, offsetBy: 10)]

let range = someString.startIndex..<someString.index(someString.startIndex, offsetBy: 10)
let substring = someString[range]

Swift 2.x.

let firstChar = someString[someString.startIndex]
let lastChar = someString[someString.endIndex.predecessor()]
let charAtIndex = someString[someString.startIndex.advanceBy(10)]

let range = someString.startIndex..<someString.startIndex.advanceBy(10)
let subtring = someString[range]

Beachten Sie, dass Sie niemals einen Index (oder Bereich) verwenden können, der von einer Zeichenfolge zu einer anderen Zeichenfolge erstellt wurde

let index10 = someString.startIndex.advanceBy(10)

//will compile
//sometimes it will work but sometimes it will crash or result in undefined behaviour
let charFromAnotherString = anotherString[index10]

Xcode 11 • Swift 5.1

Sie können StringProtocol erweitern, um den Index auch für die Teilzeichenfolgen verfügbar zu machen:

extension StringProtocol {
    subscript(_ offset: Int)                     -> Element     { self[index(startIndex, offsetBy: offset)] }
    subscript(_ range: Range<Int>)               -> SubSequence { prefix(range.lowerBound+range.count).suffix(range.count) }
    subscript(_ range: ClosedRange<Int>)         -> SubSequence { prefix(range.lowerBound+range.count).suffix(range.count) }
    subscript(_ range: PartialRangeThrough<Int>) -> SubSequence { prefix(range.upperBound.advanced(by: 1)) }
    subscript(_ range: PartialRangeUpTo<Int>)    -> SubSequence { prefix(range.upperBound) }
    subscript(_ range: PartialRangeFrom<Int>)    -> SubSequence { suffix(Swift.max(0, count-range.lowerBound)) }
}

extension LosslessStringConvertible {
    var string: String { .init(self) }
}

extension BidirectionalCollection {
    subscript(safe offset: Int) -> Element? {
        guard !isEmpty, let i = index(startIndex, offsetBy: offset, limitedBy: index(before: endIndex)) else { return nil }
        return self[i]
    }
}

Testen

let test = "Hello USA 🇺🇸!!! Hello Brazil 🇧🇷!!!"
test[safe: 10]   // "🇺🇸"
test[11]   // "!"
test[10...]   // "🇺🇸!!! Hello Brazil 🇧🇷!!!"
test[10..<12]   // "🇺🇸!"
test[10...12]   // "🇺🇸!!"
test[...10]   // "Hello USA 🇺🇸"
test[..<10]   // "Hello USA "
test.first   // "H"
test.last    // "!"

// Subscripting the Substring
 test[...][...3]  // "Hell"

// Note that they all return a Substring of the original String.
// To create a new String from a substring
test[10...].string  // "🇺🇸!!! Hello Brazil 🇧🇷!!!"

Swift 4

let str = "My String"

Zeichenfolge am Index

let index = str.index(str.startIndex, offsetBy: 3)
String(str[index])    // "S"

Teilstring

let startIndex = str.index(str.startIndex, offsetBy: 3)
let endIndex = str.index(str.startIndex, offsetBy: 7)
String(str[startIndex...endIndex])     // "Strin"

Erste n Zeichen

let startIndex = str.index(str.startIndex, offsetBy: 3)
String(str[..<startIndex])    // "My "

Letzte n Zeichen

let startIndex = str.index(str.startIndex, offsetBy: 3)
String(str[startIndex...])    // "String"

Swift 2 und 3

str = "My String"

** String am Index **

Swift 2

let charAtIndex = String(str[str.startIndex.advancedBy(3)])  // charAtIndex = "S"

Swift 3

str[str.index(str.startIndex, offsetBy: 3)]

SubString fromIndex toIndex

Swift 2

let subStr = str[str.startIndex.advancedBy(3)...str.startIndex.advancedBy(7)] // subStr = "Strin"

Swift 3

str[str.index(str.startIndex, offsetBy: 3)...str.index(str.startIndex, offsetBy: 7)]

Erste n Zeichen

let first2Chars = String(str.characters.prefix(2)) // first2Chars = "My"

Letzte n Zeichen

let last3Chars = String(str.characters.suffix(3)) // last3Chars = "ing"

Swift 2.0 ab Xcode 7 GM Seed

var text = "Hello, world!"

let firstChar = text[text.startIndex.advancedBy(0)] // "H"

Ersetzen Sie für das n-te Zeichen 0 durch n-1.

Bearbeiten: Swift 3.0

text[text.index(text.startIndex, offsetBy: 0)]

nb Es gibt einfachere Möglichkeiten, bestimmte Zeichen in der Zeichenfolge zu erfassen

z.B let firstChar = text.characters.first

Wenn Sie sehen, Cannot subscript a value of type 'String'...verwenden Sie diese Erweiterung:

Swift 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]
    }
}

Swift 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]
    }
}

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

Swift 2.2 Lösung:

Die folgende Erweiterung funktioniert in Xcode 7, dies ist eine Kombination aus dieser Lösung und der Swift 2.0-Syntaxkonvertierung.

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

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

Die Swift-String-Klasse bietet aufgrund ihrer nativen Unterstützung für UTF-Zeichen keine Möglichkeit, ein Zeichen an einem bestimmten Index abzurufen. Die variable Länge eines UTF-Zeichens im Speicher macht es unmöglich, direkt zu einem Zeichen zu springen. Das bedeutet, dass Sie die Zeichenfolge jedes Mal manuell durchlaufen müssen.

Sie können String erweitern, um eine Methode bereitzustellen, die die Zeichen bis zu Ihrem gewünschten Index durchläuft

extension String {
    func characterAtIndex(index: Int) -> Character? {
        var cur = 0
        for char in self {
            if cur == index {
                return char
            }
            cur++
        }
        return nil
    }
}

myString.characterAtIndex(0)!

Nebenbei bemerkt, es gibt einige Funktionen, die direkt auf die Zeichenkettendarstellung eines Strings anwendbar sind:

var string = "Hello, playground"
let firstCharacter = string.characters.first // returns "H"
let lastCharacter = string.characters.last // returns "d"

Das Ergebnis ist vom Typ Character, aber Sie können es in einen String umwandeln.

Oder dieses:

let reversedString = String(string.characters.reverse())
// returns "dnuorgyalp ,olleH" 

:-)

Swift 4

String(Array(stringToIndex)[index]) 

Dies ist wahrscheinlich der beste Weg, um dieses Problem einmalig zu lösen. Sie möchten den String wahrscheinlich zuerst als Array und dann erneut als String umwandeln. Andernfalls wird anstelle eines Strings ein Zeichen zurückgegeben.

Beispiel String(Array("HelloThere")[1])gibt "e" als String zurück.

(Array("HelloThere")[1] gibt "e" als Zeichen zurück.

Swift erlaubt es nicht, Strings wie Arrays zu indizieren, aber dies erledigt den Job im Brute-Force-Stil.

Meine sehr einfache Lösung:

Swift 4.1:

let myString = "Test string"
let index = 0
let firstCharacter = myString[String.Index(encodedOffset: index)]

Swift 5.1:

let firstCharacter = myString[String.Index.init(utf16Offset: index, in: myString)]

Sie können dies tun, indem Sie String in Array konvertieren und ihn anhand eines Index gemäß dem folgenden Index abrufen

var str = "Hello"
let s = Array(str)[2]
print(s)

Ich hatte gerade das gleiche Problem. Mach das einfach:

var aString: String = "test"
var aChar:unichar = (aString as NSString).characterAtIndex(0)

Swift3

Sie können die tiefgestellte Syntax verwenden, um auf das Zeichen an einem bestimmten Zeichenfolgenindex zuzugreifen.

let greeting = "Guten Tag!"
let index = greeting.index(greeting.startIndex, offsetBy: 7)
greeting[index] // a

Besuch https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/StringsAndCharacters.html

oder wir können eine String-Erweiterung in Swift 4 durchführen

extension String {
    func getCharAtIndex(_ index: Int) -> Character {
        return self[self.index(self.startIndex, offsetBy: index)]
    }
}

VERWENDUNGSZWECK:

let foo = "ABC123"
foo.getCharAtIndex(2) //C

Meine Lösung ist in einer Zeile, vorausgesetzt, Kadena ist die Zeichenfolge und 4 ist die n-te Position, die Sie möchten:

let character = cadena[advance(cadena.startIndex, 4)]

Einfach ... Ich nehme an, Swift wird in zukünftigen Versionen mehr über Teilzeichenfolgen enthalten.

Swift 3: eine andere Lösung (auf dem Spielplatz getestet)

extension String {
    func substr(_ start:Int, length:Int=0) -> String? {
        guard start > -1 else {
            return nil
        }

        let count = self.characters.count - 1

        guard start <= count else {
            return nil
        }

        let startOffset = max(0, start)
        let endOffset = length > 0 ? min(count, startOffset + length - 1) : count

        return self[self.index(self.startIndex, offsetBy: startOffset)...self.index(self.startIndex, offsetBy: endOffset)]
    }
}

Verwendungszweck:

let txt = "12345"

txt.substr(-1) //nil
txt.substr(0) //"12345"
txt.substr(0, length: 0) //"12345"
txt.substr(1) //"2345"
txt.substr(2) //"345"
txt.substr(3) //"45"
txt.substr(4) //"5"
txt.substr(6) //nil
txt.substr(0, length: 1) //"1"
txt.substr(1, length: 1) //"2"
txt.substr(2, length: 1) //"3"
txt.substr(3, length: 1) //"4"
txt.substr(3, length: 2) //"45"
txt.substr(3, length: 3) //"45"
txt.substr(4, length: 1) //"5"
txt.substr(4, length: 2) //"5"
txt.substr(5, length: 1) //nil
txt.substr(5, length: -1) //nil
txt.substr(-1, length: -1) //nil

Update für Swift 2.0 SubString

public extension String {
    public subscript (i: Int) -> String {
        return self.substringWithRange(self.startIndex..<self.startIndex.advancedBy(i + 1))
    }

    public subscript (r: Range<Int>) -> String {
        get {
            return self.substringWithRange(self.startIndex.advancedBy(r.startIndex)..<self.startIndex.advancedBy(r.endIndex))
        }
    }

}

Ich denke, dass eine schnelle Antwort für den ersten Charakter sein könnte:

let firstCharacter = aString[aString.startIndex]

Es ist so viel eleganter und leistungsfähiger als:

let firstCharacter = Array(aString.characters).first

Aber ... wenn Sie manipulieren und mehr Operationen mit Zeichenfolgen ausführen möchten, könnten Sie denken, dass Sie eine Erweiterung erstellen. Es gibt eine Erweiterung mit diesem Ansatz, die der bereits hier veröffentlichten ziemlich ähnlich 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<Int>) -> String {
    let start = startIndex.advancedBy(integerRange.startIndex)
    let end = startIndex.advancedBy(integerRange.endIndex)
    let range = start..<end
    return self[range]
}

}}

ABER ES IST EINE SCHRECKLICHE IDEE !!

Die Erweiterung unten ist schrecklich ineffizient. Jedes Mal, wenn auf eine Zeichenfolge mit einer Ganzzahl zugegriffen wird, wird eine O (n) -Funktion zum Vorrücken des Startindex ausgeführt. Das Ausführen einer linearen Schleife innerhalb einer anderen linearen Schleife bedeutet, dass diese for-Schleife versehentlich O (n2) ist. Mit zunehmender Länge der Zeichenfolge nimmt die Zeit, die diese Schleife benötigt, quadratisch zu.

Stattdessen können Sie die Zeichenfolgensammlung der Zeichen verwenden.

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<Int>) -> String {
        return substring(with: self.characters.index(self.startIndex, offsetBy: r.lowerBound)..<self.characters.index(self.startIndex, offsetBy: r.upperBound))
    }

    public subscript (r: CountableClosedRange<Int>) -> String {
        return substring(with: self.characters.index(self.startIndex, offsetBy: r.lowerBound)..<self.characters.index(self.startIndex, offsetBy: r.upperBound))
    }

}

Verwendungszweck

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

Hilfreiche Tipps und Tricks zur Programmierung (von mir geschrieben)

Index abrufen und festlegen (String & Teilzeichenfolge) - Swift 4.2

Swift 4.2, Xcode 10

Ich habe meine Antwort auf die Antwort von @alecarlson gestützt . Der einzige große Unterschied besteht darin, dass Sie eine Substringoder eine StringRückgabe (und in einigen Fällen eine einzelne Character) erhalten können. Sie können auch getund setden Index. Schließlich ist meine etwas umständlicher und länger als die Antwort von @alecarlson , und als solche schlage ich vor, dass Sie sie in eine Quelldatei einfügen .

Erweiterung:

public extension String {
    public subscript (i: Int) -> Character {
        get {
            return self[index(startIndex, offsetBy: i)]
        }
        set (c) {
            let n = index(startIndex, offsetBy: i)
            replaceSubrange(n...n, with: "\(c)")
        }
    }
    public subscript (bounds: CountableRange<Int>) -> Substring {
        get {
            let start = index(startIndex, offsetBy: bounds.lowerBound)
            let end = index(startIndex, offsetBy: bounds.upperBound)
            return self[start ..< end]
        }
        set (s) {
            let start = index(startIndex, offsetBy: bounds.lowerBound)
            let end = index(startIndex, offsetBy: bounds.upperBound)
            replaceSubrange(start ..< end, with: s)
        }
    }
    public subscript (bounds: CountableClosedRange<Int>) -> Substring {
        get {
            let start = index(startIndex, offsetBy: bounds.lowerBound)
            let end = index(startIndex, offsetBy: bounds.upperBound)
            return self[start ... end]
        }
        set (s) {
            let start = index(startIndex, offsetBy: bounds.lowerBound)
            let end = index(startIndex, offsetBy: bounds.upperBound)
            replaceSubrange(start ... end, with: s)
        }

    }
    public subscript (bounds: CountablePartialRangeFrom<Int>) -> Substring {
        get {
            let start = index(startIndex, offsetBy: bounds.lowerBound)
            let end = index(endIndex, offsetBy: -1)
            return self[start ... end]
        }
        set (s) {
            let start = index(startIndex, offsetBy: bounds.lowerBound)
            let end = index(endIndex, offsetBy: -1)
            replaceSubrange(start ... end, with: s)
        }
    }
    public subscript (bounds: PartialRangeThrough<Int>) -> Substring {
        get {
            let end = index(startIndex, offsetBy: bounds.upperBound)
            return self[startIndex ... end]
        }
        set (s) {
            let end = index(startIndex, offsetBy: bounds.upperBound)
            replaceSubrange(startIndex ... end, with: s)
        }
    }
    public subscript (bounds: PartialRangeUpTo<Int>) -> Substring {
        get {
            let end = index(startIndex, offsetBy: bounds.upperBound)
            return self[startIndex ..< end]
        }
        set (s) {
            let end = index(startIndex, offsetBy: bounds.upperBound)
            replaceSubrange(startIndex ..< end, with: s)
        }
    }

    public subscript (i: Int) -> String {
        get {
            return "\(self[index(startIndex, offsetBy: i)])"
        }
        set (c) {
            let n = index(startIndex, offsetBy: i)
            self.replaceSubrange(n...n, with: "\(c)")
        }
    }
    public subscript (bounds: CountableRange<Int>) -> String {
        get {
            let start = index(startIndex, offsetBy: bounds.lowerBound)
            let end = index(startIndex, offsetBy: bounds.upperBound)
            return "\(self[start ..< end])"
        }
        set (s) {
            let start = index(startIndex, offsetBy: bounds.lowerBound)
            let end = index(startIndex, offsetBy: bounds.upperBound)
            replaceSubrange(start ..< end, with: s)
        }
    }
    public subscript (bounds: CountableClosedRange<Int>) -> String {
        get {
            let start = index(startIndex, offsetBy: bounds.lowerBound)
            let end = index(startIndex, offsetBy: bounds.upperBound)
            return "\(self[start ... end])"
        }
        set (s) {
            let start = index(startIndex, offsetBy: bounds.lowerBound)
            let end = index(startIndex, offsetBy: bounds.upperBound)
            replaceSubrange(start ... end, with: s)
        }

    }
    public subscript (bounds: CountablePartialRangeFrom<Int>) -> String {
        get {
            let start = index(startIndex, offsetBy: bounds.lowerBound)
            let end = index(endIndex, offsetBy: -1)
            return "\(self[start ... end])"
        }
        set (s) {
            let start = index(startIndex, offsetBy: bounds.lowerBound)
            let end = index(endIndex, offsetBy: -1)
            replaceSubrange(start ... end, with: s)
        }
    }
    public subscript (bounds: PartialRangeThrough<Int>) -> String {
        get {
            let end = index(startIndex, offsetBy: bounds.upperBound)
            return "\(self[startIndex ... end])"
        }
        set (s) {
            let end = index(startIndex, offsetBy: bounds.upperBound)
            replaceSubrange(startIndex ... end, with: s)
        }
    }
    public subscript (bounds: PartialRangeUpTo<Int>) -> String {
        get {
            let end = index(startIndex, offsetBy: bounds.upperBound)
            return "\(self[startIndex ..< end])"
        }
        set (s) {
            let end = index(startIndex, offsetBy: bounds.upperBound)
            replaceSubrange(startIndex ..< end, with: s)
        }
    }

    public subscript (i: Int) -> Substring {
        get {
            return Substring("\(self[index(startIndex, offsetBy: i)])")
        }
        set (c) {
            let n = index(startIndex, offsetBy: i)
            replaceSubrange(n...n, with: "\(c)")
        }
    }
}
public extension Substring {
    public subscript (i: Int) -> Character {
        get {
            return self[index(startIndex, offsetBy: i)]
        }
        set (c) {
            let n = index(startIndex, offsetBy: i)
            replaceSubrange(n...n, with: "\(c)")
        }

    }
    public subscript (bounds: CountableRange<Int>) -> Substring {
        get {
            let start = index(startIndex, offsetBy: bounds.lowerBound)
            let end = index(startIndex, offsetBy: bounds.upperBound)
            return self[start ..< end]
        }
        set (s) {
            let start = index(startIndex, offsetBy: bounds.lowerBound)
            let end = index(startIndex, offsetBy: bounds.upperBound)
            replaceSubrange(start ..< end, with: s)
        }
    }
    public subscript (bounds: CountableClosedRange<Int>) -> Substring {
        get {
            let start = index(startIndex, offsetBy: bounds.lowerBound)
            let end = index(startIndex, offsetBy: bounds.upperBound)
            return self[start ... end]
        }
        set (s) {
            let start = index(startIndex, offsetBy: bounds.lowerBound)
            let end = index(startIndex, offsetBy: bounds.upperBound)
            replaceSubrange(start ... end, with: s)
        }
    }
    public subscript (bounds: CountablePartialRangeFrom<Int>) -> Substring {
        get {
            let start = index(startIndex, offsetBy: bounds.lowerBound)
            let end = index(endIndex, offsetBy: -1)
            return self[start ... end]
        }
        set (s) {
            let start = index(startIndex, offsetBy: bounds.lowerBound)
            let end = index(endIndex, offsetBy: -1)
            replaceSubrange(start ... end, with: s)
        }

    }
    public subscript (bounds: PartialRangeThrough<Int>) -> Substring {
        get {
            let end = index(startIndex, offsetBy: bounds.upperBound)
            return self[startIndex ... end]
        }
        set (s) {
            let end = index(startIndex, offsetBy: bounds.upperBound)
            replaceSubrange(startIndex ..< end, with: s)
        }
    }
    public subscript (bounds: PartialRangeUpTo<Int>) -> Substring {
        get {
            let end = index(startIndex, offsetBy: bounds.upperBound)
            return self[startIndex ..< end]
        }
        set (s) {
            let end = index(startIndex, offsetBy: bounds.upperBound)
            replaceSubrange(startIndex ..< end, with: s)
        }
    }
    public subscript (i: Int) -> String {
        get {
            return "\(self[index(startIndex, offsetBy: i)])"
        }
        set (c) {
            let n = index(startIndex, offsetBy: i)
            replaceSubrange(n...n, with: "\(c)")
        }
    }
    public subscript (bounds: CountableRange<Int>) -> String {
        get {
            let start = index(startIndex, offsetBy: bounds.lowerBound)
            let end = index(startIndex, offsetBy: bounds.upperBound)
            return "\(self[start ..< end])"
        }
        set (s) {
            let start = index(startIndex, offsetBy: bounds.lowerBound)
            let end = index(startIndex, offsetBy: bounds.upperBound)
            replaceSubrange(start ..< end, with: s)
        }
    }
    public subscript (bounds: CountableClosedRange<Int>) -> String {
        get {
            let start = index(startIndex, offsetBy: bounds.lowerBound)
            let end = index(startIndex, offsetBy: bounds.upperBound)
            return "\(self[start ... end])"
        }
        set (s) {
            let start = index(startIndex, offsetBy: bounds.lowerBound)
            let end = index(startIndex, offsetBy: bounds.upperBound)
            replaceSubrange(start ... end, with: s)
        }

    }
    public subscript (bounds: CountablePartialRangeFrom<Int>) -> String {
        get {
            let start = index(startIndex, offsetBy: bounds.lowerBound)
            let end = index(endIndex, offsetBy: -1)
            return "\(self[start ... end])"
        }
        set (s) {
            let start = index(startIndex, offsetBy: bounds.lowerBound)
            let end = index(endIndex, offsetBy: -1)
            replaceSubrange(start ... end, with: s)
        }
    }
    public subscript (bounds: PartialRangeThrough<Int>) -> String {
        get {
            let end = index(startIndex, offsetBy: bounds.upperBound)
            return "\(self[startIndex ... end])"
        }
        set (s) {
            let end = index(startIndex, offsetBy: bounds.upperBound)
            replaceSubrange(startIndex ... end, with: s)
        }
    }
    public subscript (bounds: PartialRangeUpTo<Int>) -> String {
        get {
            let end = index(startIndex, offsetBy: bounds.upperBound)
            return "\(self[startIndex ..< end])"
        }
        set (s) {
            let end = index(startIndex, offsetBy: bounds.upperBound)
            replaceSubrange(startIndex ..< end, with: s)
        }
    }

    public subscript (i: Int) -> Substring {
        get {
            return Substring("\(self[index(startIndex, offsetBy: i)])")
        }
        set (c) {
            let n = index(startIndex, offsetBy: i)
            replaceSubrange(n...n, with: "\(c)")
        }
    }
}

Swift 4.2

Diese Antwort ist ideal, weil sie Stringalle Subsequences( Substring) in einer Erweiterung erweitert

public extension StringProtocol {

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

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

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

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

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

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

Verwendungszweck

var str = "Hello, playground"

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

Inzwischen ist der Index (_ :) nicht verfügbar. Sowie wir das nicht können

str[0] 

mit string.Wir müssen "String.Index" angeben. Aber wie können wir auf diese Weise unsere eigene Indexnummer angeben, stattdessen können wir verwenden:

string[str.index(str.startIndex, offsetBy: 0)]

Swift 4.2 oder höher

Bereichs- und Teilbereichsabonnement mit String'sindices Eigenschaft

Als Variation der netten Antwort von @LeoDabus können wir eine zusätzliche Erweiterung hinzufügen, um DefaultIndicesbei der Implementierung der benutzerdefinierten Indizes (nach speziellen Bereichen und Teilbereichen) für letztere auf die indicesEigenschaft zurückgreifen zu können .StringInt

extension DefaultIndices {
    subscript(at: Int) -> Elements.Index { index(startIndex, offsetBy: at) }
}

// Moving the index(_:offsetBy:) to an extension yields slightly
// briefer implementations for these String extensions.
extension String {
    subscript(range: Range<Int>) -> SubSequence {
        let start = indices[range.lowerBound]
        return self[start..<indices[start...][range.count]]
    }
    subscript(range: ClosedRange<Int>) -> SubSequence {
        let start = indices[range.lowerBound]
        return self[start...indices[start...][range.count]]
    }
    subscript(range: PartialRangeFrom<Int>) -> SubSequence {
        self[indices[range.lowerBound]...]
    }
    subscript(range: PartialRangeThrough<Int>) -> SubSequence {
        self[...indices[range.upperBound]]
    }
    subscript(range: PartialRangeUpTo<Int>) -> SubSequence {
        self[..<indices[range.upperBound]]
    }
}

let str = "foo bar baz bax"
print(str[4..<6]) // "ba"
print(str[4...6]) // "bar"
print(str[4...])  // "bar baz bax"
print(str[...6])  // "foo bar"
print(str[..<6])  // "foo ba"

Vielen Dank an @LeoDabus für den Hinweis, dass ich die indicesEigenschaft als (andere) Alternative zum StringAbonnieren verwenden soll!

Swift 5.1.3:

Fügen Sie eine String-Erweiterung hinzu:

extension String {

 func stringAt(_ i: Int) -> String { 
   return String(Array(self)[i]) 
 } 

 func charAt(_ i: Int) -> Character { 
  return Array(self)[i] 
 } 
}

let str = "Teja Kumar"
let str1: String = str.stringAt(2)  //"j"
let str2: Character = str.charAt(5)  //"k"

Swifts StringTyp bietet keinecharacterAtIndex Methode, da eine Unicode-Zeichenfolge auf verschiedene Arten codiert werden kann. Gehst du mit UTF8, UTF16 oder etwas anderem?

Sie können auf die CodeUnitSammlungen zugreifen, indem Sie die Eigenschaften String.utf8und String.utf16abrufen. Sie können auch auf die UnicodeScalarSammlung zugreifen, indem Sie die abrufenString.unicodeScalars Eigenschaft .

Im Geiste der NSStringImplementierung gebe ich einen unicharTyp zurück.

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]

Um das Thema zu füttern und schnelle Indexmöglichkeiten aufzuzeigen, finden Sie hier eine kleine Zeichenfolge, die auf dem Index "substring-toolbox" basiert

Diese Methoden sind sicher und gehen niemals über String-Indizes

extension String {
    // string[i] -> one string char
    subscript(pos: Int) -> String { return String(Array(self)[min(self.length-1,max(0,pos))]) }

    // string[pos,len] -> substring from pos for len chars on the left
    subscript(pos: Int, len: Int) -> String { return self[pos, len, .pos_len, .left2right] }

    // string[pos, len, .right2left] -> substring from pos for len chars on the right
    subscript(pos: Int, len: Int, way: Way) -> String { return self[pos, len, .pos_len, way] }

    // string[range] -> substring form start pos on the left to end pos on the right
    subscript(range: Range<Int>) -> String { return self[range.startIndex, range.endIndex, .start_end, .left2right] }

    // string[range, .right2left] -> substring start pos on the right to end pos on the left
    subscript(range: Range<Int>, way: Way) -> String { return self[range.startIndex, range.endIndex, .start_end, way] }

    var length: Int { return countElements(self) }
    enum Mode { case pos_len, start_end }
    enum Way { case left2right, right2left }
    subscript(var val1: Int, var val2: Int, mode: Mode, way: Way) -> String {
        if mode == .start_end {
            if val1 > val2 { let val=val1 ; val1=val2 ; val2=val }
            val2 = val2-val1
        }
        if way == .left2right {
            val1 = min(self.length-1, max(0,val1))
            val2 = min(self.length-val1, max(1,val2))
        } else {
            let val1_ = val1
            val1 = min(self.length-1, max(0, self.length-val1_-val2 ))
            val2 = max(1, (self.length-1-val1_)-(val1-1) )
        }
        return self.bridgeToObjectiveC().substringWithRange(NSMakeRange(val1, val2))

        //-- Alternative code without bridge --
        //var range: Range<Int> = pos...(pos+len-1)
        //var start = advance(startIndex, range.startIndex)
        //var end = advance(startIndex, range.endIndex)
        //return self.substringWithRange(Range(start: start, end: end))
    }
}


println("0123456789"[3]) // return "3"

println("0123456789"[3,2]) // return "34"

println("0123456789"[3,2,.right2left]) // return "56"

println("0123456789"[5,10,.pos_len,.left2right]) // return "56789"

println("0123456789"[8,120,.pos_len,.right2left]) // return "01"

println("0123456789"[120,120,.pos_len,.left2right]) // return "9"

println("0123456789"[0...4]) // return "01234"

println("0123456789"[0..4]) // return "0123"

println("0123456789"[0...4,.right2left]) // return "56789"

println("0123456789"[4...0,.right2left]) // return "678" << because ??? range can wear endIndex at 0 ???

Eine Python-ähnliche Lösung, mit der Sie einen negativen Index verwenden können.

var str = "Hello world!"
str[-1]        // "!"

könnte sein:

extension String {
    subscript (var index:Int)->Character{
        get {
            let n = distance(self.startIndex, self.endIndex)
            index %= n
            if index < 0 { index += n }
            return self[advance(startIndex, index)]
        }
    }
}