Bir dizenin Swift'te başka bir dize içerip içermediğini nasıl kontrol ederim?

Gelen Objective-Ckod bir bir alt dize denetlemek için NSStringgeçerli:

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

Ama bunu Swift'te nasıl yaparım?

Aynı aramayı Swift ile de yapabilirsiniz:

Swift 4 ve Swift 5

Swift 4 String bir Characterdeğerler koleksiyonudur, Swift 2 ve 3'te böyle değildi, bu yüzden bu daha kısa kod ^{1'i kullanabilirsiniz} :

let string = "hello Swift"
if string.contains("Swift") {
    print("exists")
}

Swift 3.0 ve üzeri

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

Yaşlı Swift

var string = "hello Swift"

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

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

Umarım bu yararlı bir çözümdür, çünkü ben dahil bazı insanlar arayarak garip sorunlarla karşılaşmıştır containsString(). ¹

PS. Unutmaimport Foundation

Dipnotlar

1. Dizelerde toplama işlevlerini kullanmanın , örneğin emoji veya aksanlı harfler gibi diğer grafik kümeleriyle uğraşırken beklenmedik sonuçlar verebilecek bazı kenar durumları olduğunu unutmayın.

Uzatma yolu

Hızlı 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

Genellikle Swift 4'te yöntem vardır , ancak iOS 8.0+

Hızlı 3.1

Sen uzantıyı yazabilir contains:ve containsIgnoringCaseiçinString

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

Eski Swift sürümü

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

Misal:

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

Dokümanlardan, containsString()bir String'i çağırmanın çalışması gerektiği anlaşılıyor :

Swift'in String tipi, Foundation'ın NSString sınıfına sorunsuz bir şekilde köprülenir. Kakao veya Kakao Dokunuşundaki Temel çerçevesiyle çalışıyorsanız, bu bölümde açıklanan Dize özelliklerine ek olarak, oluşturduğunuz herhangi bir Dize değerini çağırmak için tüm NSString API'sini kullanabilirsiniz. Dize değerini, NSString örneği gerektiren herhangi bir API ile de kullanabilirsiniz.

Ancak, bu şekilde çalışmıyor gibi görünüyor.

Kullanmaya çalışırsanız someString.containsString(anotherString), derleme zamanı hatası alırsınız 'String' does not contain a member named 'containsString'.

Yani, bir kaç seçeneğiniz kaldı, bunlardan biri açıkça açıkça StringObjective-C'ye köprülemek ve bridgeToObjectiveC()diğer ikisini kullanarak açıkça kullanmaktır NSStringve sonuncusu StringbirNSString

Köprü kurarak şunları elde edersiniz:

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

Dizeyi açıkça bir olarak yazarak NSStringşunları elde edersiniz:

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

Mevcut Stringbir hesabınız varsa, NSString (string :) kullanarak bir NSString başlatabilirsiniz:

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

Ve son olarak, varolan yayınlayabileceğim Stringbir etmek NSStringaşağıda

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

Bir diğeri. Vaka ve aksan seçeneklerini destekler.

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

kullanım

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

iOS 9 ve sonraki sürümleri

İOS 9'dan beri kasa ve aksan duyarsız işlevi mevcut.

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

Xcode 7.1 ve Swift 2.1'den itibaren containsString()benim için iyi çalışıyor.

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

Hızlı 4:

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

Ve büyük / küçük harfe duyarlı olmayan Swift 4 örneği:

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

Veya büyük / küçük harfe duyarlı olmayan bir Stringuzantı kullanarak :

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

Swift 4.2 içinde

kullanım

func contains(_ str: String) -> Bool

Misal

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

> SWIFT 3.0'DA

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

Çıktı

String Contains Another String

Swift'te kodu kullanarak bunu kolayca yapabilirsiniz:

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

Buradaki cevaplara bir zeyilname.

Ayrıca aşağıdakileri kullanarak yerel bir büyük / küçük harfe duyarlı olmayan test de yapabilirsiniz:

 - (BOOL)localizedCaseInsensitiveContainsString:(NSString *)aString

Misal:

    import Foundation

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

GÜNCELLEME

Bu, iOS ve Mac OS X 10.10.x için Foundation Framework'ün bir parçasıdır ve Orijinal Gönderim Zamanında 10.10'un bir parçasıydı.

Oluşturulan Belge: 2014-06-05 12:26:27 -0700 OS X Sürüm Notları Telif Hakkı © 2014 Apple Inc. Tüm Hakları Saklıdır.

OS X 10.10 Sürüm Notları Kakao Vakfı Çerçevesi

NSString artık aşağıdaki iki kolaylık yöntemine sahiptir:

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

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

İşte bu hızlı oyun alanında ilk bıçaklamam. Ben iki yeni işlev sağlayarak String içerir (içerir ve içerirIgnoreCase)

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

Bu şekilde kullanın

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

Herhangi bir geri bildirim hoş geldiniz :)

