Jak mogę uzyskać n-ty znak ciągu? Próbowałem []akcesorium brack ( ) bez powodzenia.

var string = "Hello, world!"

var firstChar = string[0] // Throws error

BŁĄD: „indeks dolny” jest niedostępny: nie można subskrybować ciągu znaków z Int, patrz komentarz do dokumentacji do dyskusji

Uwaga: zapoznaj się z odpowiedzią Leo Dabusa dotyczącą prawidłowej implementacji Swift 4 i Swift 5.

Swift 4 lub nowszy

Ten Substringtyp został wprowadzony w Swift 4, aby podciągi były szybsze i bardziej wydajne poprzez współdzielenie pamięci z oryginalnym ciągiem, więc to właśnie powinny zwrócić funkcje indeksu dolnego.

Wypróbuj tutaj

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

Aby przekonwertować Substringna a String, możesz po prostu to zrobić String(string[0..2]), ale powinieneś to zrobić tylko wtedy, gdy planujesz zachować podciąg. W przeciwnym razie bardziej efektywne jest utrzymanie go Substring.

Byłoby wspaniale, gdyby ktoś wymyślił dobry sposób na połączenie tych dwóch rozszerzeń w jedno. Próbowałem rozszerzyć StringProtocol bez powodzenia, ponieważ indexmetoda tam nie istnieje. Uwaga: Ta odpowiedź została już zredagowana, jest poprawnie zaimplementowana i teraz działa również dla podciągów. Upewnij się, że używasz prawidłowego zakresu, aby uniknąć awarii podczas subskrybowania typu StringProtocol. Do indeksowania z zakresem, który nie spowoduje awarii przy wartościach spoza zakresu, możesz użyć tej implementacji

Dlaczego to nie jest wbudowane?

Komunikat o błędzie mówi „zobacz komentarz do dokumentacji do dyskusji” . Apple udostępnia następujące wyjaśnienie w pliku UnavailableStringAPIs.swift :

Ciągi indeksowania z liczbami całkowitymi nie są dostępne.

Pojęcie „ ith znak w ciągu” ma różne interpretacje w różnych bibliotekach i komponentach systemu. Prawidłową interpretację należy wybrać zgodnie z przypadkiem użycia i zaangażowanymi interfejsami API, więc String nie można zapisać jej za pomocą liczby całkowitej.

Swift zapewnia kilka różnych sposobów dostępu do danych znakowych przechowywanych w łańcuchach.

• String.utf8to zbiór jednostek kodu UTF-8 w ciągu. Użyj tego interfejsu API podczas konwersji ciągu znaków na UTF-8. Większość interfejsów API POSIX przetwarza ciągi znaków w kategoriach jednostek kodu UTF-8.

• String.utf16to zbiór jednostek kodu UTF-16 w postaci ciągu. Większość interfejsów API kakao i kakao dotykowych przetwarza ciągi znaków pod względem jednostek kodu UTF-16. Na przykład przypadki NSRangeużycia NSAttributedStringi NSRegularExpressionprzechowywania przesunięć i długości podciągów w odniesieniu do jednostek kodu UTF-16.

• String.unicodeScalarsto zbiór skalarów Unicode. Użyj tego interfejsu API podczas wykonywania niskopoziomowych manipulacji danymi znaków.

• String.characters to zbiór rozszerzonych klastrów grafemowych, które są przybliżeniem znaków postrzeganych przez użytkownika.

Należy pamiętać, że podczas przetwarzania ciągów zawierających tekst czytelny dla człowieka należy unikać przetwarzania znaków po znaku w największym możliwym stopniu. Stosowanie wysokiego poziomu locale wrażliwe algorytmy Unicode zamiast, na przykład String.localizedStandardCompare(), String.localizedLowercaseString, String.localizedStandardRangeOfString()etc.

Szybki 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"

Musisz dodać to rozszerzenie String do swojego projektu (jest w pełni przetestowane):

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

