Bagaimana saya bisa mendapatkan karakter n dari string? Saya mencoba braket ( []) accessor tanpa hasil.

var string = "Hello, world!"

var firstChar = string[0] // Throws error

GALAT: 'subskrip' tidak tersedia: tidak dapat subskrip dengan String dengan Int, lihat komentar dokumentasi untuk diskusi

Perhatian: Silakan lihat jawaban Leo Dabus untuk implementasi yang tepat untuk Swift 4 dan Swift 5.

Cepat 4 atau lebih baru

Itu Substring jenis diperkenalkan di Swift 4 untuk membuat substring lebih cepat dan lebih efisien dengan berbagi penyimpanan dengan string asli, sehingga ini apa fungsi subscript harus kembali.

Cobalah di sini

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

Untuk mengonversikannya Substringmenjadi String, Anda cukup melakukannya String(string[0..2]), tetapi Anda hanya harus melakukannya jika Anda berencana untuk menjaga agar substring tetap ada. Kalau tidak, akan lebih efisien jika menyimpannya Substring.

Alangkah baiknya jika seseorang dapat menemukan cara yang baik untuk menggabungkan dua ekstensi ini menjadi satu. Saya mencoba memperluas StringProtocol tanpa keberhasilan, karena indexmetode itu tidak ada di sana. Catatan: Jawaban ini sudah diedit, sudah diterapkan dengan benar dan sekarang berfungsi untuk substring juga. Pastikan untuk menggunakan rentang yang valid untuk menghindari tabrakan saat berlangganan jenis StringProtocol Anda. Untuk berlangganan dengan rentang yang tidak akan macet dengan nilai di luar rentang, Anda dapat menggunakan implementasi ini

Mengapa ini bukan bawaan?

Pesan kesalahan mengatakan "lihat komentar dokumentasi untuk diskusi" . Apple memberikan penjelasan berikut dalam file UnavailableStringAPIs.swift :

String langganan dengan bilangan bulat tidak tersedia.

Konsep " ikarakter th dalam sebuah string" memiliki interpretasi berbeda di berbagai pustaka dan komponen sistem. Penafsiran yang benar harus dipilih sesuai dengan kasus penggunaan dan API yang terlibat, sehingga String tidak dapat disubkripsikan dengan bilangan bulat.

Swift menyediakan beberapa cara berbeda untuk mengakses data karakter yang disimpan di dalam string.

• String.utf8adalah kumpulan unit kode UTF-8 dalam string. Gunakan API ini saat mengonversi string ke UTF-8. Sebagian besar POSIX API memproses string dalam hal unit kode UTF-8.

• String.utf16adalah kumpulan unit kode UTF-16 dalam string. Sebagian besar Cocoa dan Cocoa touch string memproses string dalam hal unit kode UTF-16. Misalnya, instance yang NSRangedigunakan dengan NSAttributedStringdan NSRegularExpressionmenyimpan offset dan panjang substring dalam hal unit kode UTF-16.

• String.unicodeScalarsadalah koleksi skalar Unicode. Gunakan API ini saat Anda melakukan manipulasi data karakter tingkat rendah.

• String.characters adalah kumpulan cluster grapheme yang diperluas, yang merupakan perkiraan karakter yang dirasakan pengguna.

Perhatikan bahwa saat memproses string yang berisi teks yang dapat dibaca manusia, pemrosesan karakter-demi-karakter harus dihindari sejauh mungkin. Gunakan tingkat tinggi lokal-sensitif algoritma Unicode bukan, misalnya, String.localizedStandardCompare(), String.localizedLowercaseString, String.localizedStandardRangeOfString()dll

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

Anda perlu menambahkan ekstensi String ini ke proyek Anda (ini sepenuhnya diuji):

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

