Як ви використовуєте String.substringWithRange? (або як працюють дальність у Swift?)

Я ще не зміг зрозуміти, як отримати підрядку a Stringу Swift:

var str = “Hello, playground”
func test(str: String) -> String {
 return str.substringWithRange( /* What goes here? */ )
}
test (str)

Я не в змозі створити діапазон у Свіфті. Автозаповнення на дитячому майданчику не дуже корисно - ось що пропонує:

return str.substringWithRange(aRange: Range<String.Index>)

Я не знайшов нічого в стандартній довідковій бібліотеці Swift, що допомагає. Ось ще одна дика здогадка:

return str.substringWithRange(Range(0, 1))

І це:

let r:Range<String.Index> = Range<String.Index>(start: 0, end: 2)
return str.substringWithRange(r)

Я бачив інші відповіді ( Знаходження індексу символів у Swift String ), які, здається, підказують, що оскільки Stringце тип мосту NSString, "старі" методи повинні працювати, але незрозуміло, як - наприклад, це також не працює ( не здається правильним синтаксисом):

let x = str.substringWithRange(NSMakeRange(0, 3))

Думки?

Можна використовувати метод substringWithRange. Це займає початок і кінець String.Index.

var str = "Hello, playground"
str.substringWithRange(Range<String.Index>(start: str.startIndex, end: str.endIndex)) //"Hello, playground"

Щоб змінити індекс початку і кінця, використовуйте AdvancedBy (n).

var str = "Hello, playground"
str.substringWithRange(Range<String.Index>(start: str.startIndex.advancedBy(2), end: str.endIndex.advancedBy(-1))) //"llo, playgroun"

Ви також можете використовувати метод NSString з NSRange, але ви повинні переконатися, що ви використовуєте NSString так:

let myNSString = str as NSString
myNSString.substringWithRange(NSRange(location: 0, length: 3))

Примітка: як згадував JanX2, цей другий спосіб не є безпечним для рядків Unicode.

Швидкий 2

Простий

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

Швидкий 3

let startIndex = str.index(str.startIndex, offsetBy: 3)
let endIndex = str.index(str.startIndex, offsetBy: 7)

str[startIndex...endIndex]       // "Strin"
str.substring(to: startIndex)    // "My "
str.substring(from: startIndex)  // "String"

Швидкий 4

substring(to:)і substring(from:)застарілі в Росії Swift 4.

String(str[..<startIndex])    // "My "
String(str[startIndex...])    // "String"
String(str[startIndex...endIndex])    // "Strin"

ПРИМІТКА: @airspeedswift робить дуже проникливі моменти щодо компромісів цього підходу, зокрема прихованих наслідків щодо продуктивності. Рядки не є простими звірами, і потрапляння на певний індекс може зайняти O (n) час, а це означає, що цикл, який використовує індекс, може бути O (n ^ 2). Вас попередили

Вам просто потрібно додати нову subscriptфункцію, яка займає діапазон і використовує advancedBy()для переходу туди, куди ви хочете:

import Foundation

extension String {
    subscript (r: Range<Int>) -> String {
        get {
            let startIndex = self.startIndex.advancedBy(r.startIndex)
            let endIndex = startIndex.advancedBy(r.endIndex - r.startIndex)

            return self[Range(start: startIndex, end: endIndex)]
        }
    }
}

var s = "Hello, playground"

println(s[0...5]) // ==> "Hello,"
println(s[0..<5]) // ==> "Hello"

