Получить n-й символ строки в языке программирования Swift

Question

Получить n-й символ строки в языке программирования Swift

338

Как я могу получить n-й символ строки? Я попытался использовать скобки ([]) без удачи.

var string = "Hello, world!"

var firstChar = string[0] // Throws error

ОШИБКА: "индекс" недоступен: не может подписать строку с Int, см. Комментарий к документации для обсуждения

Mohsen 07 июнь 2014, в 01:24

Источник

1

Похоже, что сообщение об ошибке «не может подписать строку с помощью Int, см. Комментарий к документации для обсуждения» относится к github.com/apple/swift/blob/master/stdlib/public/core/…
andrewdotn 06 авг. 2017, в 19:55

Теги:

swift

string

collections

character

38 ответов

296

Swift 4.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"

Вам нужно будет добавить это расширение String в свой проект (он полностью протестирован):

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

}

Несмотря на то, что у Swift всегда была проблема с этой проблемой (без расширения строки, которое я приводил ниже), я по-прежнему настоятельно рекомендую использовать расширение. Зачем? Потому что это спасло мне десятки часов болезненной миграции из ранних версий Swift, где синтаксис String менялся почти каждый выпуск, но все, что мне нужно было сделать, это обновить реализацию расширения, а не рефакторинг всей производственной линии на 300 тыс. Строк кода приложение. Сделай свой выбор.

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"

NAlexN 06 нояб. 2014, в 10:05

0

изменить range.upperBound - range.lowerBound на range.count
Leo Dabus 25 окт. 2017, в 23:32
0

Это не часть первоначального вопроса, но ... было бы неплохо, если бы это поддерживало назначение. Например, s [i] = "a" :).
Chris Prince 06 нояб. 2017, в 23:57
2

Я считаю, что с Swift 4.2 подписки снова недоступны. Я получаю сообщение об ошибке: «подписка» недоступна: невозможно подписать строку с помощью Int, см. Комментарий к документации для обсуждения
c1pherB1t 14 окт. 2018, в 15:14
1

@ChrisPrince extension StringProtocol where Self: RangeReplaceableCollection { subscript(offset: Int) -> Element { get { return self[index(startIndex, offsetBy: offset)] } set { let start = index(startIndex, offsetBy: offset) replaceSubrange(start..<index(after: start), with: [newValue]) } } }
Leo Dabus 11 дек. 2018, в 03:08

Показать ещё 2 комментария

116

Нет индексации с использованием целых чисел, используя только String.Index. В основном с линейной сложностью. Вы также можете создавать диапазоны от String.Index и получать подстроки, используя их.

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]

Обратите внимание, что вы никогда не сможете использовать индекс (или диапазон), созданный из одной строки в другую строку

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]

Sulthan 12 июнь 2014, в 07:29

7

String индексы уникальны для строки. Это связано с тем, что разные строки могут иметь разные многокомпонентные Characters UTF-16 и / или в разных позициях, поэтому индексы единиц UTF-16 не будут совпадать, могут выходить за пределы конца или точки внутри многозначного Character UTF-16.
zaph 19 авг. 2014, в 15:34
0

@Zaph Это очевидно.
Sulthan 19 авг. 2014, в 15:58
3

Объясняя, почему вы говорите: «иногда это приводит к сбою или приводит к неопределенному поведению». Возможно, лучше сказать, просто не делай этого, потому что ...
zaph 19 авг. 2014, в 17:17
1

@Sulthan .. сейчас ..< (в вашем назначении на range )
Aaron Brager 25 окт. 2014, в 04:41
0

В отгрузочной версии Swift string[string.endIndex] приводит к EXC_BAD_INSTRUCTION, очевидно, так как string.endIndex находится в одном месте за концом строки. string[string.endIndex-1] не работает, так как String.Index не является IntegerConvertible. Как мы получаем последний символ строки?
CajunLuke 28 окт. 2014, в 19:37
3

@CajunLuke Я знаю, что прошло много времени с тех пор, как вы оставили этот комментарий, но взгляните на этот ответ . Вы можете использовать var lastChar = string[string.endIndex.predecessor()]
David L 14 дек. 2014, в 07:11

Показать ещё 4 комментария

112

Я просто придумал это опрятное решение

var firstChar = Array(string)[0]

Jens Wirth 12 июнь 2014, в 07:27

2

Это хороший быстрый обходной путь для (обычного) случая, когда вы знаете, что у вас есть строки в кодировке UTF8 или ASCII. Просто убедитесь, что строки никогда не будут в кодировке, которая использует более одного байта.
Jeff Hay 19 авг. 2014, в 15:04
41

Это кажется крайне неэффективным, поскольку вы копируете всю строку только для того, чтобы получить первый символ. Используйте строку [строка. startIndex] вместо 0, как указал Султан.
Bjorn Tipling 12 янв. 2015, в 03:25
6

Развернуть строку: var firstChar = Array(string!)[0] В противном случае будет указано add arrayLiteral
Zaid Pathan 09 апр. 2015, в 13:58
0

Это действительно должен быть принятый ответ. Это эффективно и чисто, и работает отлично.
mginn 03 май 2015, в 16:51
2

