ios switch Qualquer maneira de substituir caracteres no Swift String?




switch case ios swift (13)

Se você não quiser usar os métodos Objective-C NSString , você pode simplesmente usar split e join :

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

split(string, isSeparator: { $0 == " " }) retorna uma matriz de strings ( ["This", "is", "my", "string"] ).

join une esses elementos com um + , resultando na saída desejada: "This+is+my+string" .

Eu estou procurando uma maneira de substituir caracteres em uma String Swift.

Exemplo: "This is my string"

Eu gostaria de substituir com + para obter: "This+is+my+string" .

Como posso conseguir isso?


Eu estou usando esta extensão:

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

Esta resposta foi atualizada para o Swift 4 . Se você ainda estiver usando o Swift 1, 2 ou 3, consulte o histórico de revisões.

Você tem algumas opções. Você pode fazer como @jaumard sugeriu e usar replacingOccurrences()

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

E como observado por @cprcrack abaixo, as options e parâmetros de range são opcionais, portanto, se você não quiser especificar opções de comparação de string ou um intervalo para fazer a substituição, você só precisa do seguinte.

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

Ou, se os dados estão em um formato específico como este, onde você está apenas substituindo caracteres de separação, você pode usar components() para quebrar a string e matriz, e então você pode usar a função join() para colocá-los de volta para junto com um separador especificado.

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

Ou se você estiver procurando por uma solução mais Swifty que não utilize API do NSString, você poderia usar isso.

let aString = "Some search text"

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

Swift 3, Swift 4 Solution

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

Solução Swift 3 baseada na resposta de Ramis :

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

Tentei criar um nome de função apropriado de acordo com a convenção de nomes do Swift 3.


Eu acho que o Regex é a maneira mais flexível e 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"

Você pode usar isto:

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

Se você adicionar este método de extensão em qualquer parte do seu 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)
    }
}

Swift 4:

let abc = "Hello world"

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

print(result :\(result))

Saída:

result : Hello_world

Uma categoria que modifica uma string mutável existente:

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

Usar:

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

Aqui está o exemplo para o Swift 3:

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

Isso é fácil em rápida 4.2. basta usar replacingOccurrences(of: " ", with: "_") para substituir

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

Aqui está uma extensão para um método de substituição de ocorrências no local em String , que não tem uma cópia desnecessária e faz tudo no 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
    }
}

(A assinatura do método também imita a assinatura do método String.replacingOccurrences() )

Pode ser usado da seguinte maneira:

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

Uma solução Swift 3 ao longo das linhas de Sunkas:

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

Usar:

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

Saída:

foo?






string