(Це обов'язково має бути частиною мови. Будь ласка, dupe rdar: // 17158813 )

Для розваги можна також додати +оператора до індексів:

func +<T: ForwardIndex>(var index: T, var count: Int) -> T {
  for (; count > 0; --count) {
    index = index.succ()
  }
  return index
}

s.substringWithRange(s.startIndex+2 .. s.startIndex+5)

(Я ще не знаю, чи ця мова повинна бути частиною мови чи ні.)

На той момент, коли я пишу, жодне розширення не є ідеально сумісним Swift 4.2 , тож ось одне, яке охоплює всі потреби, про які я міг придумати:

extension String {
    func substring(from: Int?, to: Int?) -> String {
        if let start = from {
            guard start < self.count else {
                return ""
            }
        }

        if let end = to {
            guard end >= 0 else {
                return ""
            }
        }

        if let start = from, let end = to {
            guard end - start >= 0 else {
                return ""
            }
        }

        let startIndex: String.Index
        if let start = from, start >= 0 {
            startIndex = self.index(self.startIndex, offsetBy: start)
        } else {
            startIndex = self.startIndex
        }

        let endIndex: String.Index
        if let end = to, end >= 0, end < self.count {
            endIndex = self.index(self.startIndex, offsetBy: end + 1)
        } else {
            endIndex = self.endIndex
        }

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

    func substring(from: Int) -> String {
        return self.substring(from: from, to: nil)
    }

    func substring(to: Int) -> String {
        return self.substring(from: nil, to: to)
    }

    func substring(from: Int?, length: Int) -> String {
        guard length > 0 else {
            return ""
        }

        let end: Int
        if let start = from, start > 0 {
            end = start + length - 1
        } else {
            end = length - 1
        }

        return self.substring(from: from, to: end)
    }

    func substring(length: Int, to: Int?) -> String {
        guard let end = to, end > 0, length > 0 else {
            return ""
        }

        let start: Int
        if let end = to, end - length > 0 {
            start = end - length + 1
        } else {
            start = 0
        }

        return self.substring(from: start, to: to)
    }
}

І тоді ви можете використовувати:

let string = "Hello,World!"

string.substring(from: 1, to: 7)отримує тебе: ello,Wo

string.substring(to: 7)отримує тебе: Hello,Wo

string.substring(from: 3)отримує тебе: lo,World!

string.substring(from: 1, length: 4)отримує тебе: ello

string.substring(length: 4, to: 7)отримує тебе: o,Wo

Оновлено substring(from: Int?, length: Int)для підтримки, починаючи з нуля.

SWIFT 2.0

просто:

let myString = "full text container"
let substring = myString[myString.startIndex..<myString.startIndex.advancedBy(3)] // prints: ful

SWIFT 3.0

let substring = myString[myString.startIndex..<myString.index(myString.startIndex, offsetBy: 3)] // prints: ful

SWIFT 4.0

Операції з підрядкою повертають екземпляр типу Substring замість String.

let substring = myString[myString.startIndex..<myString.index(myString.startIndex, offsetBy: 3)] // prints: ful

// Convert the result to a String for long-term storage.
let newString = String(substring)

Це набагато простіше, ніж будь-яка відповідь тут, як тільки ви знайдете правильний синтаксис.

Я хочу забрати [і]

let myString = "[ABCDEFGHI]"
let startIndex = advance(myString.startIndex, 1) //advance as much as you like
let endIndex = advance(myString.endIndex, -1)
let range = startIndex..<endIndex
let myNewString = myString.substringWithRange( range )

Результатом буде "ABCDEFGHI", також можуть бути використані startIndex і endIndex

let mySubString = myString.substringFromIndex(startIndex)

і так далі!

PS: Як зазначено у зауваженні, у swift 2 є деякі зміни синтаксису, які поставляються з xcode 7 та iOS9!

Будь ласка, подивіться на цю сторінку

Наприклад, щоб знайти своє ім’я (до першого пробілу) у моєму повному імені:

let name = "Joris Kluivers"

let start = name.startIndex
let end = find(name, " ")

if end {
    let firstName = name[start..end!]
} else {
    // no space found
}

startі endвони є типом String.Indexтут і використовуються для створення Range<String.Index>і використовуються в аксесуарі підпису (якщо пробіл взагалі знайдено в початковій рядку).

Важко створити String.Indexбезпосередньо з цілої позиції, як використовується у вступному пості. Це тому, що в моєму імені кожен символ був би однакового розміру в байтах. Але символи, які використовують спеціальні наголоси на інших мовах, могли використати ще кілька байтів (залежно від використовуваного кодування). То до якого байта має відноситися ціле число?

Можна створити новий String.Indexз існуючого з використанням методів succі predякий буде переконатися , що правильне кількість байт, пропускається , щоб дістатися до наступного пункту коду в кодуванні. Однак у цьому випадку простіше шукати індекс першого пробілу в рядку, щоб знайти кінцевий індекс.

Оскільки String - це тип мосту для NSString, "старі" методи повинні працювати, але незрозуміло, як - наприклад, це також не працює (не здається, що це синтаксис):

 let x = str.substringWithRange(NSMakeRange(0, 3))

Для мене це справді цікава частина вашого запитання. Рядок є містком NSString, тому більшість методів NSString зробити роботу безпосередньо на String. Ви можете використовувати їх вільно і не замислюючись. Наприклад, наприклад, це працює так, як ви очікуєте:

// delete all spaces from Swift String stateName
stateName = stateName.stringByReplacingOccurrencesOfString(" ", withString:"")

Але, як це часто буває, "я працюю над моджо, але це просто не працює на вас". Щойно ви вибрали один з рідкісних випадків, коли існує паралельна однаково ім'я методу Swift , а в такому випадку метод Swift затьмарює метод Objective-C. Таким чином, коли ви говорите str.substringWithRange, Swift думає, що ви маєте на увазі метод Swift, а не метод NSString, - і тоді ви шлангуєте, тому що метод Swift очікує a Range<String.Index>, і ви не знаєте, як зробити один із них.

Найпростіший вихід - зупинити Swift від такого затьмарення, чітко відкидаючи:

let x = (str as NSString).substringWithRange(NSMakeRange(0, 3))

Зауважте, що тут не задіяно жодної значної додаткової роботи. "Cast" не означає "конвертувати"; Рядок - це фактично NSString. Ми просто розповідаємо Swift, як дивитися на цю змінну для цілей цього одного рядка коду.

Дійсно дивна частина всього цього полягає в тому, що метод Свіфта, який викликає всю цю неприємність, є недокументованим. Я не маю уявлення, де це визначено; це не в заголовку NSString, а також у заголовку Swift.

У новому використанні Xcode 7.0

//: Playground - noun: a place where people can play

import UIKit

var name = "How do you use String.substringWithRange?"
let range = name.startIndex.advancedBy(0)..<name.startIndex.advancedBy(10)
name.substringWithRange(range)

//OUT:

Коротка відповідь полягає в тому, що зараз у Свіфта це дуже важко. Моя думка полягає в тому, що перед Apple ще багато роботи над зручністю для таких речей.

String.substringWithRange()очікує Range<String.Index>параметр, і наскільки я можу сказати, немає методу генератора для String.Indexтипу. Ви можете отримати String.Indexзначення назад від aString.startIndexі aString.endIndexі зателефонувати .succ()або.pred() на них, але це безумство.

Як щодо розширення класу String, яке займає добрі старі Ints?

extension String {
    subscript (r: Range<Int>) -> String {
        get {
            let subStart = advance(self.startIndex, r.startIndex, self.endIndex)
            let subEnd = advance(subStart, r.endIndex - r.startIndex, self.endIndex)
            return self.substringWithRange(Range(start: subStart, end: subEnd))
        }
    }
    func substring(from: Int) -> String {
        let end = countElements(self)
        return self[from..<end]
    }
    func substring(from: Int, length: Int) -> String {
        let end = from + length
        return self[from..<end]
    }
}

let mobyDick = "Call me Ishmael."
println(mobyDick[8...14])             // Ishmael

let dogString = "This 🐶's name is Patch."
println(dogString[5..<6])               // 🐶
println(dogString[5...5])              // 🐶
println(dogString.substring(5))        // 🐶's name is Patch.
println(dogString.substring(5, length: 1))   // 🐶

Оновлення: Swift beta 4 вирішує проблеми нижче!

Як і раніше [у бета-версії 3 та новіших версій], навіть у рідних рядків Swift є деякі проблеми з обробкою символів Unicode. Піктограма собаки працювала вище, але наступне:

let harderString = "1:1️⃣"
for character in harderString {
    println(character)
}

Вихід:

1
:
1
️
⃣

Ви можете використовувати ці розширення для покращення substringWithRange

Швидкий 2.3

extension String
{   
    func substringWithRange(start: Int, end: Int) -> String
    {
        if (start < 0 || start > self.characters.count)
        {
            print("start index \(start) out of bounds")
            return ""
        }
        else if end < 0 || end > self.characters.count
        {
            print("end index \(end) out of bounds")
            return ""
        }
        let range = Range(start: self.startIndex.advancedBy(start), end: self.startIndex.advancedBy(end))
        return self.substringWithRange(range)
    }

    func substringWithRange(start: Int, location: Int) -> String
    {
        if (start < 0 || start > self.characters.count)
        {
            print("start index \(start) out of bounds")
            return ""
        }
        else if location < 0 || start + location > self.characters.count
        {
            print("end index \(start + location) out of bounds")
            return ""
        }
        let range = Range(start: self.startIndex.advancedBy(start), end: self.startIndex.advancedBy(start + location))
        return self.substringWithRange(range)
    }
}

Швидкий 3

extension String
{
    func substring(start: Int, end: Int) -> String
    {
        if (start < 0 || start > self.characters.count)
        {
            print("start index \(start) out of bounds")
            return ""
        }
        else if end < 0 || end > self.characters.count
        {
            print("end index \(end) out of bounds")
            return ""
        }
        let startIndex = self.characters.index(self.startIndex, offsetBy: start)
        let endIndex = self.characters.index(self.startIndex, offsetBy: end)
        let range = startIndex..<endIndex

        return self.substring(with: range)
    }

    func substring(start: Int, location: Int) -> String
    {
        if (start < 0 || start > self.characters.count)
        {
            print("start index \(start) out of bounds")
            return ""
        }
        else if location < 0 || start + location > self.characters.count
        {
            print("end index \(start + location) out of bounds")
            return ""
        }
        let startIndex = self.characters.index(self.startIndex, offsetBy: start)
        let endIndex = self.characters.index(self.startIndex, offsetBy: start + location)
        let range = startIndex..<endIndex

        return self.substring(with: range)
    }
}

Використання:

let str = "Hello, playground"

let substring1 = str.substringWithRange(0, end: 5) //Hello
let substring2 = str.substringWithRange(7, location: 10) //playground

Приклад коду, як отримати підрядку в Swift 2.0

(i) Підряд з початкового індексу

Вхід: -

var str = "Swift is very powerful language!"
print(str)

str = str.substringToIndex(str.startIndex.advancedBy(5))
print(str)

Вихід: -

Swift is very powerful language!
Swift

(ii) Підстроковим рядком з певного індексу

Вхід: -

var str = "Swift is very powerful language!"
print(str)

str = str.substringFromIndex(str.startIndex.advancedBy(6)).substringToIndex(str.startIndex.advancedBy(2))
print(str)

Вихід: -

Swift is very powerful language!
is

Сподіваюся, це допоможе тобі!

Просте рішення з невеликим кодом.

Зробіть розширення, що включає в себе базову підстрокову структуру, яку мають майже всі інші мови:

extension String {
    func subString(start: Int, end: Int) -> String {
        let startIndex = self.index(self.startIndex, offsetBy: start)
        let endIndex = self.index(startIndex, offsetBy: end)

        let finalString = self.substring(from: startIndex)
        return finalString.substring(to: endIndex)
    }
}

Просто подзвоніть це за допомогою

someString.subString(start: 0, end: 6)

Це працює на моєму майданчику :)

String(seq: Array(str)[2...4])

Оновлено для Xcode 7. Додає розширення String:

Використання:

var chuck: String = "Hello Chuck Norris"
chuck[6...11] // => Chuck

Впровадження:

extension String {

    /**
     Subscript to allow for quick String substrings ["Hello"][0...1] = "He"
     */
    subscript (r: Range<Int>) -> String {
        get {
            let start = self.startIndex.advancedBy(r.startIndex)
            let end = self.startIndex.advancedBy(r.endIndex - 1)
            return self.substringWithRange(start..<end)
        }
    }

}

спробуйте це на дитячому майданчику

var str:String = "Hello, playground"

let range = Range(start:advance(str.startIndex,1), end: advance(str.startIndex,8))

це дасть вам "Елло, р"

Однак, коли це стає справді цікавим, це те, що якщо ви зробите останній індекс більшим за рядок на ігровому майданчику, він покаже будь-які рядки, які ви визначили після str: o

Range (), здається, є загальною функцією, тому йому потрібно знати тип, з яким він має справу.

Ви також повинні надати йому фактичну нитку, яка зацікавлена ​​у вас на ігрових майданчиках, оскільки, здається, утримуються всі струни в послідовності одна за одною з назвою змінної згодом.

Так

var str:String = "Hello, playground"

var str2:String = "I'm the next string"

let range = Range(start:advance(str.startIndex,1), end: advance(str.startIndex,49))

дає «Елло, майданчик str Я я наступний рядок str2 »

працює, навіть якщо str2 визначено let

:)