Buradaki tüm cevaplar arasında, ya işe yaramıyorlar ya da biraz hack (NSString'e geri dönüyorlar). Farklı beta sürümleriyle buna doğru cevabın değişmiş olması muhtemeldir.

İşte ne kullanıyorum:

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

Beta! İle "! = Nil" gerekli hale geldi.

Buyrun:

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

Bunun için herhangi bir özel kod yazmanıza gerek yoktur. 1.2 sürümünden başlayarak Swift zaten ihtiyacınız olan tüm yöntemlere sahipti:

• dize uzunluğu alma count(string):;
• dizenin alt dize içerip içermediğini denetleme contains(string, substring):;
• dizenin alt dize ile başlayıp başlamadığını kontrol etme: startsWith(string, substring)
• ve benzeri.

Swift 3'te

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

Hadi bakalım! Xcode 8 ve Swift 3 için hazır.

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

string.containsString yalnızca 10.10 Yosemite (ve muhtemelen iOS8) sürümlerinde kullanılabilir. Ayrıca 10.9 yılında ObjectiveC çöküyor onu köprüler. NSString'i NSCFString'e geçirmeye çalışıyorsunuz. Farkı bilmiyorum, ama bir OS X 10.9 uygulamasında bu kodu çalıştırdığında 10.9 barfs diyebilirim.

Swift'te 10.9 ve 10.10 ile farklar: https://developer.apple.com/library/prerelease/mac/documentation/General/Reference/APIDiffsMacOSX10_10SeedDiff/index.html yalnızca 10.10'da kullanılabilir

Yukarıdaki String aralığı 10.9'da harika çalışıyor. Ben 10.9 üzerinde geliştirme Xcode beta2 ile süper kararlı buluyorum. Oyun alanlarını veya oyun alanlarının komut satırı sürümünü kullanmıyorum. Uygun çerçevelerin içe aktarılıp aktarılmadığını otomatik tamamlamanın çok yararlı olduğunu anlıyorum.

Hızlı 4'te ve yeni sözdizimi ile

string.contains("Swift 4 is the best")

string sizin string değişkeninizdir

Xcode 8 / Swift 3 sürümü:

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

Ayrıca şunları kullanabilirsiniz contains:

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

'Merhaba' içerip içermediğini kontrol edin

let s = "Hello World"

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

Gerekli Foundation(veya UIKit) çerçeve içe aktarma dahil alt dizeleri kontrol etmek için Swift 4 yolu :

import Foundation // or UIKit

let str = "Oh Canada!"

str.contains("Can") // returns true

str.contains("can") // returns false

str.lowercased().contains("can") // case-insensitive, returns true

Sürece Foundation(veya UIKit) çerçeve ithal edilir, str.contains("Can")bir derleyici hata verecektir.

Bu cevap manojlds'in cevabını tamamen doğru olan cevabını canlandırıyor . Pek çok cevaplar yeniden yaratmak bu kadar sorun geçmesi niçin hiçbir fikrim yok Foundation'in String.contains(subString: String)yöntemi.

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

Swift 3: Burada, içerdiğini görmek için dizede arama yapmanıza veya belki de bir koleksiyonu bir arama metnine göre filtrelemenize olanak tanıyan akıllı arama uzantımı görebilirsiniz.

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

İOS 8 ve daha yeni sürümlerde şu iki NSStringyöntemi kullanabilirsiniz :

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

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

Birkaç ilginç kullanım durumu buldum. Bu varyantlar rangeOfString yöntemini kullanır ve Swift 2.0'da Dizelerin arama ve karşılaştırma özelliklerini en iyi nasıl kullanabileceğini göstermek için eşitlik örneğini eklerim

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

Daha sonra self.myObject üzerinde değişiklikler yaptıktan sonra, aşağıdaki dize karşılaştırma rutinlerine başvurabilirim (bir Bool döndüren tembel değişkenler olarak kurulum). Bu, herhangi bir zamanda durumu kontrol etmeyi sağlar.

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

Bunun bir varyantı bazen bu nesne üzerinde eksik bir özelliği analiz etmem gerektiğinde olur. Dize araması, nil olarak ayarlanan belirli bir alt dizeyi bulmama izin veriyor (bir nesne oluşturulduğunda varsayılan).

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

Bir Dizenin içinde başka bir Alt Dizenin bulunup bulunmadığını kontrol etmek istiyorsanız, bunu da kontrol edebilirsiniz,

var name = String()  
name = "John has two apples." 

Şimdi, bu özel dizede 'apple' meyve adı içerip içermediğini bilmek istiyorsanız,

if name.contains("apple")      
{  
print("Yes , it contains fruit name")    
}    
else      
{    
 print(it does not contain any fruit name)    
}    

Umarım bu sizin için çalışır.

Sadece bahsettiklerinizi yapabilirsiniz:

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

Dokümanlardan:

Swift'in Stringtürü Foundation'ın NSString sınıfına sorunsuz bir şekilde köprülenir . Kakao veya Kakao Dokunuşundaki Temel çerçevesiyle çalışıyorsanız , bu bölümde açıklanan Dize özelliklerine ek olarak oluşturduğunuz NSStringherhangi bir Stringdeğeri çağırmak için tüm API kullanılabilir . Dize değerini, NSString örneği gerektiren herhangi bir API ile de kullanabilirsiniz.

Sen gerekir import Foundationköprü NSStringyöntem ve Swift'in String sınıfına kullanılabilir hale getirmek.

SWIFT 4 çok kolay !!

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