index - ¿Cómo compruebo si una cadena contiene otra cadena en Swift?

string contains swift

Question

En Objective-C el código para verificar una subcadena en una NSString es:

NSString *string = @"hello Swift";
NSRange textRange =[string rangeOfString:@"Swift"];
if(textRange.location != NSNotFound)
{
    NSLog(@"exists");
}

¿Pero cómo hago esto en Swift?

Answer 1

En Swift 4.2

Utilizar

func contains(_ str: String) -> Bool

Ejemplo

let string = "hello Swift"
let containsSwift = string.contains("Swift")
print(containsSwift) // prints true

Answer 2

Forma de extensión

Swift 4

extension String {
    func contains(find: String) -> Bool{
        return self.range(of: find) != nil
    }
    func containsIgnoringCase(find: String) -> Bool{
        return self.range(of: find, options: .caseInsensitive) != nil
    }
}

var value = "Hello world"

print(value.contains("Hello")) // true
print(value.contains("bo"))    // false

print(value.containsIgnoringCase(find: "hello"))    // true
print(value.containsIgnoringCase(find: "Hello"))    // true
print(value.containsIgnoringCase(find: "bo"))       // false

En general, Swift 4 tiene un método, sin embargo, está disponible desde iOS 8.0+

Swift 3.1

Puede escribir la extensión contains: y containsIgnoringCase para String

extension String { 

   func contains(_ find: String) -> Bool{
     return self.range(of: find) != nil
   }

   func containsIgnoringCase(_ find: String) -> Bool{
     return self.range(of: find, options: .caseInsensitive) != nil 
   }
 }

Versión Swift más antigua

extension String {

    func contains(find: String) -> Bool{
       return self.rangeOfString(find) != nil
     }

    func containsIgnoringCase(find: String) -> Bool{
       return self.rangeOfString(find, options: NSStringCompareOptions.CaseInsensitiveSearch) != nil
     }
}

Ejemplo:

var value = "Hello world"

print(value.contains("Hello")) // true
print(value.contains("bo"))    // false

print(value.containsIgnoringCase("hello"))    // true
print(value.containsIgnoringCase("Hello"))    // true
print(value.containsIgnoringCase("bo"))       // false

Answer 3

¡Aqui tienes! Listo para Xcode 8 y Swift 3.

import UIKit

let mString = "This is a String that contains something to search."
let stringToSearchUpperCase = "String"
let stringToSearchLowerCase = "string"

mString.contains(stringToSearchUpperCase) //true
mString.contains(stringToSearchLowerCase) //false
mString.lowercased().contains(stringToSearchUpperCase) //false
mString.lowercased().contains(stringToSearchLowerCase) //true

Answer 4

A partir de Xcode 7.1 y Swift 2.1 containsString() funciona bien para mí.

let string = "hello swift"
if string.containsString("swift") {
    print("found swift")
}

Swift 4:

let string = "hello swift"
if string.contains("swift") {
    print("found swift")
}

Y un ejemplo de Swift 4 insensible a mayúsculas:

let string = "Hello Swift"
if string.lowercased().contains("swift") {
    print("found swift")
}

O usando una extensión de String insensible a mayúsculas y minúsculas:

extension String {
    func containsIgnoreCase(_ string: String) -> Bool {
        return self.lowercased().contains(string.lowercased())
    }
}

let string = "Hello Swift"
let stringToFind = "SWIFT"
if string.containsIgnoreCase(stringToFind) {
    print("found: /(stringToFind)")  // found: SWIFT
}
print("string: /(string)")
print("stringToFind: /(stringToFind)")

// console output:
found: SWIFT
string: Hello Swift
stringToFind: SWIFT

Answer 5

Aquí está mi primera puñalada en esto en el patio de recreo rápido. Extiendo String proporcionando dos nuevas funciones (contiene y contieneIgnoreCase)

extension String {
    func contains(other: String) -> Bool{
        var start = startIndex

        do{
            var subString = self[Range(start: start++, end: endIndex)]
            if subString.hasPrefix(other){
                return true
            }

        }while start != endIndex

        return false
    }

    func containsIgnoreCase(other: String) -> Bool{
        var start = startIndex

        do{
            var subString = self[Range(start: start++, end: endIndex)].lowercaseString
            if subString.hasPrefix(other.lowercaseString){
                return true
            }

        }while start != endIndex

        return false
    }
}

Usalo asi

var sentence = "This is a test sentence"
sentence.contains("this")  //returns false
sentence.contains("This")  //returns true
sentence.containsIgnoreCase("this")  //returns true

"This is another test sentence".contains(" test ")    //returns true

Me gustaría recibir cualquier comentario :)

Answer 6

Aquí estás:

let s = "hello Swift"
if let textRange = s.rangeOfString("Swift") {
    NSLog("exists")
}

Answer 7

Compruebe si contiene ''Hola''

let s = "Hello World"

if s.rangeOfString("Hello") != nil {
    print("Yes it contains ''Hello''")
}