Meskipun Swift selalu memiliki solusi untuk masalah ini (tanpa ekstensi String, yang saya berikan di bawah), saya tetap akan melakukannya sangat menyarankan menggunakan ekstensi. Mengapa? Karena itu menyelamatkan saya dari puluhan jam migrasi yang menyakitkan dari versi awal Swift, di mana sintaksis String mengubah hampir setiap rilis, tetapi yang perlu saya lakukan adalah memperbarui implementasi ekstensi sebagai lawan refactoring seluruh proyek. Tentukan pilihanmu.

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"

Saya baru saja menemukan solusi yang rapi ini

var firstChar = Array(string)[0]

Tidak ada pengindeksan menggunakan bilangan bulat, hanya menggunakan String.Index. Sebagian besar dengan kompleksitas linier. Anda juga dapat membuat rentang dari String.Indexdan menggunakan substring.

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]

Perhatikan bahwa Anda tidak dapat menggunakan indeks (atau rentang) yang dibuat dari satu string ke string lain

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

Anda dapat memperluas StringProtocol untuk membuat subskrip juga tersedia untuk substring:

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

Pengujian

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

Cepat 4

let str = "My String"

String pada indeks

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

Substring

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

Pertama dan karakter

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

Terakhir n karakter

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

Swift 2 dan 3

str = "My String"

** String Pada Indeks **

Cepat 2

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

Cepat 3

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

SubString dariIndex keIndex

Cepat 2

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

Cepat 3

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

Pertama dan karakter

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

Terakhir n karakter

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

Swift 2.0 pada Xcode 7 GM Seed

var text = "Hello, world!"

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

Untuk karakter ke-n, ganti 0 dengan n-1.

Edit: Swift 3.0

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

nb ada cara-cara sederhana untuk meraih karakter tertentu dalam string

misalnya let firstChar = text.characters.first

Jika Anda melihat Cannot subscript a value of type 'String'...menggunakan ekstensi ini:

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

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

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

Solusi Swift 2.2:

Ekstensi berikut berfungsi di Xcode 7, ini adalah kombinasi dari solusi ini dan konversi sintaks 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]
    }
}

Kelas string cepat tidak memberikan kemampuan untuk mendapatkan karakter pada indeks tertentu karena dukungan asli untuk karakter UTF. Panjang variabel karakter UTF dalam memori membuat melompat langsung ke karakter tidak mungkin. Itu berarti Anda harus secara manual mengulangi string setiap kali.

Anda dapat memperluas String untuk menyediakan metode yang akan berulang melalui karakter sampai indeks yang Anda inginkan

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

Sebagai catatan tambahan, ada beberapa fungsi yang dapat diterapkan langsung ke representasi rantai karakter String, seperti ini:

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

Hasilnya bertipe Character, tetapi Anda bisa melemparkannya ke String.

Atau ini:

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

:-)

Cepat 4

String(Array(stringToIndex)[index]) 

Ini mungkin cara terbaik untuk menyelesaikan masalah ini satu kali. Anda mungkin ingin melemparkan String sebagai array terlebih dahulu, dan kemudian melemparkan hasilnya sebagai String lagi. Jika tidak, Karakter akan dikembalikan sebagai ganti String.

Contoh String(Array("HelloThere")[1])akan mengembalikan "e" sebagai String.

(Array("HelloThere")[1] akan mengembalikan "e" sebagai Karakter.

Swift tidak memungkinkan Strings diindeks seperti array, tetapi ini menyelesaikan pekerjaan dengan gaya kasar.

Solusi saya yang sangat sederhana:

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

Anda dapat melakukannya dengan mengonversi String ke Array dan mendapatkannya dengan indeks spesifik menggunakan subskrip seperti di bawah ini

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

Saya baru saja mengalami masalah yang sama. Cukup lakukan ini:

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

Swift3

Anda dapat menggunakan sintaksis subskrip untuk mengakses Karakter pada indeks String tertentu.

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

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

atau kita bisa melakukan String Extension di Swift 4

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

PEMAKAIAN:

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

Solusi saya ada dalam satu baris, seandainya cadena adalah string dan 4 adalah posisi ke-9 yang Anda inginkan:

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

Sederhana ... Saya kira Swift akan memasukkan lebih banyak hal tentang substring di versi mendatang.

Swift 3: solusi lain (diuji di taman bermain)

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

Pemakaian:

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

Perbarui untuk subString cepat 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))
        }
    }

}

