Comment faire pour supprimer les caractères spéciaux de la chaîne dans la Swift 2?

La réponse dans
Comment démonter les caractères spéciaux de la chaîne?
n'est pas de travail.

Voici ce que j'ai eu et ça me donne une erreur

func removeSpecialCharsFromString(str: String) -> String {
    let chars: Set<String> = Set(arrayLiteral: "abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLKMNOPQRSTUVWXYZ1234567890+-*=(),.:!_")

    return String(str.characters.filter { chars.contains($0) }) //error here at $0
}

L'erreur à 0$, dit _Element(aka Personnage) ne peut pas être convertie devrait argument de type 'String'.

La ligne let text = str est tout simplement ridicule.
Dans votre lié question, l'opération est effectuée sur filter(text) tandis que vous la faites sur text.characters qui est un tableau, et la Chaîne n'a pas d'initialisation à l'aide de la matrice de caractères et donc votre fonction échoue.

InformationsquelleAutor Harout360 | 2015-09-29

52

Comme ceci:
```
func removeSpecialCharsFromString(text: String) -> String {
    let okayChars : Set<Character> = 
        Set("abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLKMNOPQRSTUVWXYZ1234567890+-*=(),.:!_".characters)
    return String(text.characters.filter {okayChars.contains($0) })
}
```
Et voici comment test:
```
let s = removeSpecialCharsFromString("père") // "pre"
```
- D'accord; mon but était de corriger les OP de la syntaxe, de ne pas résoudre le problème de façon optimale.
- Changé pour utiliser au lieu de la matrice. Recherche dans l'ensemble doivent être beaucoup plus efficace.
- Historique de réponse. Swift 2! Si vous voulez donner un Swift 4 réponse, lui donner; ne changez pas la mienne. Merci.
InformationsquelleAutor matt

SWIFT 4:

func removeSpecialCharsFromString(text: String) -> String {
    let okayChars = Set("abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLKMNOPQRSTUVWXYZ1234567890+-=().!_")
    return text.filter {okayChars.contains($0) }
}

Plus le moyen le plus propre:

extension String {

    var stripped: String {
        let okayChars = Set("abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLKMNOPQRSTUVWXYZ1234567890+-=().!_")
        return self.filter {okayChars.contains($0) }
    }
}

Utiliser cette extension comme:

let myCleanString = "some.Text@#$".stripped

De sortie: "certains.Texte"

InformationsquelleAutor Maksim Kniazev

Je pense qu'une solution de nettoyage pourrait être cette approche:

extension String {
    var alphanumeric: String {
        return self.components(separatedBy: CharacterSet.alphanumerics.inverted).joined().lowercased()
    }
}

InformationsquelleAutor Bisca

6

Dans Swift 1.2,
```
let chars = Set("abcde...")
```
créé un ensemble contenant tous les caractères de la chaîne.
Dans Swift 2.0 ce qui doit être fait comme
```
let chars = Set("abcde...".characters)
```
La raison en est qu'une chaîne de caractères elle-même n'a pas de plus se conformer à
SequenceType, vous devez utiliser le characters vue explicitement.

Avec ce changement, votre méthode compile et fonctionne comme prévu:
```
func removeSpecialCharsFromString(str: String) -> String {
    let chars = Set("abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLKMNOPQRSTUVWXYZ1234567890+-*=(),.:!_".characters)
    return String(str.characters.filter { chars.contains($0) })
}

let cleaned = removeSpecialCharsFromString("ab€xy")
print(cleaned) // abxy
```
Remarque: @Kametrixom suggéré de créer le jeu qu'une seule fois. Donc si il est
problème de performance avec la méthode ci-dessus vous pouvez soit déplacer le
déclaration de l'ensemble à l'extérieur de la fonction, ou d'en faire un
local static:
```
func removeSpecialCharsFromString(str: String) -> String {
    struct Constants {
        static let validChars = Set("abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLKMNOPQRSTUVWXYZ1234567890+-*=(),.:!_".characters)
    }
    return String(str.characters.filter { Constants.validChars.contains($0) })
}
```
- Je suggère de déplacer la déclaration de chars à l'extérieur de la fonction, comme il peut être créé à chaque fois que la fonction est appelée
InformationsquelleAutor Martin R

Si vous avez besoin de garder uniquement des caractères ascii imprimables dans une chaîne de caractères, vous pouvez simplement filtrer vérifier si leur unicodeScalar valeurs ascii:

extension Character {
    var isAscii: Bool {
        return unicodeScalars.allSatisfy { $0.isASCII }
    }
}

extension RangeReplaceableCollection where Self: StringProtocol {
    var asciiPrintable: Self {
        return filter { $0.isAscii }
    }
}

let string = "cafe\u{301}"
let asciiPrintable = string.asciiPrintable
print(asciiPrintable)  // "caf"

InformationsquelleAutor Leo Dabus

Vous devez vous connecter pour publier un commentaire.