Aktualizowałem część mojego starego kodu i odpowiedzi w Swift 3, ale kiedy dotarłem do Swift Strings i indeksowania z podciągami, sprawy się skomplikowały.

W szczególności próbowałem:

let str = "Hello, playground"
let prefixRange = str.startIndex..<str.startIndex.advancedBy(5)
let prefix = str.substringWithRange(prefixRange)

gdzie druga linia dawała mi następujący błąd

Wartość typu „String” nie ma elementu „substringWithRange”

Widzę, że Stringma teraz następujące metody:

str.substring(to: String.Index)
str.substring(from: String.Index)
str.substring(with: Range<String.Index>)

Na początku były to naprawdę mylące, więc zacząłem grać wokół indeksu i zasięgu . To jest kolejne pytanie i odpowiedź na podciąg. Dodaję odpowiedź poniżej, aby pokazać, jak są one używane.

Zastosowano wszystkie poniższe przykłady

var str = "Hello, playground"

Szybki 4

Ciągi zostały dość gruntownie zmienione w Swift 4. Kiedy teraz otrzymujesz podciąg z String, dostajesz z Substringpowrotem typ zamiast a String. Dlaczego to? Ciągi są typami wartości w Swift. Oznacza to, że jeśli użyjesz jednego ciągu, aby utworzyć nowy, należy go skopiować. Jest to dobre dla stabilności (nikt inny nie zmieni tego bez twojej wiedzy), ale złe dla wydajności.

Z drugiej strony podłańcuch jest odniesieniem do oryginalnego ciągu, z którego pochodzi. Oto obraz z dokumentacji ilustrujący to.

Kopiowanie nie jest potrzebne, więc jest znacznie wydajniejsze w użyciu. Wyobraź sobie jednak, że masz dziesięcioznakowy podłańcuch z milionowego ciągu znaków. Ponieważ podłańcuch odwołuje się do ciągu, system musiałby trzymać się całego ciągu tak długo, jak długo znajduje się on w pobliżu. Dlatego za każdym razem, gdy skończysz manipulować swoim podciągiem, przekonwertuj go na ciąg.

let myString = String(mySubstring)

Spowoduje to skopiowanie tylko podciągu, a pamięć zawierająca stary ciąg może zostać odzyskana . Podciągi (jako typ) mają być krótkotrwałe.

Kolejną dużą poprawą w Swift 4 jest to, że ciągi są kolekcjami (ponownie). Oznacza to, że cokolwiek możesz zrobić z kolekcją, możesz zrobić z łańcuchem (użyj indeksów dolnych, iteruj po znakach, filtruj itp.).

Poniższe przykłady pokazują, jak uzyskać podciąg w Swift.

Pobieranie podciągów

Można uzyskać podciąg z ciągu znaków za pomocą indeksów lub szereg innych metod (na przykład prefix, suffix, split). Nadal jednak musisz używać indeksu dla zakresu, String.Indexa nie Intindeksu. (Zobacz moją drugą odpowiedź, jeśli potrzebujesz pomocy.)

Początek łańcucha

Możesz użyć indeksu dolnego (zwróć uwagę na jednostronny zakres Swift 4):

let index = str.index(str.startIndex, offsetBy: 5)
let mySubstring = str[..<index] // Hello

lub prefix:

let index = str.index(str.startIndex, offsetBy: 5)
let mySubstring = str.prefix(upTo: index) // Hello

lub nawet łatwiej:

let mySubstring = str.prefix(5) // Hello

Koniec łańcucha

Korzystanie z indeksów dolnych:

let index = str.index(str.endIndex, offsetBy: -10)
let mySubstring = str[index...] // playground

lub suffix:

let index = str.index(str.endIndex, offsetBy: -10)
let mySubstring = str.suffix(from: index) // playground

lub nawet łatwiej:

let mySubstring = str.suffix(10) // playground

Zauważ, że podczas używania suffix(from: index)musiałem odliczać od końca, używając -10. Nie jest to konieczne przy zwykłym użyciu suffix(x), które po prostu pobiera ostatnie xznaki ciągu.

Zakres w ciągu

Ponownie używamy tutaj indeksów dolnych.

let start = str.index(str.startIndex, offsetBy: 7)
let end = str.index(str.endIndex, offsetBy: -6)
let range = start..<end

let mySubstring = str[range]  // play

Konwertowanie SubstringnaString

Nie zapominaj, że kiedy będziesz gotowy do zapisania swojego podciągu, powinieneś przekonwertować go na Stringtak, aby pamięć starego łańcucha mogła zostać wyczyszczona.

let myString = String(mySubstring)

Używasz Introzszerzenia indeksu?

