¿Alguna forma de reemplazar personajes en Swift String?

Estoy buscando una forma de reemplazar personajes en un Swift String.

Ejemplo: "Esta es mi cadena"

Me gustaría reemplazar "" con "+" para obtener "This + is + my + string".

¿Cómo puedo conseguir esto?

Esta respuesta se ha actualizado para Swift 4 y 5 . Si todavía usa Swift 1, 2 o 3, consulte el historial de revisiones.

Tienes unas cuantas opciones. Puedes hacer lo que @jaumard sugirió y usarreplacingOccurrences()

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

Y como lo señala @cprcrack a continuación, los parámetros optionsy rangeson opcionales, por lo que si no desea especificar opciones de comparación de cadenas o un rango para realizar el reemplazo, solo necesita lo siguiente.

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

O, si los datos están en un formato específico como este, donde solo está reemplazando los caracteres de separación, puede usar components()para dividir la cadena y la matriz, y luego puede usar la join()función para volver a unirlos con un separador específico .

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

O si está buscando una solución más Swifty que no utilice API de NSString, puede usar esto.

let aString = "Some search text"

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

Puedes usar esto:

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

Si agrega este método de extensión en cualquier parte de su código:

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)
    }
}

Solución Swift 3, Swift 4, Swift 5

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: "+")

¿Probaste esto?

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))

Salida:

result : Hello_world

Estoy usando esta extensión:

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: "")
    }
}

Uso:

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

Una solución Swift 3 en la línea de Sunkas:

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

Utilizar:

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

Salida:

foo?

Una categoría que modifica una cadena mutable existente:

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

Utilizar:

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

Solución Swift 3 basada en la respuesta de Ramis :

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

Intenté encontrar un nombre de función apropiado según la convención de nomenclatura Swift 3.

Menos me sucedió, solo quiero cambiar (una palabra o carácter) en el String

Así que he usado el 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
     }
    }

uso

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)

Creo que Regex es la forma más flexible y sólida:

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"

Extensión rápida:

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
    }

}

Sigue y úsalo como let replacedString = yorString.stringByReplacing(replaceStrings: [" ","?","."], with: "+")

La velocidad de la función es algo de lo que difícilmente puedo estar orgulloso, pero puede pasar una matriz de Stringuna sola vez para hacer más de un reemplazo.

Aquí está el ejemplo de Swift 3:

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

Esto es fácil en Swift 4.2. solo use replacingOccurrences(of: " ", with: "_")para reemplazar

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

Xcode 11 • Swift 5.1

El método de mutación de StringProtocol replacingOccurrencesse puede implementar de la siguiente manera:

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"

Si no desea usar los NSStringmétodos Objective-C , puede usar splity join:

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

split(string, isSeparator: { $0 == " " })devuelve una matriz de cadenas ( ["This", "is", "my", "string"]).

joinse une a estos elementos con una +, resultando en la salida deseada: "This+is+my+string".

He implementado esta función muy simple:

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

Entonces puedes escribir:

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

puedes probar esto:

let newString = test.stringByReplacingOccurrencesOfString ("", withString: "+", opciones: nil, rango: nil)

Aquí hay una extensión para un método de reemplazo de ocurrencias en el lugar String, que no requiere una copia innecesaria y hace todo en su lugar:

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
    }
}

(La firma del método también imita la firma del String.replacingOccurrences()método incorporado )

Se puede usar de la siguiente manera:

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