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

В Objective-C код для проверки подстроки в NSString:

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

Но как это сделать в Swift?

ОТВЕТЫ

Ответ 1

Вы можете сделать точно такой же вызов с Swift:

Свифт 4 и Свифт 5

В Swift 4 String представляет собой набор значений Character, это не было так в Swift 2 и 3, поэтому вы можете использовать этот более краткий код 1:

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

Свифт 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")
}

Олд Свифт

var string = "hello Swift"

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

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

Я надеюсь, что это полезное решение, так как некоторые люди, в том числе и я, столкнулись с некоторыми странными проблемами, вызвав функцию containsString(). 1

PS. Не забудьте import Foundation

Сноски

  1. Просто помните, что использование функций сбора в строках имеет некоторые крайние случаи, которые могут дать вам неожиданные результаты, например, при работе с эмодзи или другими кластерами графем, такими как буквы с акцентом.

Ответ 2

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

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

Ответ 3

В документах кажется, что вызов 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")
}

Ответ 4

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

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
}

Ответ 5

В 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

Ответ 6

В Swift 4.2

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

func contains(_ str: String) -> Bool

пример

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

Ответ 7

В 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

Ответ 8

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

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

Ответ 9

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

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

 - (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;

Ответ 10

Вот мой первый удар в этом месте на быстрой игровой площадке. Я расширяю 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

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

Ответ 11

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

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

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

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

Ответ 12

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

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

Ответ 13

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

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

Ответ 14

В Swift 3

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

Ответ 15

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

Ответ 16

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. Я не пользуюсь игровыми площадками или версией игровых площадок в командной строке. Я нахожу, что если импортировать правильные фреймворки, автозаполнение очень полезно.

Ответ 17

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

Ответ 18

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

let s = "Hello World"

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

Ответ 19

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).

Ответ 20

С новым синтаксисом в Swift 4 вы можете просто

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

строка ваша строковая переменная

Ответ 21

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

Ответ 22

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

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

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

Ответ 23

Я нашел несколько интересных вариантов использования. Эти варианты используют метод 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
    }()

Ответ 24

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

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

Ответ 25

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

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

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

Ответ 26

var str = "Hello, playground"
 print(str.count)

это для swift4 и swift5

Ответ 27

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

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.

Ответ 28

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

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