Jestem naprawdę sfrustrowany modelem dostępu strunowego Swifta: wszystko musi być Index. Chcę tylko uzyskać dostęp do i-tego znaku łańcucha za pomocą Int, a nie indeksu niezgrabnego i postępującego (co zdarza się zmieniać z każdym głównym wydaniem). Więc zrobiłem rozszerzenie do String:

extension String {
    func index(from: Int) -> Index {
        return self.index(startIndex, offsetBy: from)
    }

    func substring(from: Int) -> String {
        let fromIndex = index(from: from)
        return substring(from: fromIndex)
    }

    func substring(to: Int) -> String {
        let toIndex = index(from: to)
        return substring(to: toIndex)
    }

    func substring(with r: Range<Int>) -> String {
        let startIndex = index(from: r.lowerBound)
        let endIndex = index(from: r.upperBound)
        return substring(with: startIndex..<endIndex)
    }
}

let str = "Hello, playground"
print(str.substring(from: 7))         // playground
print(str.substring(to: 5))           // Hello
print(str.substring(with: 7..<11))    // play

Swift 4 Extension:

extension String { 
    subscript(_ range: CountableRange<Int>) -> String { 
        let idx1 = index(startIndex, offsetBy: max(0, range.lowerBound))
        let idx2 = index(startIndex, offsetBy: min(self.count, range.upperBound))
        return String(self[idx1..<idx2])
    }    
}       

Użycie:

let s = "hello"
s[0..<3] // "hel"
s[3..<s.count] // "lo"

Lub unicode:

let s = ""
s[0..<1] // ""

Swift 4

W swift 4 String odpowiada Collection. Zamiast substring, powinniśmy teraz użyć subscript., więc jeśli chcesz wyciąć tylko słowo "play" z "Hello, playground", możesz to zrobić tak:

var str = "Hello, playground"
let start = str.index(str.startIndex, offsetBy: 7)
let end = str.index(str.endIndex, offsetBy: -6)
let result = str[start..<end] // The result is of type Substring

To ciekawe wiedzieć, że to da Substring zamiast String. Jest to szybkie i wydajne, ponieważ Substring dzieli swoje przechowywanie z oryginalnym ciągiem. Jednak dzielenie pamięci w ten sposób może również łatwo prowadzić do wycieków pamięci.

Dlatego powinieneś skopiować uzyskaj wynik w nowy ciąg, gdy chcesz wyczyścić oryginalny ciąg. Można to zrobić za pomocą zwykłego konstruktora:

let newString = String(result)

Więcej informacji na temat nowej klasy Substring można znaleźć w [Dokumentacja Apple].1

Więc, jeśli na przykład otrzymasz Range w wyniku NSRegularExpression, możesz użyć następującego rozszerzenia:

extension String {

    subscript(_ range: NSRange) -> String {
        let start = self.index(self.startIndex, offsetBy: range.lowerBound)
        let end = self.index(self.startIndex, offsetBy: range.upperBound)
        let subString = self[start..<end]
        return String(subString)
    }

}

Miałem taką samą reakcję początkową. Ja też byłem sfrustrowany tym, jak składnia i Obiekty zmieniają się tak drastycznie w każdym większym wydaniu.

Jednak zdałem sobie sprawę z tego, że zawsze w końcu cierpię konsekwencje walki z "zmianą", jak radzenie sobie z wielobajtowymi postaciami, co jest nieuniknione, jeśli patrzysz na globalną publiczność.

Zamiast tworzyć rozszerzenia, które są tylko obejściem ułatwiającym życie (nie mówię, że są złe lub drogie), dlaczego nie dowiedzieć się, jak struny są teraz zaprojektowane do działania.

Na przykład miałem ten kod, który działał na Swift 2.2:

let rString = cString.substringToIndex(2)
let gString = (cString.substringFromIndex(2) as NSString).substringToIndex(2)
let bString = (cString.substringFromIndex(4) as NSString).substringToIndex(2)

I po rezygnacji z prób uzyskania tego samego podejścia działającego np. przy użyciu Podłańcuchów, w końcu zrozumiałem koncepcję traktowania ciągów jako zbioru dwukierunkowego dla którego skończyłem z tą wersją tego samego kodu:

let rString = String(cString.characters.prefix(2))
cString = String(cString.characters.dropFirst(2))
let gString = String(cString.characters.prefix(2))
cString = String(cString.characters.dropFirst(2))
let bString = String(cString.characters.prefix(2))

Jestem nowy w Swift 3, ale patrząc na składnię String (index) dla analogii myślę, że index jest jak "wskaźnik" ograniczony do string i Int może pomóc jako niezależny obiekt. Używając składni base + offset, wtedy możemy otrzymać i-ten znak z łańcucha o kodzie poniżej:

let s = "abcdefghi"
let i = 2
print (s[s.index(s.startIndex, offsetBy:i)])
// print c

Dla zakresu znaków (indeksów) od string używając składni String (range) możemy uzyskać od i-th do f-TH znaków z poniższym kodem:

let f = 6
print (s[s.index(s.startIndex, offsetBy:i )..<s.index(s.startIndex, offsetBy:f+1 )])
//print cdefg

Dla fragmentu (zakresu) łańcucha używając Sznurka.substring (zakres) możemy uzyskać substring używając poniższego kodu:

print (s.substring (with:s.index(s.startIndex, offsetBy:i )..<s.index(s.startIndex, offsetBy:f+1 ) ) )
//print cdefg

Uwagi:

1. I-th i F-TH zaczynają się od 0.