Я не считаю, что это чисто, на самом деле это кругом. Я не совсем уверен, какой инициализатор в Array используется первым, что вызывает это (и я предполагаю, что это инициализатор SequenceType, заставляющий его собирать символы строки как отдельные компоненты для Array). Это совсем не явно и может быть исправлено в будущем без приведения типов. Это также не работает, если вы используете сокращение для массива через [string] .first. Решение @ Sulthan лучше всего использует запеченные в значениях индекса. Намного яснее, что здесь происходит.
TheCodingArt 25 май 2015, в 18:22
1

Вау, ошибка сегмента компилятора!
Frank 26 сен. 2016, в 03:43
0

Это не работает с Swift 3: argument type 'String' does not conform to expected type 'Sequence' . Сначала вам нужно получить CharacterView для строки, а затем индексировать ее массив: Array(str.characters)[0] или String(Array(str.characters)[0]) если вы хотите сохранить тип String.
Matt Le Fleur 11 апр. 2017, в 08:52

Показать ещё 5 комментариев

82

Swift 4.1 или позже

Вы можете расширить Swift 4 StringProtocol, чтобы сделать индекс доступным также для подстрок. Примечание. Из-за предложения SE-0191 ограничение расширения на IndexDistance == Int может быть удалено:

extension StringProtocol {

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

    subscript(_ range: CountableRange<Int>) -> SubSequence {
        return prefix(range.lowerBound + range.count)
            .suffix(range.count)
    }
    subscript(range: CountableClosedRange<Int>) -> SubSequence {
        return prefix(range.lowerBound + range.count)
            .suffix(range.count)
    }

    subscript(range: PartialRangeThrough<Int>) -> SubSequence {
        return prefix(range.upperBound.advanced(by: 1))
    }
    subscript(range: PartialRangeUpTo<Int>) -> SubSequence {
        return prefix(range.upperBound)
    }
    subscript(range: PartialRangeFrom<Int>) -> SubSequence {
        return suffix(Swift.max(0, count - range.lowerBound))
    }
}
extension Substring {
    var string: String { return String(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]
    }
}

тестирование

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 you need to add .string as follow
test[10...].string  // "!!! Hello Brazil !!!"

Leo Dabus 06 июль 2016, в 03:23

0

Могу я спросить, что такое «self [index (startIndex, offsetBy: i)]»? И как работает «я [я]»?
allenlinli 22 сен. 2016, в 13:12
1

Привет, Лео, спасибо за решение! Я только что (сегодня) переключился с Swift 2.3 на 3, и ваш индекс решения (диапазон: Range <Int>) выдает ошибку «Дополнительный аргумент« limitedBy »в вызове». Что вы думаете может быть не так?
Ahmet Akkök 03 окт. 2016, в 14:56
0

@ АхметАккёк, ты уверен, что не менял код?
Leo Dabus 03 окт. 2016, в 15:26
1

@ Оказалось, что я не конвертировал весь проект, но в приложении, а не в расширении, я повторил процесс как для приложения, так и для расширения, и теперь он работает нормально. Ваша помощь очень ценится!
Ahmet Akkök 03 окт. 2016, в 15:57
0

это очень сложный код. В чем преимущество по сравнению с return String(Array(characters)[range]) в Swift 3?
Dan Rosenstark 07 нояб. 2016, в 16:25
0

Почему вы решили вернуть SubSequence а не значение, подобное SubString или String ?
Noah Wilder 25 апр. 2018, в 22:14
0

Я расширяю протокол, а не тип (String), поэтому вам нужно вернуть SubSequence, которая в случае String является Substring.
Leo Dabus 25 апр. 2018, в 22:18

Показать ещё 5 комментариев

50

Swift 4

let str = "My String"

Строка с индексом

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

подстроку

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

Первые n символов

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

Последние n символов

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

Swift 2 и 3

str = "My String"

** Строка по индексу **

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

Первые n символов

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

Последние n символов

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

Warif Akhand Rishi 16 нояб. 2015, в 11:36

25

Swift 2.0 от Xcode 7 GM Seed

var text = "Hello, world!"

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

Для n-го символа замените 0 на n-1.

Изменить: Swift 3.0

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

нотабене есть более простые способы захвата определенных символов в строке

например. let firstChar = text.characters.first

Matt Le Fleur 16 сен. 2015, в 13:09

23

Если вы видите Cannot subscript a value of type 'String'..., используйте это расширение:

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

Источник: http://oleb.net/blog/2014/07/swift-strings/

SoftDesigner 07 июль 2015, в 09:56

19

Swift 2.2 Решение:

Следующее расширение работает в Xcode 7, это комбинация это решение и синтаксическое преобразование 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]
    }
}

Dan Beaulieu 03 сен. 2015, в 05:08

11

В качестве примечания, есть несколько функций, применимых непосредственно к представлению символьной цепочки String, например:

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

Результат имеет тип Character, но вы можете передать его в String.

Или это:

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

: -)

Frédéric Adda 09 окт. 2015, в 14:56

11

Класс быстрых строк не предоставляет возможность получить символ по определенному индексу из-за его собственной поддержки символов UTF. Переменная длина символа UTF в памяти делает невозможным переключение непосредственно на символ. Это означает, что вам приходится вручную перематывать строку по каждой строке.

Вы можете расширить String, чтобы предоставить метод, который будет проходить через символы до нужного индекса

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

drewag 07 июнь 2014, в 03:35

3

Вы уже можете перебирать строки: для буквы в "foo" {println (letter)}
Doobeh 07 июнь 2014, в 01:56
0

@Doobeh Я имел в виду цикл через и вернуть реальный символ, как в моем редактировании выше
drewag 07 июнь 2014, в 02:01
0

