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 4.2 oder später

Bereichs- und Teilbereichssubskription mit String's indices-Eigenschaft

Als Variation von @LeoDabus schöner Antwort können wir eine zusätzliche Erweiterung zu DefaultIndices hinzufügen, mit dem Ziel uns zu ermöglichen, auf die indices-Eigenschaft von String zurückzugreifen, wenn wir die benutzerdefinierten Subskripte (durch auf Int spezialisierte Bereiche und Teilbereiche) für letzteren implementieren.

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

// Das Verschieben von index(_:offsetBy:) in eine Erweiterung ermöglicht etwas
// kürzere Implementierungen für diese String-Erweiterungen.
extension String {
    subscript(range: Range) -> SubSequence {
        let start = indices[range.lowerBound]
        return self[start..) -> SubSequence {
        let start = indices[range.lowerBound]
        return self[start...indices[start...][range.count]]
    }
    subscript(range: PartialRangeFrom) -> SubSequence {
        self[indices[range.lowerBound]...]
    }
    subscript(range: PartialRangeThrough) -> SubSequence {
        self[...indices[range.upperBound]]
    }
    subscript(range: PartialRangeUpTo) -> SubSequence {
        self[..

``

Danke @LeoDabus, dass du mich darauf hingewiesen hast, die indices-Eigenschaft als eine (weitere) Alternative für das String-Subskripting zu verwenden!

``

Answer 2

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"

Answer 3

Meine Lösung besteht aus einer Zeile, vorausgesetzt, cadena ist der String und 4 ist die n-te Position, die Sie möchten:

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

Einfach... Ich vermute, dass Swift in zukünftigen Versionen mehr Dinge über Teilstrings einbeziehen wird.

Answer 4

Der beste Weg, der für mich funktioniert hat, ist:

var firstName = "Olivia"
var lastName = "Pope"

var nameInitials.text = "\(firstName.prefix(1))" + "\    (lastName.prefix(1))"

Output:"OP"

Answer 5

Swift 3: eine andere Lösung (getestet im Playground)

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

Verwendung:

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