2. Do f-th, używam offsetBY: f + 1, ponieważ zakres użytkowania subskrypcji ..

3. Oczywiście musi zawierać błędy walidacji, takie jak invalid index.

Oto funkcja, która zwraca podłańcuch danego podłańcucha, gdy podane są indeksy początku i końca. Pełne informacje można znaleźć pod linkami podanymi poniżej.

func substring(string: String, fromIndex: Int, toIndex: Int) -> String? {
    if fromIndex < toIndex && toIndex < string.count /*use string.characters.count for swift3*/{
        let startIndex = string.index(string.startIndex, offsetBy: fromIndex)
        let endIndex = string.index(string.startIndex, offsetBy: toIndex)
        return String(string[startIndex..<endIndex])
    }else{
        return nil
    }
}

Oto link do wpisu na blogu, który stworzyłem, aby poradzić sobie z manipulacją strunami w swift. manipulacja strunami w języku swift (obejmuje również swift 4)

Możesz też zobaczyć ten gist na github

Ta sama frustracja, to nie powinno być takie trudne...

Skompilowałem ten przykład pobierania pozycji dla podłańcuchów z większego tekstu:

//
// Play with finding substrings returning an array of the non-unique words and positions in text
//
//

import UIKit

let Bigstring = "Why is it so hard to find substrings in Swift3"
let searchStrs : Array<String>? = ["Why", "substrings", "Swift3"]

FindSubString(inputStr: Bigstring, subStrings: searchStrs)


func FindSubString(inputStr : String, subStrings: Array<String>?) ->    Array<(String, Int, Int)> {
    var resultArray : Array<(String, Int, Int)> = []
    for i: Int in 0...(subStrings?.count)!-1 {
        if inputStr.contains((subStrings?[i])!) {
            let range: Range<String.Index> = inputStr.range(of: subStrings![i])!
            let lPos = inputStr.distance(from: inputStr.startIndex, to: range.lowerBound)
            let uPos = inputStr.distance(from: inputStr.startIndex, to: range.upperBound)
            let element = ((subStrings?[i])! as String, lPos, uPos)
            resultArray.append(element)
        }
    }
    for words in resultArray {
        print(words)
    }
    return resultArray
}

Zwraca ("Dlaczego", 0, 3)) ("substraty", 26, 36) ("Swift3", 40, 46)

Stworzyłem proste rozszerzenie dla tego (Swift 3)

extension String {
    func substring(location: Int, length: Int) -> String? {
        guard characters.count >= location + length else { return nil }
        let start = index(startIndex, offsetBy: location)
        let end = index(startIndex, offsetBy: location + length)
        return substring(with: start..<end)
    }
}

Swift 4

extension String {
    subscript(_ i: Int) -> String {
        let idx1 = index(startIndex, offsetBy: i)
        let idx2 = index(idx1, offsetBy: 1)
        return String(self[idx1..<idx2])
    }
}

let s = "hello"

s[0]    // h
s[1]    // e
s[2]    // l
s[3]    // l
s[4]    // o

Swift 4

"Substring" ( https://developer.apple.com/documentation/swift/substring):

let greeting = "Hi there! It's nice to meet you! "
let endOfSentence = greeting.index(of: "!")!
let firstSentence = greeting[...endOfSentence]
// firstSentence == "Hi there!"

Przykład ciągu rozszerzenia:

private typealias HowDoYouLikeThatElonMusk = String
private extension HowDoYouLikeThatElonMusk {

    subscript(_ from: Character?, _ to: Character?, _ include: Bool) -> String? {
        if let _from: Character = from, let _to: Character = to {
            let dynamicSourceForEnd: String = (_from == _to ? String(self.reversed()) : self)
            guard let startOfSentence: String.Index = self.index(of: _from),
                let endOfSentence: String.Index = dynamicSourceForEnd.index(of: _to) else {
                return nil
            }

            let result: String = String(self[startOfSentence...endOfSentence])
            if include == false {
                guard result.count > 2 else {
                        return nil
                }
                return String(result[result.index(result.startIndex, offsetBy: 1)..<result.index(result.endIndex, offsetBy: -1)])
            }
            return result
        } else if let _from: Character = from {
            guard let startOfSentence: String.Index = self.index(of: _from) else {
                return nil
            }
            let result: String = String(self[startOfSentence...])
            if include == false {
                guard result.count > 1 else {
                    return nil
                }
                return String(result[result.index(result.startIndex, offsetBy: 1)...])
            }
            return result
        } else if let _to: Character = to {
            guard let endOfSentence: String.Index = self.index(of: _to) else {
                    return nil
            }
            let result: String = String(self[...endOfSentence])
            if include == false {
                guard result.count > 1 else {
                    return nil
                }
                return String(result[..<result.index(result.endIndex, offsetBy: -1)])
            }
            return result
        }
        return nil
    }
}

Przykład użycia ciągu rozszerzenia:

let source =                                   ">>>01234..56789<<<"
// include = true
var from =          source["3", nil, true]  //       "34..56789<<<"
var to =            source[nil, "6", true]  // ">>>01234..56"
var fromTo =        source["3", "6", true]  //       "34..56"
let notFound =      source["a", nil, true]  // nil
// include = false
from =              source["3", nil, false] //        "4..56789<<<"
to =                source[nil, "6", false] // ">>>01234..5"
fromTo =            source["3", "6", false] //        "4..5"
let outOfBounds =   source[".", ".", false] // nil

let str = "Hello, playground"
let hello = str[nil, ",", false] // "Hello"