отлично! Забавно, как вы можете проходить через это, но не через индекс. Свифт чувствует себя питоническим, но с более жесткими краями.
Doobeh 07 июнь 2014, в 02:10
0

Я обнаружил, что использование myString.bridgeToObjectiveC().characterAtIndex(0) или (string as NSString ).characterAtIndex(0) возвращает значение Int для символа
markhunte 07 июнь 2014, в 09:24
0

@markhunte Это хороший момент. Еще один аргумент в моей голове, чтобы использовать нативный метод
drewag 07 июнь 2014, в 15:11
4

Не используйте методы NSString для доступа к отдельным символам из String Swift-native - оба используют разные механизмы подсчета, поэтому вы получите непредсказуемые результаты с более высокими символами Unicode. Первый метод должен быть безопасным (после обработки ошибок Юникода в Swift).
Nate Cook 09 июнь 2014, в 16:01
0

@NateCook ты прав. Я удалил второй вариант
drewag 12 июнь 2014, в 14:24
0

Как насчет "for (cur, char) в enumerate (self) {}"?
masakielastic 14 июль 2014, в 05:07

Показать ещё 6 комментариев

10

Swift 4

String(Array(stringToIndex)[index])

Это, наверное, лучший способ решить эту проблему разом. Вероятно, вы хотите сначала перенести строку как массив, а затем снова передать результат в виде строки. В противном случае символ будет возвращен вместо строки.

Пример String(Array("HelloThere")[1]) вернет "e" в виде строки.

(Array("HelloThere")[1] вернет символ "e" в качестве символа.

Swift не позволяет индексировать строки как массивы, но это выполняет задание, стиль грубой силы.

Harsh G. 10 нояб. 2017, в 20:20

5

У меня была такая же проблема. Просто сделайте следующее:

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

user3723247 04 авг. 2015, в 20:12

0

Это не работает для многих эмодзи и других персонажей, которые на самом деле занимают более одного раза «персонаж» в NSString .
rmaddy 25 май 2017, в 02:37

3

Мое очень простое решение:

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

Linh Dao 02 март 2018, в 06:06

0

Работает в Swift 4.1
leanne 25 авг. 2018, в 18:09

3

Мое решение находится в одной строке, предполагая, что cadena - это строка, а 4 - это n-я позиция, которую вы хотите:

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

Простой... Полагаю, что Swift будет включать больше вещей о подстроках в будущих версиях.

Julio César Fernández Muñoz 10 авг. 2014, в 01:17

1

Разве это не то же самое, что var charAtIndex = string[advance(string.startIndex, 10)] в ответе Султана?
Martin R 19 авг. 2014, в 14:54
0

Да, это то же самое решение с другим примером, как сказал Султан. Извините за дубликат. :) Легко два человека нашли то же самое.
Julio César Fernández Muñoz 19 авг. 2014, в 18:45

2

Получить и установить индекс (строка и подстрока) - Swift 4.2

Swift 4.2, Xcode 10

Я основал свой ответ на ответе @alecarlson. Единственная большая разница в том, что вы можете получить возвращенную Substring или String (а в некоторых случаях один Character). Вы также можете get и set индекс. Наконец, мой немного более громоздкий и более длинный, чем ответ @alecarlson, и поэтому я предлагаю вам поместить его в исходный файл.

Расширение:

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

Noah Wilder 27 апр. 2018, в 23:01

2

Swift 4

Диапазон и частичный диапазон индексирование с использованием `String` `indices` свойства

Как изменения @LeoDabus хорошего ответа, мы можем добавить дополнительное расширение для DefaultBidirectionalIndices с целью позволить нам падать обратно на indices собственности String при реализации пользовательских индексов (по Int специализированы диапазоны и частичные диапазоны) для последнего.

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

// Moving the index(_:offsetBy:) to an extension yields slightly
// briefer implementations for these String extensions.
extension String {
    subscript(r: CountableClosedRange<Int>) -> SubSequence {
        return self[indices[r.lowerBound]...indices[r.upperBound]]
    }
    subscript(r: CountablePartialRangeFrom<Int>) -> SubSequence {
        return self[indices[r.lowerBound]...]
    }
    subscript(r: PartialRangeThrough<Int>) -> SubSequence {
        return self[...indices[r.upperBound]]
    }
    subscript(r: PartialRangeUpTo<Int>) -> SubSequence {
        return self[..<indices[r.upperBound]]
    }
}

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

Спасибо @LeoDabus за то, что указали мне в сторону использования свойства indices в качестве (другой) альтернативы подстроке String !

Swift 4.2.

В Swift 4.2 DefaultBidirectionalIndices устарел в пользу DefaultIndices.

dfri 25 окт. 2017, в 22:32

1

единственный недостаток - CountableClosedRange сместит оба индекса из startIndex
Leo Dabus 25 окт. 2017, в 20:51
0

stackoverflow.com/a/38215613/4573247 теперь расширяет StringProtocol для поддержки подстрок
Leo Dabus 26 март 2018, в 23:38
0

Swift 4.2 DefaultBidirectionalIndices был переименован в DefaultIndices
Leo Dabus 31 авг. 2018, в 11:41
0

@LeoDabus спасибо! Выпущен ли сейчас Swift 4.2?
dfri 31 авг. 2018, в 15:31
0

Еще нет. Может быть через 10-14 дней. Вы программируете на Linux?
Leo Dabus 31 авг. 2018, в 15:37
1