Mimo że Swift zawsze miał gotowe rozwiązanie tego problemu (bez rozszerzenia String, które podałem poniżej), nadal zdecydowanie polecam użycie rozszerzenia. Dlaczego? Ponieważ zaoszczędziło mi to dziesiątki godzin bolesnej migracji z wczesnych wersji Swift, gdzie składnia String zmieniała się prawie w każdym wydaniu, ale wszystko, co musiałem zrobić, to zaktualizować implementację rozszerzenia w przeciwieństwie do refaktoryzacji całego projektu. Dokonaj swojego wyboru.

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"

Właśnie wymyśliłem to fajne obejście

var firstChar = Array(string)[0]

Brak indeksowania przy użyciu liczb całkowitych, tylko przy użyciu String.Index. Głównie z liniową złożonością. Możesz także tworzyć zakresy String.Indexi uzyskiwać z nich podciągi.

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]

Pamiętaj, że nigdy nie możesz użyć indeksu (lub zakresu) utworzonego z jednego ciągu na drugi

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

Możesz rozszerzyć StringProtocol, aby indeks dolny był dostępny również dla podciągów:

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

Testowanie

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 🇧🇷!!!"

Szybki 4

let str = "My String"

Ciąg o indeksie

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

Podciąg

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

Pierwsze n znaków

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

Ostatnie n znaków

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

Swift 2 i 3

str = "My String"

** Ciąg według indeksu **

Swift 2

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

Szybki 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"

Szybki 3

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

Pierwsze n znaków

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

Ostatnie n znaków

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

Swift 2.0 od Xcode 7 GM Seed

var text = "Hello, world!"

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

Dla n-tego znaku zamień 0 na n-1.

Edycja: Swift 3.0

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

Uwaga: istnieją prostsze sposoby chwytania niektórych znaków w ciągu

na przykład let firstChar = text.characters.first

Jeśli widzisz, Cannot subscript a value of type 'String'...użyj tego rozszerzenia:

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

Źródło: http://oleb.net/blog/2014/07/swift-strings/

Rozwiązanie Swift 2.2:

Poniższe rozszerzenie działa w Xcode 7, jest to połączenie tego rozwiązania i konwersji składni Swift 2.0.

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

Szybka klasa łańcuchowa nie zapewnia możliwości uzyskania znaku o określonym indeksie z uwagi na jego natywną obsługę znaków UTF. Zmienna długość znaku UTF w pamięci uniemożliwia skok bezpośrednio do znaku. Oznacza to, że za każdym razem musisz ręcznie zapętlić ciąg.

Możesz rozszerzyć String, aby zapewnić metodę, która będzie przechodzić między znakami aż do pożądanego indeksu

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)!

Na marginesie, istnieje kilka funkcji, które można zastosować bezpośrednio do reprezentacji ciągu znaków w łańcuchu znaków, takie jak:

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

Wynik jest typu Postać, ale możesz rzucić go na Ciąg.

Albo to:

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

:-)

Szybki 4

String(Array(stringToIndex)[index]) 

Jest to prawdopodobnie najlepszy sposób na rozwiązanie tego problemu jednorazowo. Prawdopodobnie chcesz najpierw rzucić String jako tablicę, a następnie ponownie rzutować wynik jako String. W przeciwnym razie znak zostanie zwrócony zamiast łańcucha.

Przykład String(Array("HelloThere")[1])zwróci „e” jako ciąg.

(Array("HelloThere")[1] zwróci „e” jako postać.

Swift nie pozwala na indeksowanie ciągów znaków jak tablic, ale wykonuje to zadanie w stylu brute-force.

Moje bardzo proste rozwiązanie:

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

Możesz to zrobić, konwertując String na Array i uzyskując go według określonego indeksu za pomocą indeksu dolnego jak poniżej

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

Właśnie miałem ten sam problem. Po prostu zrób to:

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

Swift3

Możesz użyć składni indeksu dolnego, aby uzyskać dostęp do znaku przy określonym indeksie ciągów.

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

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

lub możemy wykonać rozszerzenie ciągu w Swift 4

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

STOSOWANIE:

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

Moje rozwiązanie jest w jednej linii, załóżmy, że cadena jest łańcuchem, a 4 to n-ta pozycja, którą chcesz:

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

Proste ... Przypuszczam, że Swift będzie zawierał więcej informacji na temat podciągów w przyszłych wersjach.

Swift 3: inne rozwiązanie (testowane na placu zabaw)

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

Stosowanie:

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

Aktualizacja do szybkiego subString 2.0

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

}

