Un moyen de remplacer les caractères sur Swift String?

vous pouvez utiliser ceci:

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

si vous ajoutez cette méthode d'extension n'importe où dans votre code:

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, Solution Swift 4

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

avez-vous testé ceci:

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

sortie:

result : Hello_world

Une Swift 3 de la solution le long de la lignes de Sunkas:

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

utiliser:

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

sortie:

foo?

j'utilise cette extension:

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

Utilisation:

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

catégorie qui modifie une chaîne mutable existante:

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

utiliser:

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

solution Swift 3 basée sur réponse de Ramis :

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

a essayé de trouver un nom de fonction approprié selon la convention de nommage Swift 3.

Voici L'exemple pour Swift 3:

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

Voici une extension pour un in-place occurrences remplacer la méthode sur String , qui n'est pas une copie inutile et faire tout en place:

extension String {
    mutating func replaceOccurrences(of target: String, with replacement: String, options: String.CompareOptions = [], locale: Locale? = nil) {
        var range: Range<String.Index>?
        repeat {
            range = self.range(of: source, options: options, range: range.map { "151900920".lowerBound..<self.endIndex }, locale: locale)
            if let range = range {
                self.replaceSubrange(range, with: new)
            }
        } while range != nil
    }
}

(la méthode signature imite également la signature de la méthode intégrée String.replacingOccurrences() )

Peut être utilisé de la manière suivante:

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

si vous ne voulez pas utiliser L'objectif-c NSString méthodes, vous pouvez juste utiliser split et join :

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

split(string, isSeparator: { "151940920" == " " }) retourne un tableau de cordes ( ["This", "is", "my", "string"] ).

join joint ces éléments avec un + , résultant en la sortie désirée: "This+is+my+string" .

j'ai mis en œuvre cette fonction très facile:

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

pour que vous puissiez écrire:

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

je pense que Regex est le moyen le plus flexible et solide:

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"

extension Swift:

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
    }

}

continuez et utilisez-le comme let replacedString = yorString.stringByReplacing(replaceStrings: [" ","?","."], with: "+")

la vitesse de la fonction est quelque chose dont je peux difficilement être fier, mais vous pouvez passer un tableau de String en un seul passage pour faire plus d'un remplacement.