Waham się przed użyciem Introzszerzenia indeksu opartego na indeksie po przeczytaniu artykułu Strings in Swift 3 autorstwa Airspeed Velocity i Ole Begemann. Chociaż w Swift 4 Strings są kolekcjami, zespół Swift celowo nie używał Intindeksów. Nadal jest String.Index. Ma to związek z tym, że znaki Swift składają się z różnej liczby punktów kodowych Unicode. Rzeczywisty indeks musi być jednoznacznie obliczony dla każdego łańcucha.

Muszę powiedzieć, że mam nadzieję, że zespół Swift znajdzie sposób na abstrahowanie String.Indexw przyszłości. Ale dopóki nie zdecyduję się użyć ich interfejsu API. Pomaga mi pamiętać, że manipulacje ciągami znaków to nie tylko proste Intwyszukiwanie indeksów.

Jestem naprawdę sfrustrowany modelem dostępu do ciągów Swift: wszystko musi być Index. Chcę tylko uzyskać dostęp do i-tego znaku ciągu Int, a nie niezdarny indeks i postęp (który zdarza się zmieniać z każdym większym wydaniem). Zrobiłem więc 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 String(self[fromIndex...])
    }

    func substring(to: Int) -> String {
        let toIndex = index(from: to)
        return String(self[..<toIndex])
    }

    func substring(with r: Range<Int>) -> String {
        let startIndex = index(from: r.lowerBound)
        let endIndex = index(from: r.upperBound)
        return String(self[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

Rozszerzenie Swift 5:

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

    subscript(_ range: CountablePartialRangeFrom<Int>) -> String {
        let start = index(startIndex, offsetBy: max(0, range.lowerBound))
         return String(self[start...])
    }
}

Stosowanie:

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

Lub Unicode:

let s = "😎🤣😋"
s[0..<1] // "😎"

Swift 4 i 5:

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

  subscript (r: Range<Int>) -> String {
    let start = index(startIndex, offsetBy: r.lowerBound)
    let end = index(startIndex, offsetBy: r.upperBound)
    return String(self[start ..< end])
  }

  subscript (r: CountableClosedRange<Int>) -> String {
    let startIndex =  self.index(self.startIndex, offsetBy: r.lowerBound)
    let endIndex = self.index(startIndex, offsetBy: r.upperBound - r.lowerBound)
    return String(self[startIndex...endIndex])
  }
}

Jak tego użyć:

„abcde” [0] -> „a”

„abcde” [0 ... 2] -> „abc”

„abcde” [2 .. <4] -> „cd”

Szybki 4

W szybkim 4 Stringodpowiada Collection. Zamiast tego substringpowinniśmy teraz użyć subscript.Więc jeśli chcesz wyciąć tylko słowo "play"z "Hello, playground", możesz to zrobić w następujący sposób:

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

Interesujące jest wiedzieć, że zrobienie tego da ci Substringzamiast String. Jest to szybkie i wydajne, ponieważ Substringdzieli pamięć z oryginalnym ciągiem. Jednak dzielenie pamięci w ten sposób może również łatwo doprowadzić do wycieków pamięci.

Dlatego powinieneś skopiować wynik do nowego ciągu, gdy chcesz wyczyścić oryginalny ciąg. Możesz to zrobić za pomocą normalnego konstruktora:

let newString = String(result)

Więcej informacji na temat nowej Substringklasy można znaleźć w [dokumentacji Apple]. 1

Jeśli na przykład otrzymasz Rangewynik w postaci 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)
    }

}

Oto funkcja, która zwraca podłańcuch danego podłańcucha, gdy podane są indeksy początkowy i końcowy. Aby uzyskać pełne odniesienie, możesz odwiedzić poniższe linki.

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 posta na blogu, który utworzyłem, aby szybko poradzić sobie z manipulacją ciągami. Manipulowanie strunami w trybie szybkim (obejmuje również swift 4)

Lub możesz zobaczyć tę istotę na github

Miałem taką samą początkową reakcję. Ja również byłem sfrustrowany tym, że składnia i obiekty zmieniają się tak drastycznie w każdej większej wersji.

Jednak z doświadczenia zdałem sobie sprawę, że zawsze w końcu odczuwam konsekwencje walki z „zmianą”, np. Radzenia sobie z postaciami wielobajtowymi, co jest nieuniknione, jeśli spojrzysz na globalną publiczność.

Postanowiłem więc uznać i szanować wysiłki inżynierów Apple i wykonać swoją część, rozumiejąc ich sposób myślenia, kiedy wymyślili to „przerażające” podejście.

Zamiast tworzyć rozszerzenia, które są tylko obejściem, aby ułatwić Ci życie (nie mówię, że są złe lub drogie), dlaczego nie dowiedzieć się, w jaki sposób Struny są teraz zaprojektowane do pracy.

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óby zastosowania tego samego podejścia, np. przy użyciu Substringów, w końcu zrozumiałem koncepcję traktowania Strings jako kolekcji dwukierunkowej, dla której 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))

Mam nadzieję, że przyczyni się to ...

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