@ LeoDabus я вижу. Да, в основном это linux, но не сильно Swift в эти дни: / Когда я использую swiftenv , я думаю, что он будет обновлен до 4.2 также довольно скоро.
dfri 31 авг. 2018, в 19:29

Показать ещё 4 комментария

2

Swift 3: другое решение (проверено на детской площадке)

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

Использование:

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

Peter Kreinz 11 апр. 2017, в 22:49

2

Swift3

Вы можете использовать синтаксис индекса для доступа к символу в конкретном индексе String.

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

Перейдите на страницу https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/StringsAndCharacters.html.

или мы можем сделать расширение строки в Swift 4

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

ИСПОЛЬЗОВАНИЕ:

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

Hamed Akhlaghi 18 янв. 2017, в 15:59

2

В Swift 3

    let mystring = "Hello, world!"
    let stringToArray = Array(mystring.characters)

    let indices = (stringToArray.count)-1

    print(stringToArray[0]) //H
    print(stringToArray[indices]) //!

Rajamohan S 19 окт. 2016, в 08:48

0

mystring даже не содержит свойства, называемое символами в Swift 3
Ankahathara 04 нояб. 2016, в 16:37
0

Хотя эти комментарии становятся немного странными, код работает. Это не полный ответ, но .characters это вещь. @Ankahathara ты проверял это на детской площадке?
Dan Rosenstark 06 нояб. 2016, в 22:16
0

Спасибо человек, это очень круто. Мне действительно удалось повторить ответ Лео сверху в одной строке для каждого метода, например, return String(Array(characters)[range]) ... отличные вещи!
Dan Rosenstark 07 нояб. 2016, в 16:27

Показать ещё 1 комментарий

2

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

}

Использование

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

Полезные советы и рекомендации по программированию (написано мной)

quemeful 15 сен. 2016, в 14:03

2

Я думаю, что быстрый ответ для получения первого символа может быть:

let firstCharacter = aString[aString.startIndex]

Это так элегантно и качественно, как:

let firstCharacter = Array(aString.characters).first

Но.. если вы хотите манипулировать и делать больше операций со строками, вы можете подумать о создании расширения... там есть одно расширение с этим подходом, оно очень похоже на уже опубликованное здесь:

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

}

НО ЭТО ТЕРРОМНАЯ ИДЕЯ!

Расширение ниже ужасно неэффективно. Каждый раз, когда к строке обращается целое число, выполняется функция O (n) для продвижения начального индекса. Запуск линейного цикла внутри другого линейного цикла означает, что для цикла случайно O (n2) - по мере увеличения длины строки время, которое этот цикл принимает, увеличивается квадратично.

Вместо этого вы можете использовать коллекцию строк символов.

ignaciohugog 20 апр. 2016, в 19:09

2

Обновление для 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))
        }
    }

}

YannickSteph 14 сен. 2015, в 17:33

0

Только сработал ответ за меня. (Swift 2.3)
Nik Kov 14 май 2017, в 09:09

2

Чтобы прокормить тему и показать быстрые возможности подстроки, здесь небольшая строка подстроки подстроки

Эти методы безопасны и никогда не переходят к строковым индексам

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

Luc-Olivier 02 июль 2014, в 13:32

1

Есть альтернатива, поясняемая в Строковый манифест

extension String : BidirectionalCollection {
    subscript(i: Index) -> Character { return characters[i] }
}

George Maisuradze 25 сен. 2017, в 14:06

1

Использование символов выполнит задание. Вы можете быстро преобразовать String в массив символов, которые могут обрабатываться методами CharacterView.

Пример:

let myString = "Hello World!"
let myChars  = myString.characters

(полный CharacterView doc)

(проверено в Swift 3)

Stephane Paquet 19 нояб. 2016, в 18:50

1

В Swift 3 без расширений класса String так просто, как я могу это сделать!

let myString = "abcedfg"
let characterLocationIndex = myString.index(myString.startIndex, offsetBy: 3)
let myCharacter = myString[characterLocationIndex]

myCharacter - это "3" в этом примере.

John Pavley 22 окт. 2016, в 17:32

1

Вы также можете преобразовать String в массив таких символов:

let text = "My Text"
let index = 2
let charSequence = text.unicodeScalars.map{ Character($0) }
let char = charSequence[index]

Это способ получить char по указанному индексу в постоянное время.

Приведенный ниже пример не выполняется в постоянное время, но требует линейного времени. Итак, если у вас много поиска в String по индексу, используйте метод выше.

let char = text[text.startIndex.advancedBy(index)]

Marcin Kapusta 10 март 2016, в 17:10

1

Питон-подобное решение, которое позволяет использовать отрицательный индекс,

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

может быть:

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

Кстати, это может стоить транспонировать целую ноту фрагмента питона

Joseph Merdrignac 08 нояб. 2015, в 23:14

0

Вы не возражаете написать что-то, что компилируется для Swift 4? последнее возвращение ... строка, похоже, не работает.
c1pherB1t 11 окт. 2018, в 19:00

1

Получите первое письмо:

first(str) // retrieve first letter

Подробнее здесь: http://sketchytech.blogspot.com/2014/08/swift-pure-swift-method-for-returning.html

philippinedev 27 нояб. 2014, в 07:38

1

Тип Swift String не предоставляет метод characterAtIndex, поскольку существует несколько способов кодирования строки Unicode. Вы собираетесь с UTF8, UTF16 или еще чем-нибудь?

