NSRange to Range <String.Index>

Wie kann ich konvertieren NSRangezu Range<String.Index>in Swift?

Ich möchte die folgende UITextFieldDelegateMethode verwenden:

    func textField(textField: UITextField!,
        shouldChangeCharactersInRange range: NSRange,
        replacementString string: String!) -> Bool {

textField.text.stringByReplacingCharactersInRange(???, withString: string)

Die NSStringVersion (im Gegensatz zu Swift String) von replacingCharacters(in: NSRange, with: NSString)einem übernimmt NSRange, so eine einfache Lösung ist , zu konvertieren , Stringum NSStringersten . Die Namen der Delegaten- und Ersetzungsmethoden unterscheiden sich in Swift 3 und 2 geringfügig. Je nachdem, welchen Swift Sie verwenden:

Swift 3.0

func textField(_ textField: UITextField,
               shouldChangeCharactersIn range: NSRange,
               replacementString string: String) -> Bool {

  let nsString = textField.text as NSString?
  let newString = nsString?.replacingCharacters(in: range, with: string)
}

Swift 2.x.

func textField(textField: UITextField,
               shouldChangeCharactersInRange range: NSRange,
               replacementString string: String) -> Bool {

    let nsString = textField.text as NSString?
    let newString = nsString?.stringByReplacingCharactersInRange(range, withString: string)
}

Ab Swift 4 (Xcode 9) bietet die Swift-Standardbibliothek Methoden zum Konvertieren zwischen Swift-Zeichenfolgenbereichen ( Range<String.Index>) und NSStringBereichen ( NSRange). Beispiel:

let str = "a👿b🇩🇪c"
let r1 = str.range(of: "🇩🇪")!

// String range to NSRange:
let n1 = NSRange(r1, in: str)
print((str as NSString).substring(with: n1)) // 🇩🇪

// NSRange back to String range:
let r2 = Range(n1, in: str)!
print(str[r2]) // 🇩🇪

Daher kann die Textersetzung in der Textfelddelegatmethode jetzt wie folgt erfolgen

func textField(_ textField: UITextField,
               shouldChangeCharactersIn range: NSRange,
               replacementString string: String) -> Bool {

    if let oldString = textField.text {
        let newString = oldString.replacingCharacters(in: Range(range, in: oldString)!,
                                                      with: string)
        // ...
    }
    // ...
}

(Ältere Antworten für Swift 3 und früher :)

Ab Swift 1.2 String.Indexgibt es einen Initialisierer

init?(_ utf16Index: UTF16Index, within characters: String)

die NSRangezur Range<String.Index>korrekten Konvertierung in (einschließlich aller Fälle von Emojis, Regionalindikatoren oder anderen erweiterten Graphemclustern) ohne Zwischenkonvertierung in Folgendes verwendet werden kann NSString:

extension String {
    func rangeFromNSRange(nsRange : NSRange) -> Range<String.Index>? {
        let from16 = advance(utf16.startIndex, nsRange.location, utf16.endIndex)
        let to16 = advance(from16, nsRange.length, utf16.endIndex)
        if let from = String.Index(from16, within: self),
            let to = String.Index(to16, within: self) {
                return from ..< to
        }
        return nil
    }
}

Diese Methode gibt einen optionalen Zeichenfolgenbereich zurück, da nicht alle NSRanges für eine bestimmte Swift-Zeichenfolge gültig sind.

Die UITextFieldDelegateDelegate-Methode kann dann als geschrieben werden

func textField(textField: UITextField, shouldChangeCharactersInRange range: NSRange, replacementString string: String) -> Bool {

    if let swRange = textField.text.rangeFromNSRange(range) {
        let newString = textField.text.stringByReplacingCharactersInRange(swRange, withString: string)
        // ...
    }
    return true
}

Die inverse Umwandlung ist

extension String {
    func NSRangeFromRange(range : Range<String.Index>) -> NSRange {
        let utf16view = self.utf16
        let from = String.UTF16View.Index(range.startIndex, within: utf16view) 
        let to = String.UTF16View.Index(range.endIndex, within: utf16view)
        return NSMakeRange(from - utf16view.startIndex, to - from)
    }
}

Ein einfacher Test:

let str = "a👿b🇩🇪c"
let r1 = str.rangeOfString("🇩🇪")!

// String range to NSRange:
let n1 = str.NSRangeFromRange(r1)
println((str as NSString).substringWithRange(n1)) // 🇩🇪

// NSRange back to String range:
let r2 = str.rangeFromNSRange(n1)!
println(str.substringWithRange(r2)) // 🇩🇪

Update für Swift 2:

Die Swift 2-Version von rangeFromNSRange()wurde bereits von Serhii Yakovenko in dieser Antwort angegeben. Der Vollständigkeit halber füge ich sie hier ein:

extension String {
    func rangeFromNSRange(nsRange : NSRange) -> Range<String.Index>? {
        let from16 = utf16.startIndex.advancedBy(nsRange.location, limit: utf16.endIndex)
        let to16 = from16.advancedBy(nsRange.length, limit: utf16.endIndex)
        if let from = String.Index(from16, within: self),
            let to = String.Index(to16, within: self) {
                return from ..< to
        }
        return nil
    }
}

Die Swift 2 Version von NSRangeFromRange()ist

extension String {
    func NSRangeFromRange(range : Range<String.Index>) -> NSRange {
        let utf16view = self.utf16
        let from = String.UTF16View.Index(range.startIndex, within: utf16view)
        let to = String.UTF16View.Index(range.endIndex, within: utf16view)
        return NSMakeRange(utf16view.startIndex.distanceTo(from), from.distanceTo(to))
    }
}

Update für Swift 3 (Xcode 8):

extension String {
    func nsRange(from range: Range<String.Index>) -> NSRange {
        let from = range.lowerBound.samePosition(in: utf16)
        let to = range.upperBound.samePosition(in: utf16)
        return NSRange(location: utf16.distance(from: utf16.startIndex, to: from),
                       length: utf16.distance(from: from, to: to))
    }
}

extension String {
    func range(from nsRange: NSRange) -> Range<String.Index>? {
        guard
            let from16 = utf16.index(utf16.startIndex, offsetBy: nsRange.location, limitedBy: utf16.endIndex),
            let to16 = utf16.index(utf16.startIndex, offsetBy: nsRange.location + nsRange.length, limitedBy: utf16.endIndex),
            let from = from16.samePosition(in: self),
            let to = to16.samePosition(in: self)
            else { return nil }
        return from ..< to
    }
}

Beispiel:

let str = "a👿b🇩🇪c"
let r1 = str.range(of: "🇩🇪")!

// String range to NSRange:
let n1 = str.nsRange(from: r1)
print((str as NSString).substring(with: n1)) // 🇩🇪

// NSRange back to String range:
let r2 = str.range(from: n1)!
print(str.substring(with: r2)) // 🇩🇪

Sie müssen Range<String.Index>anstelle des Klassikers verwenden NSRange. Die Art und Weise, wie ich es mache (vielleicht gibt es einen besseren Weg), besteht darin, die Saite zu nehmen und sie zu String.Indexbewegen advance.

Ich weiß nicht, welchen Bereich Sie ersetzen möchten, aber tun wir so, als wollten Sie die ersten beiden Zeichen ersetzen.

var start = textField.text.startIndex // Start at the string's start index
var end = advance(textField.text.startIndex, 2) // Take start index and advance 2 characters forward
var range: Range<String.Index> = Range<String.Index>(start: start,end: end)

textField.text.stringByReplacingCharactersInRange(range, withString: string)

Diese Antwort von Martin R scheint richtig zu sein, da sie Unicode ausmacht.

Zum Zeitpunkt des Posts (Swift 1) wird sein Code jedoch nicht in Swift 2.0 (Xcode 7) kompiliert, da die advance()Funktion entfernt wurde . Die aktualisierte Version ist unten:

Swift 2

extension String {
    func rangeFromNSRange(nsRange : NSRange) -> Range<String.Index>? {
        let from16 = utf16.startIndex.advancedBy(nsRange.location, limit: utf16.endIndex)
        let to16 = from16.advancedBy(nsRange.length, limit: utf16.endIndex)
        if let from = String.Index(from16, within: self),
            let to = String.Index(to16, within: self) {
                return from ..< to
        }
        return nil
    }
}

Swift 3

extension String {
    func rangeFromNSRange(nsRange : NSRange) -> Range<String.Index>? {
        if let from16 = utf16.index(utf16.startIndex, offsetBy: nsRange.location, limitedBy: utf16.endIndex),
            let to16 = utf16.index(from16, offsetBy: nsRange.length, limitedBy: utf16.endIndex),
            let from = String.Index(from16, within: self),
            let to = String.Index(to16, within: self) {
                return from ..< to
        }
        return nil
    }
}

Swift 4

extension String {
    func rangeFromNSRange(nsRange : NSRange) -> Range<String.Index>? {
        return Range(nsRange, in: self)
    }
}

Dies ist vergleichbar mit Emilie Antwort jedoch , da Sie speziell gefragt , wie die zu konvertieren , NSRangeum Range<String.Index>Sie so etwas wie dies tun würden:

func textField(textField: UITextField, shouldChangeCharactersInRange range: NSRange, replacementString string: String) -> Bool {

     let start = advance(textField.text.startIndex, range.location) 
     let end = advance(start, range.length) 
     let swiftRange = Range<String.Index>(start: start, end: end) 
     ...

}

Ein Riff über die großartige Antwort von @Emilie, keine Ersatz- / Konkurrenzantwort.
(Xcode6-Beta5)

var original    = "🇪🇸😂This is a test"
var replacement = "!"

var startIndex = advance(original.startIndex, 1) // Start at the second character
var endIndex   = advance(startIndex, 2) // point ahead two characters
var range      = Range(start:startIndex, end:endIndex)
var final = original.stringByReplacingCharactersInRange(range, withString:replacement)

println("start index: \(startIndex)")
println("end index:   \(endIndex)")
println("range:       \(range)")
println("original:    \(original)")
println("final:       \(final)")

Ausgabe:

start index: 4
end index:   7
range:       4..<7
original:    🇪🇸😂This is a test
final:       🇪🇸!his is a test

Beachten Sie, dass die Indizes mehrere Codeeinheiten berücksichtigen. Das Flag (REGIONAL INDICATOR SYMBOL LETTERS ES) beträgt 8 Bytes und das (FACE WITH TEARS OF JOY) 4 Bytes. (In diesem speziellen Fall stellt sich heraus, dass die Anzahl der Bytes für UTF-8-, UTF-16- und UTF-32-Darstellungen gleich ist.)

Wickeln Sie es in eine Funktion:

func replaceString(#string:String, #with:String, #start:Int, #length:Int) ->String {
    var startIndex = advance(original.startIndex, start) // Start at the second character
    var endIndex   = advance(startIndex, length) // point ahead two characters
    var range      = Range(start:startIndex, end:endIndex)
    var final = original.stringByReplacingCharactersInRange(range, withString: replacement)
    return final
}

var newString = replaceString(string:original, with:replacement, start:1, length:2)
println("newString:\(newString)")

Ausgabe:

newString: !his is a test

func textField(textField: UITextField, shouldChangeCharactersInRange range: NSRange, replacementString string: String) -> Bool {

       let strString = ((textField.text)! as NSString).stringByReplacingCharactersInRange(range, withString: string)

 }

In Swift 2.0 unter der Annahme func textField(textField: UITextField, shouldChangeCharactersInRange range: NSRange, replacementString string: String) -> Bool {:

var oldString = textfield.text!
let newRange = oldString.startIndex.advancedBy(range.location)..<oldString.startIndex.advancedBy(range.location + range.length)
let newString = oldString.stringByReplacingCharactersInRange(newRange, withString: string)

Hier ist meine größte Anstrengung. Dies kann jedoch keine falschen Eingabeargumente überprüfen oder erkennen.

extension String {
    /// :r: Must correctly select proper UTF-16 code-unit range. Wrong range will produce wrong result.
    public func convertRangeFromNSRange(r:NSRange) -> Range<String.Index> {
        let a   =   (self as NSString).substringToIndex(r.location)
        let b   =   (self as NSString).substringWithRange(r)

        let n1  =   distance(a.startIndex, a.endIndex)
        let n2  =   distance(b.startIndex, b.endIndex)

        let i1  =   advance(startIndex, n1)
        let i2  =   advance(i1, n2)

        return  Range<String.Index>(start: i1, end: i2)
    }
}

let s   =   "🇪🇸😂"
println(s[s.convertRangeFromNSRange(NSRange(location: 4, length: 2))])      //  Proper range. Produces correct result.
println(s[s.convertRangeFromNSRange(NSRange(location: 0, length: 4))])      //  Proper range. Produces correct result.
println(s[s.convertRangeFromNSRange(NSRange(location: 0, length: 2))])      //  Improper range. Produces wrong result.
println(s[s.convertRangeFromNSRange(NSRange(location: 0, length: 1))])      //  Improper range. Produces wrong result.

Ergebnis.

😂
🇪🇸
🇪🇸
🇪🇸

Einzelheiten

NSRangevon NSStringZählungen UTF-16 Code-Einheit s. Und Range<String.Index>von Swift Stringist ein undurchsichtiger relativer Typ, der nur Gleichheits- und Navigationsoperationen bietet. Dies ist absichtlich verstecktes Design.

Obwohl die Range<String.Index>scheinbar auf den UTF-16-Code-Unit-Offset abgebildet sind, ist dies nur ein Implementierungsdetail, und ich konnte keine Erwähnung für eine Garantie finden. Das heißt, die Implementierungsdetails können jederzeit geändert werden. Die interne Darstellung von Swift Stringist nicht genau definiert, und ich kann mich nicht darauf verlassen.

NSRangeWerte können direkt String.UTF16ViewIndizes zugeordnet werden. Aber es gibt keine Methode, um es umzuwandelnString.Index .

Swift String.Indexist ein Index zum Iterieren von Swift Character, einem Unicode-Graphemcluster . Dann müssen Sie NSRangedas richtige angeben, das die richtigen Graphemcluster auswählt. Wenn Sie wie im obigen Beispiel einen falschen Bereich angeben, wird ein falsches Ergebnis erzielt, da der richtige Graphemclusterbereich nicht ermittelt werden konnte.

Wenn es eine Garantie dafür gibt, dass String.Index es sich um einen UTF-16-Code-Unit-Offset handelt, wird das Problem einfach. Aber es ist unwahrscheinlich, dass es passiert.

Inverse Umwandlung

Auf jeden Fall kann die inverse Umwandlung genau durchgeführt werden.

extension String {
    /// O(1) if `self` is optimised to use UTF-16.
    /// O(n) otherwise.
    public func convertRangeToNSRange(r:Range<String.Index>) -> NSRange {
        let a   =   substringToIndex(r.startIndex)
        let b   =   substringWithRange(r)

        return  NSRange(location: a.utf16Count, length: b.utf16Count)
    }
}
println(convertRangeToNSRange(s.startIndex..<s.endIndex))
println(convertRangeToNSRange(s.startIndex.successor()..<s.endIndex))

Ergebnis.

(0,6)
(4,2)

Ich habe festgestellt, dass die sauberste Lösung von swift2 nur darin besteht, eine Kategorie in NSRange zu erstellen:

extension NSRange {
    func stringRangeForText(string: String) -> Range<String.Index> {
        let start = string.startIndex.advancedBy(self.location)
        let end = start.advancedBy(self.length)
        return Range<String.Index>(start: start, end: end)
    }
}

Rufen Sie es dann für die Textfelddelegatfunktion auf:

func textField(textField: UITextField, shouldChangeCharactersInRange range: NSRange, replacementString string: String) -> Bool {
    let range = range.stringRangeForText(textField.text)
    let output = textField.text.stringByReplacingCharactersInRange(range, withString: string)

    // your code goes here....

    return true
}

Die offizielle Beta-Dokumentation zu Swift 3.0 bietet die Standardlösung für diese Situation unter dem Titel String.UTF16View im Abschnitt UTF16View Elements Match NSString Characters title

In der akzeptierten Antwort finde ich die Optionen umständlich. Dies funktioniert mit Swift 3 und scheint kein Problem mit Emojis zu haben.

func textField(_ textField: UITextField, 
      shouldChangeCharactersIn range: NSRange, 
      replacementString string: String) -> Bool {

  guard let value = textField.text else {return false} // there may be a reason for returning true in this case but I can't think of it
  // now value is a String, not an optional String

  let valueAfterChange = (value as NSString).replacingCharacters(in: range, with: string)
  // valueAfterChange is a String, not an optional String

  // now do whatever processing is required

  return true  // or false, as required
}

extension StringProtocol where Index == String.Index {

    func nsRange(of string: String) -> NSRange? {
        guard let range = self.range(of: string) else {  return nil }
        return NSRange(range, in: self)
    }
}