Myślę, że szybką odpowiedzią na pierwszą postać może być:

let firstCharacter = aString[aString.startIndex]

Jest o wiele bardziej elegancki i wydajny niż:

let firstCharacter = Array(aString.characters).first

Ale .. jeśli chcesz manipulować i wykonywać więcej operacji na ciągach, możesz pomyśleć o utworzeniu rozszerzenia .. istnieje jedno rozszerzenie z tym podejściem, jest dość podobne do tego, które już tu opublikowano:

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

}

ALE TO OKOLICZNY POMYSŁ !!

Poniższe rozszerzenie jest strasznie nieefektywne. Za każdym razem, gdy ciąg jest uzyskiwany za pomocą liczby całkowitej, uruchamiana jest funkcja O (n) w celu przyspieszenia początkowego indeksu. Uruchomienie pętli liniowej wewnątrz innej pętli liniowej oznacza, że ​​przypadkowo pętla ta ma wartość O (n2) - wraz ze wzrostem długości łańcucha rośnie czas kwadratowy tej pętli.

Zamiast tego możesz użyć kolekcji ciągów znaków.

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

}

Stosowanie

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

Pomocne wskazówki i porady programistyczne (napisane przeze mnie)

Pobierz i ustaw indeks (ciąg i podciąg) - Swift 4.2

Swift 4.2, Xcode 10

Oparłem swoją odpowiedź na odpowiedzi @alecarlson . Jedyna różnica polega można dostać Substringlub Stringzwrócony (aw niektórych przypadkach pojedyncza Character). Możesz także geti setindeks dolny. Wreszcie moje jest trochę bardziej kłopotliwe i dłuższe niż odpowiedź @alecarlson i jako takie sugeruję, abyś umieścił je w pliku źródłowym.

Rozbudowa:

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

Szybki 4.2

Ta odpowiedź jest idealna, ponieważ rozszerza Stringi wszystkie jej Subsequences( Substring) w jednym rozszerzeniu

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

Stosowanie

var str = "Hello, playground"

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

Do tej pory indeks dolny (_ :) jest niedostępny. Nie możemy tego zrobić

str[0] 

za pomocą ciągu znaków. Musimy podać ciąg „String.Index”. Ale w jaki sposób możemy w ten sposób podać własny numer indeksu, zamiast tego możemy użyć,

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

Swift 4.2 lub nowszy

Indeksowanie zakresu i częściowego zakresu za pomocą String'sindices właściwość

Jako wariant ładnej odpowiedzi @LeoDabus , możemy dodać dodatkowe rozszerzenie DefaultIndicesw celu umożliwienia nam powrotu do indiceswłaściwości Stringprzy wdrażaniu niestandardowych indeksów dolnych (według Intzakresów specjalistycznych i zakresów częściowych) dla tego drugiego.

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"

Dzięki @LeoDabus za wskazanie mnie w kierunku wykorzystania tej indiceswłaściwości jako (innej) alternatywy dla Stringsubskrypcji!

Swift 5.1.3:

Dodaj rozszerzenie String:

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"

StringTyp Swift nie zapewnia znakucharacterAtIndex metody, ponieważ istnieje kilka sposobów kodowania łańcucha Unicode. Czy korzystasz z UTF8, UTF16 lub czegoś innego?

Możesz uzyskać dostęp do CodeUnitkolekcji, pobierając właściwości String.utf8i String.utf16. Możesz również uzyskać dostęp do UnicodeScalarkolekcji, pobierając plikString.unicodeScalars właściwość.

W duchu NSStringimplementacji zwracam unichartyp.

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]

Aby nakarmić temat i pokazać szybkie możliwości indeksu dolnego, oto krótki ciąg oparty na indeksie dolnym

Te metody są bezpieczne i nigdy nie przekraczają indeksów ciągów

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 ???

Rozwiązanie typu python, które pozwala na użycie indeksu ujemnego,

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

możliwe:

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