Роб Неп'є вже дав приголомшливу відповідь, використовуючи підпис. Але я відчув один недолік у тому, що немає перевірки на невиконання умов. Це може призвести до краху. Тож я змінив розширення і ось воно

extension String {
    subscript (r: Range<Int>) -> String? { //Optional String as return value
        get {
            let stringCount = self.characters.count as Int
            //Check for out of boundary condition
            if (stringCount < r.endIndex) || (stringCount < r.startIndex){
                return nil
            }
            let startIndex = self.startIndex.advancedBy(r.startIndex)

            let endIndex = self.startIndex.advancedBy(r.endIndex - r.startIndex)

            return self[Range(start: startIndex, end: endIndex)]
        }
    }
}

Вихід нижче

var str2 = "Hello, World"

var str3 = str2[0...5]
//Hello,
var str4 = str2[0..<5]
//Hello
var str5 = str2[0..<15]
//nil

Тому я пропоную завжди перевіряти, чи дозволяю

if let string = str[0...5]
{
    //Manipulate your string safely
}

В Swift3

Наприклад: змінна "Герцог Джеймс Томас", нам потрібно отримати "Джеймс".

let name = "Duke James Thomas"
let range: Range<String.Index> = name.range(of:"James")!
let lastrange: Range<String.Index> = img.range(of:"Thomas")!
var middlename = name[range.lowerBound..<lstrange.lowerBound]
print (middlename)