Вы можете получить доступ к коллекциям CodeUnit, получив свойства String.utf8 и String.utf16. Вы также можете получить доступ к коллекции UnicodeScalar, получив свойство String.unicodeScalars.

В духе реализации NSString я возвращаю тип unichar.

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]

Erik 07 июнь 2014, в 08:09

0

Это не удастся для символов, которые требуют больше памяти, чем 16 бит. По сути, любой символ Unicode, кроме U + FFFF.
rmaddy 25 май 2017, в 02:50

0

Swift 4.2

Этот ответ является идеальным, поскольку он расширяет String и все его Subsequences (Substring) в одном расширении

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

использование

var str = "Hello, playground"

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

Noah Wilder 17 дек. 2018, в 22:56

0

Это излишне смещает оба индекса ( start и end ) из startIndex . Вы можете просто сместить end индекс с помощью range.count и сместить start индекс
Leo Dabus 19 дек. 2018, в 00:24

0

Включите это расширение в свой проект

  extension String{
func trim() -> String
{
    return self.trimmingCharacters(in: NSCharacterSet.whitespaces)
}

var length: Int {
    return self.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])
}

func substring(fromIndex: Int, toIndex:Int)->String{
    let startIndex = self.index(self.startIndex, offsetBy: fromIndex)
    let endIndex = self.index(startIndex, offsetBy: toIndex-fromIndex)

    return String(self[startIndex...endIndex])
}

Затем используйте функцию, подобную этой

let str = "Sample-String"

let substring = str.substring(fromIndex: 0, toIndex: 0) //returns S
let sampleSubstr = str.substring(fromIndex: 0, toIndex: 5) //returns Sample

AkilRajdho 27 март 2018, в 19:28

0

Swift 3:

extension String {
    func substring(fromPosition: UInt, toPosition: UInt) -> String? {
        guard fromPosition <= toPosition else {
            return nil
        }

        guard toPosition < UInt(characters.count) else {
            return nil
        }

        let start = index(startIndex, offsetBy: String.IndexDistance(fromPosition))
        let end   = index(startIndex, offsetBy: String.IndexDistance(toPosition) + 1)
        let range = start..<end

        return substring(with: range)
    }
}

"ffaabbcc".substring(fromPosition: 2, toPosition: 5) // return "aabb"

Daniele Ceglia 29 май 2017, в 12:51

0

Здесь вы можете использовать расширение, работая с Swift 3.1. Один индекс возвращает Character, который кажется интуитивным при индексировании a String, а a Range возвращает String.

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

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

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

Некоторые примеры расширения в действии:

let string = "Hello"

let c1 = string[1]  // Character "e"
let c2 = string[-1] // fatal error: Index out of range

let r1 = string[1..<4] // String "ell"
let r2 = string[1...4] // String "ello"
let r3 = string[1...5] // fatal error: Array index is out of range

n.b. Вы можете добавить дополнительный метод к вышеуказанному расширению, чтобы вернуть String с единственным символом, если захотите:

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

Обратите внимание, что тогда вам нужно будет явно указать тип, который вам нужен, при индексировании строки:

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

Matt Le Fleur 11 апр. 2017, в 10:04

0

Разрешает отрицательные индексы

Всегда полезно не всегда писать string[string.length - 1], чтобы получить последний символ при использовании расширения подстроки. Это расширение (Swift 3) позволяет использовать отрицательные индексы, Range и CountableClosedRange.

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

    subscript (i: Int) -> Character {
        // wraps out of bounds indices
        let j = i % self.count
        // wraps negative indices
        let x = j < 0 ? j + self.count : j

        // quick exit for first
        guard x != 0 else {
            return self.characters.first!
        }

        // quick exit for last
        guard x != count - 1 else {
            return self.characters.last!
        }

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

    subscript (r: Range<Int>) -> String {
        let lb = r.lowerBound
        let ub = r.upperBound

        // quick exit for one character
        guard lb != ub else { return String(self[lb]) }

        return self[self.index(self.startIndex, offsetBy: lb)..<self.index(self.startIndex, offsetBy: ub)]
    }

    subscript (r: CountableClosedRange<Int>) -> String {
        return self[r.lowerBound..<r.upperBound + 1]
    }
}

Как вы можете его использовать:

var text = "Hello World"

text[-1]    // d
text[2]     // l
text[12]    // e
text[0...4] // Hello
text[0..<4] // Hell

Для более тщательного программиста: включите guard в пустые строки в этом расширении

subscript (i: Int) -> Character {
    guard self.count != 0 else { return '' }
    ...
}

subscript (r: Range<Int>) -> String {
    guard self.count != 0 else { return "" }
    ...
}

Jay Harris 21 март 2017, в 07:08

0

Я хотел указать, что если у вас есть большая строка и вам нужно случайно получить доступ ко многим символам, вы можете заплатить дополнительную стоимость памяти и преобразовать строку в массив для лучшей производительности:

// Pay up front for O(N) memory
let chars = Array(veryLargeString.characters)

for i in 0...veryLargeNumber {
    // Benefit from O(1) access
    print(chars[i])
}

Joseph Chen 16 окт. 2016, в 07:37

0

