index - swift search string for substring




Come posso verificare se una stringa contiene un'altra stringa in Swift? (16)

In Objective-C il codice per verificare una sottostringa in una NSString è:

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

Ma come faccio a farlo in Swift?


In Swift 4.2

Uso

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

Esempio

String Contains Another String

Modo di estensione

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

Generalmente Swift 4 contains metodo comunque disponibile da iOS 8.0+

Swift 3.1

È possibile scrivere l'estensione contains: e containsIgnoringCase for 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 
   }
 }

Versione precedente di Swift

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

Esempio:

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

Controlla se contiene "Ciao"

let s = "Hello World"

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

Dai documenti, sembra che la chiamata containsString() su una stringa dovrebbe funzionare:

Il tipo di stringa di Swift viene collegato senza interruzioni alla classe NSString di Foundation. Se si sta lavorando con il framework Foundation in Cocoa o Cocoa Touch, l'intera API NSString è disponibile per chiamare qualsiasi valore di stringa creato, oltre alle funzionalità String descritte in questo capitolo. Puoi anche utilizzare un valore String con qualsiasi API che richiede un'istanza NSString.

Tuttavia, non sembra funzionare in questo modo.

Se si tenta di utilizzare someString.containsString(anotherString) , verrà visualizzato un errore in fase di compilazione in cui viene indicato che 'String' does not contain a member named 'containsString' .

Quindi, ti restano alcune opzioni, una delle quali consiste nel collegare esplicitamente la tua String a Objective-C usando bridgeToObjectiveC() altre due implicano esplicitamente l'uso di una NSString e quella finale implica il cast della String su una NSString

Collegando, otterresti:

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

Digitando esplicitamente la stringa come NSString , NSString :

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

Se si dispone di una String esistente, è possibile inizializzare una NSString utilizzando NSString (stringa :):

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

E infine, puoi lanciare una String esistente su una NSString come di seguito

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

Ecco la mia prima pugnalata a questo nel campo da giuoco veloce. Estendo String fornendo due nuove funzioni (contiene e contiene IgnoraCase)

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 in questo modo

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

Sarei felice di ricevere qualsiasi feedback :)


Ecco qui! Pronto per Xcode 8 e 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

Ho trovato un paio di casi d'uso interessanti. Queste varianti fanno uso del metodo rangeOfString e includo l'esempio di uguaglianza per mostrare come si possa utilizzare al meglio le funzionalità di ricerca e confronto di Strings in Swift 2.0

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

Successivamente, dopo aver apportato le modifiche a self.myObject, posso fare riferimento alle seguenti routine di confronto delle stringhe (l'installazione come variabili lazy che restituiscono un Bool). Ciò consente di controllare lo stato in qualsiasi momento.

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

Una variante di questo accade quando a volte ho bisogno di analizzare una proprietà mancante su quell'oggetto. Una ricerca di stringhe mi consente di trovare una sottostringa particolare impostata su zero (l'impostazione predefinita quando viene creato un oggetto).

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

In Swift 3

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

Non è necessario scrivere alcun codice personalizzato per questo. A partire dalla versione 1.2 Swift ha già avuto tutti i metodi necessari:

  • ottenere la lunghezza della stringa: count(string) ;
  • controllando se la stringa contiene sottostringa: contains(string, substring) ;
  • controllando se la stringa inizia con la sottostringa: startsWith(string, substring)
  • e così via.

Puoi fare esattamente la stessa chiamata 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")
}

Older Swift

var string = "hello Swift"

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

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

Spero che questa sia una soluzione utile dal momento che alcune persone, incluso me, hanno incontrato strani problemi chiamando containsString() .

PS. Non dimenticare di import Foundation


Puoi semplicemente fare ciò che hai menzionato:

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

Dai documenti:

Il tipo di String di Swift viene collegato senza NSString classe NSString di Foundation. Se si sta lavorando con il framework Foundation in Cocoa o Cocoa Touch, l'intera API NSString è disponibile per chiamare qualsiasi valore di String creato, oltre alle funzionalità String descritte in questo capitolo. Puoi anche utilizzare un valore String con qualsiasi API che richiede un'istanza NSString.

È necessario import Foundation per collegare i metodi NSString e renderli disponibili alla classe String di Swift.


SWIFT 4 è molto semplice !!

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

Un altro. Supporta case e opzioni diacritiche.

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+

Caso e funzione diacritica insensibile disponibile da iOS 9.

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

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

Puoi anche usare contains :

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

> IN SWIFT 3.0

func contains(_ str: String) -> Bool

Produzione

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

Swift 3: qui puoi vedere la mia estensione di ricerca intelligente con la stringa che ti permette di fare una ricerca sulla stringa per vedere se contiene, o forse per filtrare una collezione basata su un testo di ricerca.

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





swift