Зробивши сторінку від Rob Napier, я розробив ці поширені розширення для рядків , два з яких:

subscript (r: Range<Int>) -> String
{
    get {
        let startIndex = advance(self.startIndex, r.startIndex)
        let endIndex = advance(self.startIndex, r.endIndex - 1)

        return self[Range(start: startIndex, end: endIndex)]
    }
}

func subString(startIndex: Int, length: Int) -> String
{
    var start = advance(self.startIndex, startIndex)
    var end = advance(self.startIndex, startIndex + length)
    return self.substringWithRange(Range<String.Index>(start: start, end: end))
}

Використання:

"Awesome"[3...7] //"some"
"Awesome".subString(3, length: 4) //"some"

Ось як ви отримуєте діапазон від рядка:

var str = "Hello, playground"

let startIndex = advance(str.startIndex, 1)
let endIndex = advance(startIndex, 8)
let range = startIndex..<endIndex
let substr = str[range] //"ello, pl"

Ключовим моментом є те, що ви передаєте діапазон значень типу String.Index (це те, що повертається заздалегідь) замість цілих чисел.

Причина, чому це необхідно, полягає в тому, що рядки в Swift не мають випадкового доступу (в основному через змінну довжину символів Unicode). Ви також не можете робити str[1]. String.Index призначений для роботи зі своєю внутрішньою структурою.

