Как проверить, содержит ли строка другую строку в Swift?

Способ расширения

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

Обычно Swift 4 имеет contains, однако он доступен из iOS 8.0 +

Swift 3.1

Вы можете написать расширение contains: и containsIgnoringCase для 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 
   }
 }

Старая версия 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
     }
}

Пример:

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

В документах кажется, что вызов containsString() в String должен работать:

Swifts Строковый тип легко соединяется с Foundations NSString класс. Если вы работаете с базой Foundation в Cocoa или Cocoa Нажмите, весь API NSString доступен для вызова любого Строковое значение, которое вы создаете, в дополнение к описанным выше функциям String в этой главе. Вы также можете использовать значение String с любым API, который требуется экземпляр NSString.

Однако, похоже, что это не работает.

Если вы попытаетесь использовать someString.containsString(anotherString), вы получите ошибку времени компиляции, в которой указано 'String' does not contain a member named 'containsString'.

Итак, у вас осталось несколько опций, один из которых заключается в явном переносе вашего String в Objective-C с помощью bridgeToObjectiveC(), другие два явно задействуют NSString, а последний включает в себя String до NSString

С помощью моста вы получите:

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

Явным образом набрав строку как NSString, вы получите:

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

Если у вас есть существующий String, вы можете инициализировать NSString из него с помощью NSString (string:):

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

И, наконец, вы можете применить существующий String к NSString, как показано ниже

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

Другой. Поддерживает регистр и диакритические варианты.

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

Использование

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

iOS 9 +

Доступна функция случая и диакритическая нечувствительность, доступная с iOS 9.

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

В Xcode 7.1 и Swift 2.1 containsString() работает нормально для меня.

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

Swift 4:

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

И пример без учета регистра Swift 4:

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

Или используя нечувствительность к регистру String extension:

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

использование

func contains(_ str: String) -> Bool

пример

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

В SWIFT 3.0

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

Выход

String Contains Another String

Вы можете сделать это очень легко в Swift с помощью кода:

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

Из всех ответов здесь я думаю, что они либо не работают, либо они немного взломаны (отбрасываются на NSString). Очень вероятно, что правильный ответ на это изменился с различными бета-версиями.

Вот что я использую:

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

В бета-версии 5 потребовалось "!= nil".

Просто добавление к ответам здесь.

Вы также можете выполнить локальный тест без учета регистра, используя:

 - (BOOL)localizedCaseInsensitiveContainsString:(NSString *)aString

Пример:

    import Foundation

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

ОБНОВИТЬ

Это часть Foundation Framework для iOS и Mac OS X 10.10.x и была частью 10.10 во время моей первоначальной публикации.

Сгенерировано документа: 2014-06-05 12:26:27 -0700 Замечания к выпуску OS X Apple Inc., 2014. Все права защищены.

Замечания к выпуску OS X 10.10 Cocoa Foundation Framework

NSString теперь имеет следующие два вспомогательных метода:

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

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

Здесь вы находитесь:

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

Вот мой первый удар в этом месте на быстрой игровой площадке. Я расширяю String, предоставляя две новые функции (содержит и содержитIgnoreCase)

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

Используйте его так:

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

Я бы приветствовал любую обратную связь:)

В Swift 3

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

Вам не нужно писать какой-либо пользовательский код для этого. Начиная с версии 1.2 у Swift уже были все необходимые методы:

• получение длины строки: count(string);
• проверка строки, содержащей строку: contains(string, substring);
• проверка, начинается ли строка с подстроки: startsWith(string, substring)
• и т.д.

Здесь вы идете! Готов к Xcode 8 и 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

Swift 4 способа проверить наличие подстрок, включая необходимый импорт фреймворка Foundation (или UIKit):

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

Если не импортирована str.contains("Can") Foundation (или UIKit), str.contains("Can") выдаст ошибку компилятора.

Этот ответ является регургитирующим ответом manojlds, который является полностью правильным. Я понятия не имею, почему столько ответов проходит так много проблем, чтобы воссоздать String.contains(subString: String) Foundation String.contains(subString: String).

Проверьте, содержит ли он 'Hello'

let s = "Hello World"

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

Версия 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")
}

Вы также можете использовать contains:

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

string.containsString доступен только в 10.10 Yosemite (и, возможно, iOS8). Также переместите его на ObjectiveC в 10.9. Вы пытаетесь передать NSString в NSCFString. Я не знаю разницы, но могу сказать 10,9 бар, когда он выполняет этот код в приложении OS X 10.9.

Вот различия в Swift с 10.9 и 10.10: https://developer.apple.com/library/prerelease/mac/documentation/General/Reference/APIDiffsMacOSX10_10SeedDiff/index.html containsString доступен только в 10.10

Диапазон строк выше отлично работает на 10.9. Я нахожу, что разработка на 10.9 является суперстабильной с Xcode beta2. Я не пользуюсь игровыми площадками или версией игровых площадок в командной строке. Я нахожу, что если импортировать правильные фреймворки, автозаполнение очень полезно.

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

Если вы хотите проверить, что одна строка содержит в себе другую подстроку или нет, вы можете проверить это так же,

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

Теперь, в этой конкретной строке, если вы хотите знать, содержит ли она фруктовое название "яблоко" или нет, вы можете сделать,

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

Надеюсь, что это работает для вас.

Swift 3: Здесь вы можете увидеть мою строку интеллектуального поиска fro string, которая позволяет вам выполнять поиск по строке для просмотра, если она содержит, или, возможно, для фильтрации коллекции на основе текста поиска.

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

Я нашел несколько интересных вариантов использования. Эти варианты используют метод rangeOfString, и я включаю пример равенства, чтобы показать, как лучше всего использовать функции поиска и сравнения строк в Swift 2.0

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

Позже, после внесения изменений в self.myObject, я могу обратиться к после процедур сравнения строк (настройка как ленивых переменных, которые вернуть Bool). Это позволяет проверять состояние в любое время.

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

Вариант этого случается, когда мне иногда приходится анализировать недостающие свойство на этом объекте. Строковый поиск позволяет мне найти для конкретной подстроки установлено значение nil (по умолчанию, когда объект создан).

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

В iOS 8 и новее вы можете использовать эти два метода NSString:

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

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

Вы можете просто сделать то, что вы упомянули:

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

Из документов:

Тип Swifts String легко соединяется с классом Foundations NSString. Если вы работаете с платформой Foundation в Cocoa или Cocoa Touch, весь API NSString доступен для вызова любого значения String вы создаете, в дополнение к функциям String, описанным в этой главе. Вы также можете использовать значение String с любым API, для которого требуется экземпляр NSString.

Вам необходимо import Foundation чтобы NSString методы NSString и сделать их доступными для класса Swift String.

SWIFT 4 - это очень просто!

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