Skompilowałem ten przykład uzyskiwania pozycji dla podciągó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) („podłańcuchy”, 26, 36) („Swift3”, 40, 46)

Jestem nowy w Swift 3, ale patrząc na Stringskładnię (indeks) dla analogii, myślę, że indeks jest jak „wskaźnik” ograniczony do łańcucha, a Int może pomóc jako niezależny obiekt. Używając składni base + offset, możemy uzyskać i-ty znak z ciągu znaków z poniższym kodem:

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

Dla zakresu znaków (indeksów) od łańcucha przy użyciu składni String (zakres) możemy uzyskać od i-tego do f-tego znaku z poniższym kodem:

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

W przypadku podłańcucha (zakresu) z łańcucha przy użyciu String.substring (range) możemy uzyskać podłańcuch za pomocą 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-ta i-ta zaczynają się od 0.

2. Do f-tej używam offsetBY: f + 1, ponieważ zakres abonamentu wykorzystuje .. <(operator półotwarty), nie obejmuje piątej pozycji.

3. Oczywiście musi zawierać błędy sprawdzania poprawności, takie jak nieprawidłowy indeks.

Swift 4+

extension String {
    func take(_ n: Int) -> String {
        guard n >= 0 else {
            fatalError("n should never negative")
        }
        let index = self.index(self.startIndex, offsetBy: min(n, self.count))
        return String(self[..<index])
    }
}

Zwraca podsekwencję pierwszych n znaków lub całego łańcucha, jeśli łańcuch jest krótszy. (inspirowany: https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.text/take.html )

Przykład:

let text = "Hello, World!"
let substring = text.take(5) //Hello

Mam dość mechaniczne myślenie. Oto podstawy ...

Swift 4 Swift 5

  let t = "abracadabra"

  let start1 = t.index(t.startIndex, offsetBy:0)
  let   end1 = t.index(t.endIndex, offsetBy:-5)
  let start2 = t.index(t.endIndex, offsetBy:-5)
  let   end2 = t.index(t.endIndex, offsetBy:0)

  let t2 = t[start1 ..< end1]
  let t3 = t[start2 ..< end2]                

  //or a shorter form 

  let t4 = t[..<end1]
  let t5 = t[start2...]

  print("\(t2) \(t3) \(t)")
  print("\(t4) \(t5) \(t)")

  // result:
  // abraca dabra abracadabra

Wynikiem jest podłańcuch, co oznacza, że ​​jest on częścią oryginalnego łańcucha. Aby uzyskać pełny ciąg oddzielnych ciągów, wystarczy użyć np

    String(t3)
    String(t4)

Oto, czego używam:

    let mid = t.index(t.endIndex, offsetBy:-5)
    let firstHalf = t[..<mid]
    let secondHalf = t[mid...]

Szybki 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

Stworzyłem do tego proste rozszerzenie (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)
    }
}

Oto bardziej ogólna implementacja:

Ta technika wciąż stosuje się indexdo standardów Swift i sugeruje pełną Postać.

extension String
{
    func subString <R> (_ range: R) -> String? where R : RangeExpression, String.Index == R.Bound
    {
        return String(self[range])
    }

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

Aby podciąć ciąg od trzeciego znaku:

let item = "Fred looks funny"
item.subString(item.index(at: 2)...) // "ed looks funny"

Użyłem wielbłąda, subStringaby wskazać, że zwraca a, Stringa nie a Substring.

Opierając się na powyższym, musiałem podzielić ciąg znaków na znak niedrukowalny, porzucając znak niedrukowalny. Opracowałem dwie metody:

var str = "abc\u{1A}12345sdf"
let range1: Range<String.Index> = str.range(of: "\u{1A}")!
let index1: Int = str.distance(from: str.startIndex, to: range1.lowerBound)
let start = str.index(str.startIndex, offsetBy: index1)
let end = str.index(str.endIndex, offsetBy: -0)
let result = str[start..<end] // The result is of type Substring
let firstStr = str[str.startIndex..<range1.lowerBound]

które zestawiłem, używając niektórych z powyższych odpowiedzi.

Ponieważ ciąg jest kolekcją, wykonałem następujące czynności:

var fString = String()
for (n,c) in str.enumerated(){

*if c == "\u{1A}" {
    print(fString);
    let lString = str.dropFirst(n + 1)
    print(lString)
    break
   }
 fString += String(c)
}*

Co było dla mnie bardziej intuicyjne. Który jest najlepszy? Nie mogę powiedzieć, że oboje pracują z Swift 5

Szybki 4

„Podciąg” ( 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 rozszerzenia String:

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 rozszerzenia String:

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"

Swift 5
let desiredIndex: Int = 7 let substring = str[String.Index(encodedOffset: desiredIndex)...]
Ta zmienna podła daje wynik.
Po prostu tutaj Int jest konwertowany na indeks, a następnie możesz podzielić ciągi. Chyba że otrzymasz błędy.