Ви можете створити розширення за допомогою індекса, але це робить для вас, так що ви можете просто передати ряд цілих чисел (див., Наприклад , відповідь Роб Неп'є ).

Я намагався придумати щось піфонічне.

Усі підписки тут чудові, але час, коли мені справді потрібно щось просте, зазвичай, коли я хочу рахувати ззаду, наприклад string.endIndex.advancedBy(-1)

Він підтримує nilзначення, як для початкового, так і для кінцевого індексів, де nilозначав би індекс у 0 для початку, string.characters.countдля кінця.

extension String {
    var subString: (Int?) -> (Int?) -> String {
        return { (start) in
            { (end) in
                let startIndex = start ?? 0 < 0 ? self.endIndex.advancedBy(start!) : self.startIndex.advancedBy(start ?? 0)
                let endIndex = end ?? self.characters.count < 0 ? self.endIndex.advancedBy(end!) : self.startIndex.advancedBy(end ?? self.characters.count)

                return startIndex > endIndex ? "" : self.substringWithRange(startIndex ..< endIndex)
            }
        }
    }
}

let dog = "Dog‼🐶"
print(dog.subString(nil)(-1)) // Dog!!

EDIT

Більш елегантне рішення:

public extension String {
    struct Substring {
        var start: Int?
        var string: String

        public subscript(end: Int?) -> String {
            let startIndex = start ?? 0 < 0 ? string.endIndex.advancedBy(start!) : string.startIndex.advancedBy(start ?? 0)
            let endIndex = end ?? string.characters.count < 0 ? string.endIndex.advancedBy(end!) : string.startIndex.advancedBy(end ?? string.characters.count)

            return startIndex > endIndex ? "" : string.substringWithRange(startIndex ..< endIndex)
        }
    }

    public subscript(start: Int?) -> Substring {
        return Substring(start: start, string: self)
    }
}

let dog = "Dog‼🐶"
print(dog[nil][-1]) // Dog!!

Спочатку створіть діапазон, потім підрядку. Ви можете використовувати fromIndex..<toIndexсинтаксис так:

let range = fullString.startIndex..<fullString.startIndex.advancedBy(15) // 15 first characters of the string
let substring = fullString.substringWithRange(range)

ось приклад, як швидко отримати лише відео-ідентифікатор .ie (6oL687G0Iso) з усієї URL-адреси

let str = "https://www.youtube.com/watch?v=6oL687G0Iso&list=PLKmzL8Ib1gsT-5LN3V2h2H14wyBZTyvVL&index=2"
var arrSaprate = str.componentsSeparatedByString("v=")
let start = arrSaprate[1]
let rangeOfID = Range(start: start.startIndex,end:start.startIndex.advancedBy(11))
let substring = start[rangeOfID]
print(substring)

let startIndex = text.startIndex
var range = startIndex.advancedBy(1) ..< text.endIndex.advancedBy(-4)
let substring = text.substringWithRange(range)

Повний зразок ви можете побачити тут

http://www.learnswiftonline.com/reference-guides/string-reference-guide-for-swift/ показує, що це працює добре:

var str = "abcd"
str = str.substringToIndex(1)

Ну, у мене була та сама проблема, і я вирішив функцію "bridgeToObjectiveC ()":

var helloworld = "Hello World!"
var world = helloworld.bridgeToObjectiveC().substringWithRange(NSMakeRange(6,6))
println("\(world)") // should print World!

Зверніть увагу, що у прикладі substringWithRange спільно з NSMakeRange приймають частину рядка, починаючи з індексу 6 (символ "W") і закінчуючи на позиції індексу 6 + 6 попереду (символ "!")

Ура.

Ви можете використовувати будь-який із методів підрядки у розширенні Swift String, про яке я писав https://bit.ly/JString .

var string = "hello"
var sub = string.substringFrom(3) // or string[3...5]
println(sub)// "lo"

Якщо у вас є NSRange, мостика NSStringпрацює безперебійно. Наприклад, я робив певну роботу UITextFieldDelegateі мені швидко хотілося обчислити нове значення рядка, коли він запитав, чи слід замінити діапазон.

func textField(textField: UITextField, shouldChangeCharactersInRange range: NSRange, replacementString string: String) -> Bool {
    let newString = (textField.text as NSString).stringByReplacingCharactersInRange(range, withString: string)
    println("Got new string: ", newString)
}

Просте розширення для String:

extension String {

    func substringToIndex(index: Int) -> String {
        return self[startIndex...startIndex.advancedBy(min(index, characters.count - 1))]
    }
}

Якщо ви не дбаєте про продуктивність ... це, мабуть, найбільш стисле рішення у Swift 4

extension String {
    subscript(range: CountableClosedRange<Int>) -> String {
        return enumerated().filter{$0.offset >= range.first! && $0.offset < range.last!}
            .reduce(""){$0 + String($1.element)}
    }
}

Це дає змогу зробити щось подібне:

let myStr = "abcd"
myStr[0..<2] // produces "ab"