Gibt es eine Möglichkeit, Zeichen in Swift String zu ersetzen?

Ich suche nach einer Möglichkeit, Zeichen in einem Swift zu ersetzen String.

Beispiel: "Dies ist meine Zeichenfolge"

Ich möchte "" durch "+" ersetzen, um "This + is + my + string" zu erhalten.

Wie kann ich das erreichen?

Diese Antwort wurde für Swift 4 & 5 aktualisiert . Wenn Sie Swift 1, 2 oder 3 noch verwenden, lesen Sie den Versionsverlauf.

Sie haben mehrere Möglichkeiten. Sie können wie von @jaumard vorgeschlagen tun und verwendenreplacingOccurrences()

let aString = "This is my string"
let newString = aString.replacingOccurrences(of: " ", with: "+", options: .literal, range: nil)

Wie von @cprcrack unten angegeben, sind die Parameter optionsund rangeoptional. Wenn Sie also keine Zeichenfolgenvergleichsoptionen oder einen Bereich angeben möchten, in dem die Ersetzung durchgeführt werden soll, benötigen Sie nur die folgenden.

let aString = "This is my string"
let newString = aString.replacingOccurrences(of: " ", with: "+")

Wenn die Daten in einem bestimmten Format wie diesem vorliegen und nur Trennzeichen ersetzt werden, können Sie components()die Zeichenfolge in ein Array aufteilen und sie dann mithilfe der join()Funktion zusammen mit einem angegebenen Trennzeichen wieder zusammensetzen .

let toArray = aString.components(separatedBy: " ")
let backToString = toArray.joined(separator: "+")

Oder wenn Sie nach einer schnelleren Lösung suchen, die keine API von NSString verwendet, können Sie diese verwenden.

let aString = "Some search text"

let replaced = String(aString.map {
    $0 == " " ? "+" : $0
})

Sie können dies verwenden:

let s = "This is my string"
let modified = s.replace(" ", withString:"+")    

Wenn Sie diese Erweiterungsmethode an einer beliebigen Stelle in Ihrem Code hinzufügen:

extension String
{
    func replace(target: String, withString: String) -> String
    {
       return self.stringByReplacingOccurrencesOfString(target, withString: withString, options: NSStringCompareOptions.LiteralSearch, range: nil)
    }
}

Swift 3:

extension String
{
    func replace(target: String, withString: String) -> String
    {
        return self.replacingOccurrences(of: target, with: withString, options: NSString.CompareOptions.literal, range: nil)
    }
}

Swift 3, Swift 4, Swift 5 Lösung

let exampleString = "Example string"

//Solution suggested above in Swift 3.0
let stringToArray = exampleString.components(separatedBy: " ")
let stringFromArray = stringToArray.joined(separator: "+")

//Swiftiest solution
let swiftyString = exampleString.replacingOccurrences(of: " ", with: "+")

Hast du das getestet:

var test = "This is my string"

let replaced = test.stringByReplacingOccurrencesOfString(" ", withString: "+", options: nil, range: nil)

Swift 4:

let abc = "Hello world"

let result = abc.replacingOccurrences(of: " ", with: "_", 
    options: NSString.CompareOptions.literal, range:nil)

print(result :\(result))

Ausgabe:

result : Hello_world

Ich benutze diese Erweiterung:

extension String {

    func replaceCharacters(characters: String, toSeparator: String) -> String {
        let characterSet = NSCharacterSet(charactersInString: characters)
        let components = self.componentsSeparatedByCharactersInSet(characterSet)
        let result = components.joinWithSeparator("")
        return result
    }

    func wipeCharacters(characters: String) -> String {
        return self.replaceCharacters(characters, toSeparator: "")
    }
}

Verwendungszweck:

let token = "<34353 43434>"
token.replaceCharacters("< >", toString:"+")

Eine Swift 3-Lösung nach dem Vorbild von Sunkas:

extension String {
    mutating func replace(_ originalString:String, with newString:String) {
        self = self.replacingOccurrences(of: originalString, with: newString)
    }
}

Verwenden:

var string = "foo!"
string.replace("!", with: "?")
print(string)

Ausgabe:

foo?

Eine Kategorie, die eine vorhandene veränderbare Zeichenfolge ändert:

extension String
{
    mutating func replace(originalString:String, withString newString:String)
    {
        let replacedString = self.stringByReplacingOccurrencesOfString(originalString, withString: newString, options: nil, range: nil)
        self = replacedString
    }
}

Verwenden:

name.replace(" ", withString: "+")

Swift 3-Lösung basierend auf Ramis 'Antwort :

extension String {
    func withReplacedCharacters(_ characters: String, by separator: String) -> String {
        let characterSet = CharacterSet(charactersIn: characters)
        return components(separatedBy: characterSet).joined(separator: separator)
    }
}

Es wurde versucht, einen geeigneten Funktionsnamen gemäß der Swift 3-Namenskonvention zu finden.