Для этого вы можете использовать SwiftString (https://github.com/amayne/SwiftString).

"Hello, world!"[0] // H
"Hello, world!"[0...4] // Hello

ОТКАЗ ОТ ОТВЕТСТВЕННОСТИ: Я написал это расширение

eurobrew 06 фев. 2016, в 17:51

Ещё вопросы

Похоже, что сообщение об ошибке «не может подписать строку с помощью Int, см. Комментарий к документации для обсуждения» относится к github.com/apple/swift/blob/master/stdlib/public/core/…
изменить range.upperBound - range.lowerBound на range.count
Это не часть первоначального вопроса, но ... было бы неплохо, если бы это поддерживало назначение. Например, s [i] = "a" :).
Я считаю, что с Swift 4.2 подписки снова недоступны. Я получаю сообщение об ошибке: «подписка» недоступна: невозможно подписать строку с помощью Int, см. Комментарий к документации для обсуждения
@ChrisPrince extension StringProtocol where Self: RangeReplaceableCollection { subscript(offset: Int) -> Element { get { return self[index(startIndex, offsetBy: offset)] } set { let start = index(startIndex, offsetBy: offset) replaceSubrange(start..<index(after: start), with: [newValue]) } } }
String индексы уникальны для строки. Это связано с тем, что разные строки могут иметь разные многокомпонентные Characters UTF-16 и / или в разных позициях, поэтому индексы единиц UTF-16 не будут совпадать, могут выходить за пределы конца или точки внутри многозначного Character UTF-16.
Объясняя, почему вы говорите: «иногда это приводит к сбою или приводит к неопределенному поведению». Возможно, лучше сказать, просто не делай этого, потому что ...
@Sulthan .. сейчас ..< (в вашем назначении на range )
В отгрузочной версии Swift string[string.endIndex] приводит к EXC_BAD_INSTRUCTION, очевидно, так как string.endIndex находится в одном месте за концом строки. string[string.endIndex-1] не работает, так как String.Index не является IntegerConvertible. Как мы получаем последний символ строки?
@CajunLuke Я знаю, что прошло много времени с тех пор, как вы оставили этот комментарий, но взгляните на этот ответ . Вы можете использовать var lastChar = string[string.endIndex.predecessor()]
Это хороший быстрый обходной путь для (обычного) случая, когда вы знаете, что у вас есть строки в кодировке UTF8 или ASCII. Просто убедитесь, что строки никогда не будут в кодировке, которая использует более одного байта.
Это кажется крайне неэффективным, поскольку вы копируете всю строку только для того, чтобы получить первый символ. Используйте строку [строка. startIndex] вместо 0, как указал Султан.
Развернуть строку: var firstChar = Array(string!)[0] В противном случае будет указано add arrayLiteral
Это действительно должен быть принятый ответ. Это эффективно и чисто, и работает отлично.
Я не считаю, что это чисто, на самом деле это кругом. Я не совсем уверен, какой инициализатор в Array используется первым, что вызывает это (и я предполагаю, что это инициализатор SequenceType, заставляющий его собирать символы строки как отдельные компоненты для Array). Это совсем не явно и может быть исправлено в будущем без приведения типов. Это также не работает, если вы используете сокращение для массива через [string] .first. Решение @ Sulthan лучше всего использует запеченные в значениях индекса. Намного яснее, что здесь происходит.
Вау, ошибка сегмента компилятора!
Это не работает с Swift 3: argument type 'String' does not conform to expected type 'Sequence' . Сначала вам нужно получить CharacterView для строки, а затем индексировать ее массив: Array(str.characters)[0] или String(Array(str.characters)[0]) если вы хотите сохранить тип String.
Могу я спросить, что такое «self [index (startIndex, offsetBy: i)]»? И как работает «я [я]»?
Привет, Лео, спасибо за решение! Я только что (сегодня) переключился с Swift 2.3 на 3, и ваш индекс решения (диапазон: Range <Int>) выдает ошибку «Дополнительный аргумент« limitedBy »в вызове». Что вы думаете может быть не так?
@ АхметАккёк, ты уверен, что не менял код?
@ Оказалось, что я не конвертировал весь проект, но в приложении, а не в расширении, я повторил процесс как для приложения, так и для расширения, и теперь он работает нормально. Ваша помощь очень ценится!
это очень сложный код. В чем преимущество по сравнению с return String(Array(characters)[range]) в Swift 3?
Почему вы решили вернуть SubSequence а не значение, подобное SubString или String ?
Я расширяю протокол, а не тип (String), поэтому вам нужно вернуть SubSequence, которая в случае String является Substring.
Вы уже можете перебирать строки: для буквы в "foo" {println (letter)}
@Doobeh Я имел в виду цикл через и вернуть реальный символ, как в моем редактировании выше
отлично! Забавно, как вы можете проходить через это, но не через индекс. Свифт чувствует себя питоническим, но с более жесткими краями.
Я обнаружил, что использование myString.bridgeToObjectiveC().characterAtIndex(0) или (string as NSString ).characterAtIndex(0) возвращает значение Int для символа
@markhunte Это хороший момент. Еще один аргумент в моей голове, чтобы использовать нативный метод
Не используйте методы NSString для доступа к отдельным символам из String Swift-native - оба используют разные механизмы подсчета, поэтому вы получите непредсказуемые результаты с более высокими символами Unicode. Первый метод должен быть безопасным (после обработки ошибок Юникода в Swift).
@NateCook ты прав. Я удалил второй вариант
Как насчет "for (cur, char) в enumerate (self) {}"?
Это не работает для многих эмодзи и других персонажей, которые на самом деле занимают более одного раза «персонаж» в NSString .
Разве это не то же самое, что var charAtIndex = string[advance(string.startIndex, 10)] в ответе Султана?
Да, это то же самое решение с другим примером, как сказал Султан. Извините за дубликат. :) Легко два человека нашли то же самое.
единственный недостаток - CountableClosedRange сместит оба индекса из startIndex
stackoverflow.com/a/38215613/4573247 теперь расширяет StringProtocol для поддержки подстрок
Swift 4.2 DefaultBidirectionalIndices был переименован в DefaultIndices
@LeoDabus спасибо! Выпущен ли сейчас Swift 4.2?
Еще нет. Может быть через 10-14 дней. Вы программируете на Linux?
@ LeoDabus я вижу. Да, в основном это linux, но не сильно Swift в эти дни: / Когда я использую swiftenv , я думаю, что он будет обновлен до 4.2 также довольно скоро.
mystring даже не содержит свойства, называемое символами в Swift 3
Хотя эти комментарии становятся немного странными, код работает. Это не полный ответ, но .characters это вещь. @Ankahathara ты проверял это на детской площадке?
Спасибо человек, это очень круто. Мне действительно удалось повторить ответ Лео сверху в одной строке для каждого метода, например, return String(Array(characters)[range]) ... отличные вещи!
Только сработал ответ за меня. (Swift 2.3)
Вы не возражаете написать что-то, что компилируется для Swift 4? последнее возвращение ... строка, похоже, не работает.
Это не удастся для символов, которые требуют больше памяти, чем 16 бит. По сути, любой символ Unicode, кроме U + FFFF.
Это излишне смещает оба индекса ( start и end ) из startIndex . Вы можете просто сместить end индекс с помощью range.count и сместить start индекс