Saya pikir jawaban cepat untuk mendapatkan karakter pertama adalah:

let firstCharacter = aString[aString.startIndex]

Ini jauh lebih elegan dan kinerja daripada:

let firstCharacter = Array(aString.characters).first

Tapi .. jika Anda ingin memanipulasi dan melakukan lebih banyak operasi dengan string, Anda dapat berpikir membuat ekstensi .. ada satu ekstensi dengan pendekatan ini, itu sangat mirip dengan yang sudah diposting di sini:

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

}

TAPI ITU GAGASAN YANG MENGERIKAN !!

Ekstensi di bawah ini sangat tidak efisien. Setiap kali string diakses dengan integer, fungsi O (n) untuk memajukan indeks awal dijalankan. Menjalankan loop linier di dalam loop linier lain berarti ini untuk loop secara tidak sengaja O (n2) - karena panjang string meningkat, waktu yang dibutuhkan loop ini meningkat secara kuadratik.

Alih-alih melakukan itu Anda bisa menggunakan koleksi string karakter.

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

}

Pemakaian

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

Tips dan Trik Pemrograman yang Membantu (ditulis oleh saya)

Dapatkan & Atur Langganan (String & Substring) - Swift 4.2

Swift 4.2, Xcode 10

Saya mendasarkan jawaban saya dari jawaban @alecarlson . Satu-satunya perbedaan besar adalah Anda bisa mendapatkan Substringatau Stringmengembalikan (dan dalam beberapa kasus, satu Character). Anda juga bisa getdan setsubskrip. Terakhir, milik saya sedikit lebih rumit dan lebih panjang dari jawaban @alecarlson dan karena itu, saya sarankan Anda memasukkannya ke file sumber.

Perpanjangan:

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

Cepat 4.2

Jawaban ini sangat ideal karena meluas Stringdan semua Subsequences( Substring) dalam satu ekstensi

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

Pemakaian

var str = "Hello, playground"

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

Sekarang, subskrip (_ :) tidak tersedia. Kita juga tidak bisa melakukan ini

str[0] 

dengan string. Kita harus menyediakan "String.Index" Tapi, bagaimana kita bisa memberikan nomor indeks kita sendiri dengan cara ini, sebagai gantinya kita bisa menggunakan,

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

Swift 4.2 atau lebih baru

Range dan subscripting berbagai parsial menggunakan String'sindices properti

Sebagai variasi dari jawaban bagus @LeoDabus , kami dapat menambahkan ekstensi tambahan DefaultIndicesdengan tujuan memungkinkan kami untuk kembali ke indicesproperti Stringketika menerapkan subskrip khusus (dengan Intrentang khusus dan rentang parsial) untuk yang terakhir.

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"

Terima kasih @LeoDabus karena menunjukkan saya ke arah penggunaan indicesproperti sebagai alternatif (lain) untuk Stringberlangganan!

Swift 5.1.3:

Tambahkan ekstensi 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"

StringJenis Swift tidak menyediakan characterAtIndexmetode karena ada beberapa cara string Unicode dapat dikodekan. Apakah Anda menggunakan UTF8, UTF16, atau yang lainnya?

Anda dapat mengakses CodeUnitkoleksi dengan mengambil String.utf8dan String.utf16properti. Anda juga dapat mengakses UnicodeScalarkoleksi dengan mengambil String.unicodeScalarsproperti.

Dalam semangat NSStringimplementasi, saya mengembalikan sebuah unichartipe.

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]

Untuk memberi makan subjek dan menunjukkan kemungkinan subskrip cepat, berikut ini adalah string subskrip "substring-toolbox"

Metode ini aman dan tidak pernah melewati indeks string

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

Solusi mirip python, yang memungkinkan Anda menggunakan indeks negatif,

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

bisa jadi:

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