Est-il possible de remplacer des caractères sur Swift String?

Je cherche un moyen de remplacer les personnages d'un Swift String.

Exemple: "Ceci est ma chaîne"

Je voudrais remplacer "" par "+" pour obtenir "This + is + my + string".

Comment puis-je atteindre cet objectif?

Cette réponse a été mise à jour pour Swift 4 et 5 . Si vous utilisez toujours Swift 1, 2 ou 3, consultez l'historique des révisions.

Vous avez plusieurs options. Vous pouvez faire comme suggéré par @jaumard et utiliserreplacingOccurrences()

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

Et comme indiqué par @cprcrack ci-dessous, les paramètres optionset rangesont facultatifs, donc si vous ne souhaitez pas spécifier d'options de comparaison de chaînes ou d'une plage pour effectuer le remplacement, vous n'avez besoin que des éléments suivants.

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

Ou, si les données sont dans un format spécifique comme celui-ci, où vous remplacez simplement des caractères de séparation, vous pouvez utiliser components()pour diviser la chaîne en un tableau, puis vous pouvez utiliser la join()fonction pour les remettre ensemble avec un séparateur spécifié .

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

Ou si vous recherchez une solution plus Swifty qui n'utilise pas l'API de NSString, vous pouvez l'utiliser.

let aString = "Some search text"

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

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

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

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

Production:

result : Hello_world

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

Usage:

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

Une solution Swift 3 sur le modèle de celle de Sunkas:

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

Utilisation:

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

Production:

foo?

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

Utilisation:

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

Solution Swift 3 basée sur la 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)
    }
}

J'ai essayé de trouver un nom de fonction approprié selon la convention de dénomination de Swift 3.

Il m'est moins arrivé, je veux juste changer (un mot ou un caractère) dans le String

J'ai donc utilisé le 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
     }
    }

usage

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)

Je pense que Regex est le moyen le plus flexible et le plus 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 rapide:

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 ne peux guère être fier, mais vous pouvez passer un tableau Stringen un seul passage pour faire plus d'un remplacement.

Voici l'exemple de Swift 3:

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

C'est facile dans swift 4.2. il suffit d'utiliser replacingOccurrences(of: " ", with: "_")pour remplacer

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

Xcode 11 • Swift 5.1

La méthode de mutation de StringProtocol replacingOccurrencespeut être implémentée comme suit:

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 vous ne souhaitez pas utiliser les NSStringméthodes Objective-C , vous pouvez simplement utiliser splitet join:

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

split(string, isSeparator: { $0 == " " })renvoie un tableau de chaînes ( ["This", "is", "my", "string"]).

joinse joint à ces éléments avec un +, ce qui entraîne la sortie désirée: "This+is+my+string".

J'ai implémenté cette fonction très simple:

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

Vous pouvez donc écrire:

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

vous pouvez tester ceci:

laissez newString = test.stringByReplacingOccurrencesOfString ("", withString: "+", options: nil, plage: nil)

Voici une extension pour une méthode de remplacement des occurrences sur place String, qui n'est pas une copie inutile et fait tout en place:

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 signature de la méthode imite également la signature de la String.replacingOccurrences()méthode intégrée )

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

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