Mir ist weniger passiert, ich möchte nur (ein Wort oder ein Zeichen) in der ändern String

Also habe ich das benutzt Dictionary

  extension String{
    func replace(_ dictionary: [String: String]) -> String{
          var result = String()
          var i = -1
          for (of , with): (String, String)in dictionary{
              i += 1
              if i<1{
                  result = self.replacingOccurrences(of: of, with: with)
              }else{
                  result = result.replacingOccurrences(of: of, with: with)
              }
          }
        return result
     }
    }

Verwendungszweck

let mobile = "+1 (800) 444-9999"
let dictionary = ["+": "00", " ": "", "(": "", ")": "", "-": ""]
let mobileResult = mobile.replace(dictionary)
print(mobileResult) // 001800444999

var str = "This is my string"
str = str.replacingOccurrences(of: " ", with: "+")
print(str)

Ich denke, Regex ist der flexibelste und solide Weg:

var str = "This is my string"
let regex = try! NSRegularExpression(pattern: " ", options: [])
let output = regex.stringByReplacingMatchesInString(
    str,
    options: [],
    range: NSRange(location: 0, length: str.characters.count),
    withTemplate: "+"
)
// output: "This+is+my+string"

Schnelle Erweiterung:

extension String {

    func stringByReplacing(replaceStrings set: [String], with: String) -> String {
        var stringObject = self
        for string in set {
            stringObject = self.stringByReplacingOccurrencesOfString(string, withString: with)
        }
        return stringObject
    }

}

Mach weiter und benutze es wie let replacedString = yorString.stringByReplacing(replaceStrings: [" ","?","."], with: "+")

Die Geschwindigkeit der Funktion ist etwas, auf das ich kaum stolz sein kann, aber Sie können eine Reihe von Stringin einem Durchgang übergeben, um mehr als einen Ersatz vorzunehmen.

Hier ist das Beispiel für Swift 3:

var stringToReplace = "This my string"
if let range = stringToReplace.range(of: "my") {
   stringToReplace?.replaceSubrange(range, with: "your")
} 

Dies ist in Swift 4.2 einfach. einfach replacingOccurrences(of: " ", with: "_")zum ersetzen verwenden

var myStr = "This is my string"
let replaced = myStr.replacingOccurrences(of: " ", with: "_")
print(replaced)

Xcode 11 • Swift 5.1

Die Mutationsmethode von StringProtocol replacingOccurrenceskann wie folgt implementiert werden:

extension RangeReplaceableCollection where Self: StringProtocol {
    mutating func replaceOccurrences<Target: StringProtocol, Replacement: StringProtocol>(of target: Target, with replacement: Replacement, options: String.CompareOptions = [], range searchRange: Range<String.Index>? = nil) {
        self = .init(replacingOccurrences(of: target, with: replacement, options: options, range: searchRange))
    }
}

var name = "This is my string"
name.replaceOccurrences(of: " ", with: "+")
print(name) // "This+is+my+string\n"

Wenn Sie die Objective-C nicht verwenden wollen NSStringMethoden, können Sie einfach verwenden splitund join:

var string = "This is my string"
string = join("+", split(string, isSeparator: { $0 == " " }))

split(string, isSeparator: { $0 == " " })Gibt ein Array von Strings ( ["This", "is", "my", "string"]) zurück.

joinverbindet diese Elemente mit a +, was zu der gewünschten Ausgabe führt : "This+is+my+string".

Ich habe diese sehr einfache Funktion implementiert:

func convap (text : String) -> String {
    return text.stringByReplacingOccurrencesOfString("'", withString: "''")
}

So können Sie schreiben:

let sqlQuery = "INSERT INTO myTable (Field1, Field2) VALUES ('\(convap(value1))','\(convap(value2)')

Sie können dies testen:

let newString = test.stringByReplacingOccurrencesOfString ("", withString: "+", Optionen: nil, Bereich: nil)

Hier ist eine Erweiterung für eine Methode zum Ersetzen von Vor-Ort-Vorkommen String, bei der keine unnötige Kopie erstellt wird und alles an Ort und Stelle ausgeführt wird:

extension String {
    mutating func replaceOccurrences<Target: StringProtocol, Replacement: StringProtocol>(of target: Target, with replacement: Replacement, options: String.CompareOptions = [], locale: Locale? = nil) {
        var range: Range<Index>?
        repeat {
            range = self.range(of: target, options: options, range: range.map { self.index($0.lowerBound, offsetBy: replacement.count)..<self.endIndex }, locale: locale)
            if let range = range {
                self.replaceSubrange(range, with: replacement)
            }
        } while range != nil
    }
}

(Die Methodensignatur ahmt auch die Signatur der integrierten String.replacingOccurrences()Methode nach.)

Kann folgendermaßen verwendet werden:

var string = "this is a string"
string.replaceOccurrences(of: " ", with: "_")
print(string) // "this_is_a_string"