aleclarson · Accepted Answer · 2014-06-10T16-27-00.000Z

Внимание: см. Ответ Leo Dabus для правильной реализации для Swift 4.

Swift 4

Тип Substring был введен в Swift 4, чтобы сделать подстроки быстрее и эффективнее, используя хранилище с исходной строкой, чтобы возвращались функции подстрочного индекса.

Попробуйте здесь

extension String {
  subscript (i: Int) -> Character {
    return self[index(startIndex, offsetBy: i)]
  }
  subscript (bounds: CountableRange<Int>) -> Substring {
    let start = index(startIndex, offsetBy: bounds.lowerBound)
    let end = index(startIndex, offsetBy: bounds.upperBound)
    return self[start ..< end]
  }
  subscript (bounds: CountableClosedRange<Int>) -> Substring {
    let start = index(startIndex, offsetBy: bounds.lowerBound)
    let end = index(startIndex, offsetBy: bounds.upperBound)
    return self[start ... end]
  }
  subscript (bounds: CountablePartialRangeFrom<Int>) -> Substring {
    let start = index(startIndex, offsetBy: bounds.lowerBound)
    let end = index(endIndex, offsetBy: -1)
    return self[start ... end]
  }
  subscript (bounds: PartialRangeThrough<Int>) -> Substring {
    let end = index(startIndex, offsetBy: bounds.upperBound)
    return self[startIndex ... end]
  }
  subscript (bounds: PartialRangeUpTo<Int>) -> Substring {
    let end = index(startIndex, offsetBy: bounds.upperBound)
    return self[startIndex ..< end]
  }
}
extension Substring {
  subscript (i: Int) -> Character {
    return self[index(startIndex, offsetBy: i)]
  }
  subscript (bounds: CountableRange<Int>) -> Substring {
    let start = index(startIndex, offsetBy: bounds.lowerBound)
    let end = index(startIndex, offsetBy: bounds.upperBound)
    return self[start ..< end]
  }
  subscript (bounds: CountableClosedRange<Int>) -> Substring {
    let start = index(startIndex, offsetBy: bounds.lowerBound)
    let end = index(startIndex, offsetBy: bounds.upperBound)
    return self[start ... end]
  }
  subscript (bounds: CountablePartialRangeFrom<Int>) -> Substring {
    let start = index(startIndex, offsetBy: bounds.lowerBound)
    let end = index(endIndex, offsetBy: -1)
    return self[start ... end]
  }
  subscript (bounds: PartialRangeThrough<Int>) -> Substring {
    let end = index(startIndex, offsetBy: bounds.upperBound)
    return self[startIndex ... end]
  }
  subscript (bounds: PartialRangeUpTo<Int>) -> Substring {
    let end = index(startIndex, offsetBy: bounds.upperBound)
    return self[startIndex ..< end]
  }
}

Чтобы преобразовать Substring в String, вы можете просто создать String String(string[0..2]), но вы должны сделать это только в том случае, если вы планируете поддерживать подстроку. В противном случае, более эффективно поддерживать Substring.

Было бы здорово, если бы кто-то мог найти хороший способ объединить эти два расширения в один. Я попытался расширить StringProtocol без успеха, потому что index метод там не существует.

Swift 3:

extension String {
  subscript (i: Int) -> Character {
    return self[index(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[Range(start ..< end)]
  }
}

Почему это не встроено?

Apple предоставляет следующее объяснение (найдено здесь):

Подписные строки с целыми числами недоступны.

Понятие " i й символ в строке" имеет разные интерпретации в разных библиотеках и системных компонентах. Правильная интерпретация должна быть выбрана в соответствии с используемым случаем и задействованными API, поэтому String не может быть индексировано с целым числом.

Swift предоставляет несколько различных способов доступа к символьным данным, хранящимся внутри строк.

String.utf8 - это набор кодовых блоков UTF-8 в строке. Используйте этот API при преобразовании строки в UTF-8. Большинство API-интерфейсов POSIX обрабатывают строки в единицах кода UTF-8.

String.utf16 - это набор кодовых блоков UTF-16 в строке. Большинство API-интерфейсов Cocoa и Cocoa touch обрабатывают строки в единицах кода UTF-16. Например, экземпляры NSRange используемые с NSAttributedString и NSRegularExpression хранят подстроки и длины в единицах кода UTF-16.

String.unicodeScalars - это набор String.unicodeScalars Unicode. Используйте этот API при выполнении низкоуровневых манипуляций с символьными данными.

String.characters - это совокупность расширенных кластеров графемы, которые являются приближением воспринимаемых пользователем символов.
Обратите внимание, что при обработке строк, содержащих текст, читаемый человеком, следует избегать в любом случае пошаговую обработку. Вместо этого используйте высокоуровневые языковые алгоритмы Unicode, например String.localizedStandardCompare(), String.localizedLowercaseString, String.localizedStandardRangeOfString() и т.д.

Правильно, но это не делает адаптацию диапазона для нарезки строки, которую вышеуказанное решение решает так элегантно.
Cannot find an overload for 'advance' that accepts an argument list of type '(String.Index, T)' ... String.Index и Int несовместимы.
@ Барри Это более чем вероятно из-за выпуска Swift 2.0. Сейчас я не использую Swift, поэтому, если кто-то сможет обновить этот ответ, я уверен, что люди это оценят.
Разве возвращаемый тип не должен быть необязательным символом?
Если вы видите Cannot subscript a value of type 'String'... проверьте этот ответ: stackoverflow.com/a/31265316/649379
последняя операция может серьезно улучшить производительность, сначала получив начальный индекс как let start = startIndex.advancedBy(r.startIndex) и используя его в качестве начальной точки для конечного индекса let end = start.advanceBy(r.endIndex - r.startIndex) ,
Кажется, вы можете заменить return substringWithRange(Range(start: startIndex.advancedBy(r.startIndex), end: startIndex.advancedBy(r.endIndex))) на return self[Range(start: startIndex.advancedBy(r.startIndex), end: startIndex.advancedBy(r.endIndex))]
Когда я пытаюсь использовать это, я получаю Ambiguous use of 'subscript' .
@aleclarson Похоже, у этого будут некоторые проблемы со Swift 3. init(start:end:) устарела.
Почему вы используете "==="? Это тождественный оператор для объектов, не сравнивающих значения.
ПРЕДУПРЕЖДЕНИЕ! Расширение ниже ужасно неэффективно. Каждый раз, когда к строке обращаются с помощью целого числа, запускается функция O (n) для продвижения ее начального индекса. Запуск линейного цикла внутри другого линейного цикла означает, что этот цикл for случайно равен O (n2) - поскольку длина строки увеличивается, время, которое занимает этот цикл, увеличивается квадратично. Вместо этого вы можете использовать коллекцию строк символов.
@ignaciohugog Как вы думаете, String.CharacterView.Index.successor () - это O (1) или O (N)? Я не смог найти информацию о O () для .successor () или .predecessor (). Благодарю.
Могу ли я добавить это в файл утилит, который я делаю, и в конце концов хочу передать на GitHub?
Я получаю пару ошибок при попытке использовать это с xCode 8
Для тех, кто получает Ambiguous use of 'subscript' typehint Ambiguous use of 'subscript' для типа переменной, поскольку "someString"[5] может возвращать либо String, либо Character с указанными индексами. Вы должны сказать ему, что вам нужно. @jowie
Я не совсем понимаю. Так есть ли случай, когда ответ Swift3 не будет работать? Если не то, что сделал Apple, не имеет смысла
Проверьте мой ответ, он использует то же самое (кредит @alecarlson ), но вы можете get и set индекс.
Этот метод, так как он излишне смещает обе границы из startIndex. То, что вы должны сделать, чтобы избежать смещения endIndex, начиная с начального (не startIndex) смещения счетчиком диапазона. Что касается расширения подписки StringProtocol, я уже разместил его.
@LeoDabus Я отредактировал свой ответ, чтобы рекомендовать твой. Хорошая работа!
@aleclarson Просто измените startIndex на start и upperBound для подсчета при определении индекса конца. Это, вероятно, причина 20 отрицательных голосов. Также использование персонажа в персонаже в вашей версии Swift 3 бессмысленно
@ LeoDabus Не стесняйтесь вносить эти изменения самостоятельно, вместо того, чтобы говорить мне об этом. :)
@ignaciohugog подожди. Я думаю, что это в конечном итоге больше похоже на O (n!)

Получить n-й символ строки в языке программирования Swift

38 ответов

Swift 4

Попробуйте здесь

Swift 3:

Почему это не встроено?

Swift 4.2 и ранее

Swift 4

Swift 2 и 3

Swift 2.2 Решение:

Получить и установить индекс (строка и подстрока) - Swift 4.2

Swift 4.2, Xcode 10

Расширение:

Swift 4

Диапазон и частичный диапазон индексирование с использованием String indices свойства

Swift 4.2.

Swift 4.2

использование

Ещё вопросы

Диапазон и частичный диапазон индексирование с использованием `String` `indices` свойства