Answer 8

De los documentos, parece que la función de funcionamiento de WITHSTRING containsString() en una cadena debería funcionar:

El tipo String de Swift se une perfectamente a la clase NSString de Foundation. Si está trabajando con Foundation framework en Cocoa o Cocoa Touch, toda la API de NSString está disponible para solicitar cualquier valor de String que cree, además de las funciones de String que se describen en este capítulo. También puede usar un valor de cadena con cualquier API que requiera una instancia de NSString.

Sin embargo, no parece funcionar de esa manera.

Si intentas usar someString.containsString(anotherString) , obtendrás un error de tiempo de compilación que indica que ''String'' does not contain a member named ''containsString'' .

Entonces, te quedan algunas opciones, una de las cuales es unir explícitamente tu String a Objective-C mediante el uso de bridgeToObjectiveC() otras dos involucran explícitamente el uso de una NSString y la última implica lanzar la String a una NSString

Al hacer un puente, obtendrías:

var string = "hello Swift"
if string.bridgeToObjectiveC().containsString("Swift") {
    println("YES")
}

Al escribir explícitamente la cadena como NSString , obtendrías:

var string: NSString = "hello Swift"
if string.containsString("Swift") {
    println("YES")
}

Si tiene un String existente, puede inicializar un NSString usando NSString (string :):

var string = "hello Swift"
if NSString(string: string).containsString("Swift") {
    println("YES")
}

Y, finalmente, puede lanzar una String existente a una NSString como se muestra a continuación

var string = "hello Swift"
if (string as NSString).containsString("Swift") {
    println("YES")
}

Answer 9

De todas las respuestas aquí, creo que o bien no funcionan, o son un poco piratas (volviendo a NSString). Es muy probable que la respuesta correcta a esto haya cambiado con las diferentes versiones beta.

Esto es lo que yo uso:

let string: String = "hello Swift"
if string.rangeOfString("Swift") != nil
{
    println("exists")
}

El "! = Nil" se volvió necesario con Beta 5.

Answer 10

En Swift 3

if((a.range(of: b!, options: String.CompareOptions.caseInsensitive, range: nil, locale: nil)) != nil){
    print("Done")
}

Answer 11

En iOS 8 y posteriores, puede usar estos dos métodos NSString :

@availability(iOS, introduced=8.0)
func containsString(aString: String) -> Bool

@availability(iOS, introduced=8.0)
func localizedCaseInsensitiveContainsString(aString: String) -> Bool

Answer 12

He encontrado un par de casos de uso interesantes. Estas variantes hacen uso del método rangeOfString e incluyo el ejemplo de igualdad para mostrar cómo se pueden usar mejor las funciones de búsqueda y comparación de Strings en Swift 2.0

//In viewDidLoad() I assign the current object description (A Swift String) to self.loadedObjectDescription
self.loadedObjectDescription = self.myObject!.description

Más tarde, después de realizar cambios en self.myObject, puedo consultar las siguientes rutinas de comparación de cadenas (configuración como variables perezosas que devuelven un Bool). Esto permite verificar el estado en cualquier momento.

lazy var objectHasChanges : Bool = {
        guard self.myObject != nil else { return false }
        return !(self.loadedObjectDescription == self.myObject!.description)
    }()

Una variante de esto sucede cuando a veces necesito analizar una propiedad que falta en ese objeto. Una búsqueda de cadena me permite encontrar una subcadena particular que se establece en nil (el valor predeterminado cuando se crea un objeto).

    lazy var isMissingProperty : Bool = {
        guard self.myObject != nil else { return true }
        let emptyPropertyValue = "myProperty = nil"
        return (self.myObject!.description.rangeOfString(emptyPropertyValue) != nil) ? true : false
    }()

Answer 13

No necesitas escribir ningún código personalizado para esto. A partir de la versión 1.2, Swift ya ha tenido todos los métodos que necesita:

• obtener la longitud de la cadena: count(string) ;
• comprobando si la cadena contiene subcadena: contains(string, substring) ;
• comprobando si la cadena comienza con subcadena: startsWith(string, substring)
• y etc.

Answer 14

Otro. Soporta mayúsculas y opciones diacríticas.

Swift 3.0

struct MyString {
  static func contains(_ text: String, substring: String,
                       ignoreCase: Bool = true,
                       ignoreDiacritic: Bool = true) -> Bool {

    var options = NSString.CompareOptions()

    if ignoreCase { _ = options.insert(NSString.CompareOptions.caseInsensitive) }
    if ignoreDiacritic { _ = options.insert(NSString.CompareOptions.diacriticInsensitive) }

    return text.range(of: substring, options: options) != nil
  }
}

Uso

MyString.contains("Niels Bohr", substring: "Bohr") // true

iOS 9+

Estuche y función insensible al diacrítico disponible desde iOS 9.

if #available(iOS 9.0, *) {
  "Für Elise".localizedStandardContains("fur") // true
}

