the - swift(lenguaje de programación)

¿Cuál es la mejor manera de determinar si una cadena contiene un carácter de un conjunto en Swift?

Question

Necesito determinar si una cadena contiene alguno de los caracteres de un conjunto personalizado que he definido.

Veo en this publicación que puede usar rangeOfString para determinar si una cadena contiene otra cadena. Esto, por supuesto, también funciona para los personajes si pruebas cada personaje de uno en uno.

Me pregunto cuál es la mejor manera de hacer esto.

Answer 1

Desde Swift 1.2 puedes hacerlo usando Set

CharacterSet.letters.isSuperset(of: CharacterSet(charactersIn: myString) // returns BOOL

Swift 3 o posterior

let customSet: CharacterSet = [" ", "-"]
let finalSet = CharacterSet.letters.union(customSet)
finalSet.isSuperset(of: CharacterSet(charactersIn: myString)) // BOOL

Answer 2

Ejemplo de Swift 3:

extension String{
var isContainsLetters : Bool{
let letters = CharacterSet.letters
return self.rangeOfCharacter(from: letters) != nil
}
}

Uso:

"123".isContainsLetters // false

Answer 3

Podrías hacerlo de esta manera:

var string = "Hello, World!"
if string.rangeOfString("W") != nil {
println("exists")
} else {
println("doesn''t exist")
}
// alternative: not case sensitive
if string.lowercaseString.rangeOfString("w") != nil {
println("exists")
} else {
println("doesn''t exist")
}

Answer 4

Puede crear un conjunto de CharacterSet contenga el conjunto de sus caracteres personalizados y luego probar la membresía con este conjunto de caracteres:

Swift 3:

let charset = CharacterSet(charactersIn: "aw")
if str.rangeOfCharacter(from: charset) != nil {
print("yes")
}

Para la comparación entre mayúsculas y minúsculas, use

if str.lowercased().rangeOfCharacter(from: charset) != nil {
print("yes")
}

(suponiendo que el juego de caracteres contenga solo letras minúsculas).

Swift 2:

let charset = NSCharacterSet(charactersInString: "aw")
if str.rangeOfCharacterFromSet(charset) != nil {
print("yes")
}

Swift 1.2

let charset = NSCharacterSet(charactersInString: "aw")
if str.rangeOfCharacterFromSet(charset, options: nil, range: nil) != nil {
println("yes")
}

Answer 5

Solución ONE LINE Swift4 para verificar si contiene letras:

var str = "Hello, World!"
let charset: Set<Character> = ["e", "n"]
charset.isSubsetOf(str) // `true` if `str` contains all characters in `charset`
charset.isDisjointWith(str) // `true` if `str` does not contains any characters in `charset`
charset.intersect(str) // set of characters both `str` and `charset` contains.

Otro caso cuando necesita validar una cadena para conjuntos de caracteres personalizados . Por ejemplo, si la cadena contiene solo letras y (por ejemplo) guiones y espacios:

let isSubset = charset.isSubset(of: str) // `true` if `str` contains all characters in `charset`
let isDisjoint = charset.isDisjoint(with: str) // `true` if `str` does not contains any characters in `charset`
let intersection = charset.intersection(str) // set of characters both `str` and `charset` contains.
print(intersection.count) // 1

Espero que ayude a alguien algún día :)

Answer 6

Swift 4

let myString = "Some Words"
if myString.contains("Some"){
print("myString contains the word `Some`")
}else{
print("myString does NOT contain the word `Some`")
}

Swift 3:

let myString = "Some Words"
if (myString.range(of: "Some") != nil){
print("myString contains the word `Some`")
}else{
print("Word does not contain `Some`")
}

Answer 7

Usando Swift 3 para determinar si su cadena contiene caracteres de un conjunto de caracteres específico :

 let letters = CharacterSet.alphanumerics
let string = "my-string_"
if (string.trimmingCharacters(in: letters) != "") {
print("Invalid characters in string.")
}
else {
print("Only letters and numbers.")
}

Answer 8

Usar así en swift 4.2

 var string = "Hello, World!"
let charSet = NSCharacterSet.letters
if string.rangeOfCharacter(from:charSet)?.isEmpty == false{
print ("String contain letters");
}

Answer 9

swift3

var str = "Hello, playground"
let res = str.characters.contains { ["x", "z"].contains( $0 ) }

Answer 10

func isAnyCharacter( from charSetString: String, containedIn string: String ) -> Bool
{
return Set( charSetString.characters ).isDisjointWith( Set( string.characters) ) == false
}