Answer 15

Puedes hacer exactamente la misma llamada con Swift:

Swift 3.0+

var string = "hello Swift"

if string.range(of:"Swift") != nil { 
    print("exists")
}

// alternative: not case sensitive
if string.lowercased().range(of:"swift") != nil {
    print("exists")
}

Swift más viejo

var string = "hello Swift"

if string.rangeOfString("Swift") != nil{ 
    println("exists")
}

// alternative: not case sensitive
if string.lowercaseString.rangeOfString("swift") != nil {
    println("exists")
}

Espero que esta sea una solución útil ya que algunas personas, incluyéndome a mí, se encontraron con algunos problemas extraños al llamar a containsString() .

PD. No olvides import Foundation

Answer 16

Puedes hacerlo muy fácilmente en Swift usando el código:

let string = "hello Swift";
let subString = (string as NSString).containsString("Swift")
if(subString){println("Exist")}

Answer 17

SWIFT 4 es muy fácil !!

if (yourString.contains("anyThing")) {
   Print("Exist")
}

Answer 18

Solo puedes hacer lo que has mencionado:

import Foundation
...
string.containsString("Swift");

De la documentación:

El tipo String de Swift se une perfectamente a la clase NSString de NSString . Si está trabajando con Foundation framework en Cocoa o Cocoa Touch, toda la API de NSString está disponible para solicitar cualquier valor de String que cree, además de las funciones de String que se describen en este capítulo. También puede usar un valor de cadena con cualquier API que requiera una instancia de NSString.

NSString import Foundation para salvar los métodos de NSString y ponerlos a disposición de la clase String de Swift.

Answer 19

Solo un addendum a las respuestas aquí.

También puede hacer una prueba local sin distinción de mayúsculas y minúsculas utilizando:

 - (BOOL)localizedCaseInsensitiveContainsString:(NSString *)aString

Ejemplo:

    import Foundation

    var string: NSString  =  "hello Swift"
   if string.localizedCaseInsensitiveContainsString("Hello") {
    println("TRUE")
}

ACTUALIZAR

Esto es parte de Foundation Framework para iOS y Mac OS X 10.10.x y fue parte de 10.10 en el momento de mi publicación original.

Documento generado: 2014-06-05 12:26:27 -0700 OS X Release Notes Copyright © 2014 Apple Inc. Todos los derechos reservados.

OS X 10.10 Notas de la versión Cocoa Foundation Framework

NSString ahora tiene los siguientes dos métodos de conveniencia:

- (BOOL)containsString:(NSString *)str;

- (BOOL)localizedCaseInsensitiveContainsString:(NSString *)str;

Answer 20

Versión Xcode 8 / Swift 3:

let string = "hello Swift"

if let range = string.range(of: "Swift") {
    print("exists at range /(range)")
} else {
    print("does not exist")
}

if let lowercaseRange = string.lowercased().range(of: "swift") {
    print("exists at range /(lowercaseRange)")
} else {
    print("does not exist")
}

También puede utilizar contains :

string.contains("swift") // false
string.contains("Swift") // true

Answer 21

string.containsString solo está disponible en 10.10 Yosemite (y probablemente iOS8). También unirlo a ObjectiveC se bloquea en 10.9. Estás intentando pasar un NSString a NSCFString. No sé la diferencia, pero puedo decir 10,9 barfs cuando ejecuta este código en una aplicación OS X 10.9.

Aquí están las diferencias en Swift con 10.9 y 10.10: https://developer.apple.com/library/prerelease/mac/documentation/General/Reference/APIDiffsMacOSX10_10SeedDiff/index.html contentsString solo está disponible en 10.10

El rango de la cadena anterior funciona muy bien en 10.9. Estoy descubriendo que el desarrollo en 10.9 es super estable con Xcode beta2. No uso los patios de recreo ni la versión de línea de comandos de los patios de recreo. Estoy descubriendo que si se importan los marcos adecuados, el autocompletar es muy útil.

Answer 22

> EN SWIFT 3.0

let str = "Hello Swift"
if str.lowercased().contains("Swift".lowercased()) {
    print("String Contains Another String")
} else {
    print("Not Exists")
}

Salida

String Contains Another String

Answer 23

Swift 3: aquí puede ver mi extensión de búsqueda inteligente para la cadena que le permite realizar una búsqueda en la cadena para ver si contiene, o tal vez filtrar una colección basada en un texto de búsqueda.

https://github.com/magonicolas/Swift-Smart-String-Search

Answer 24

// Search string exist in employee name finding.
var empName:NSString! = employeeDetails[filterKeyString] as NSString

Case sensitve search.
let rangeOfSearchString:NSRange! = empName.rangeOfString(searchString, options: NSStringCompareOptions.CaseInsensitiveSearch)

// Not found.
if rangeOfSearchString.location != Foundation.NSNotFound
{
    // search string not found in employee name.
}
// Found
else
{
    // search string found in employee name.
}