Swift에서 문자열에 다른 문자열이 포함되어 있는지 어떻게 확인합니까?

에서 Objective-C코드에서 문자열을 확인 할 NSString수 있습니다 :

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

그러나 Swift에서 어떻게해야합니까?

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

추신. 잊지 마세요import Foundation

각주

1. Strings에서 수집 함수를 사용 하면 예를 들어 이모티콘이나 악센트 문자와 같은 다른 grapheme 클러스터를 다룰 때 예기치 않은 결과를 줄 수있는 몇 가지 경우 가 있음을 기억하십시오 .

확장 방법

스위프트 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 에는 방법 이 포함되어 있지만 iOS 8.0 이상에서 사용할 수 있습니다.

스위프트 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 
   }
 }

이전 스위프트 버전

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()문자열 을 호출 하면 작동하는 것 같습니다 .

Swift의 String 유형은 Foundation의 NSString 클래스와 완벽하게 연결됩니다. Cocoa 또는 Cocoa Touch에서 Foundation 프레임 워크를 사용하는 경우이 장에서 설명하는 String 기능 외에도 전체 NSString API를 사용하여 생성 한 모든 String 값을 호출 할 수 있습니다. NSString 인스턴스가 필요한 API와 함께 String 값을 사용할 수도 있습니다.

그러나 그런 식으로 작동하지 않는 것 같습니다.

을 사용하려고 someString.containsString(anotherString)하면 컴파일 시간 오류가 발생합니다.'String' does not contain a member named 'containsString' .

따라서 몇 가지 옵션이 있습니다. 그중 하나는 명시 적으로 다른 두 가지 String를 사용하여 Objective-C에 명시 적으로 브리지 하는 것입니다.bridgeToObjectiveC()NSStringString 로를NSString

브리징을 통해 다음을 얻을 수 있습니다.

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

문자열을 명시 적으로 입력 NSString하면 다음을 얻을 수 있습니다.

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

기존이있는 경우 StringNSString (string :)을 사용하여 NSString을 초기화 할 수 있습니다.

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

다른 것. 대소 문자 및 분음 부호 옵션을 지원합니다.

스위프트 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")
}

스위프트 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 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

스위프트 4.2

사용하다

func contains(_ str: String) -> Bool

예

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

> 스위프트 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")}

여기에 대한 답변에 대한 부록.

다음을 사용하여 대소 문자를 구분하지 않는 테스트를 수행 할 수도 있습니다.

 - (BOOL)localizedCaseInsensitiveContainsString:(NSString *)aString

예:

    import Foundation

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

최신 정보

이것은 iOS 및 Mac OS X 10.10.x 용 Foundation 프레임 워크의 일부이며 원래 게시 당시 10.10의 일부였습니다.

생성 된 문서 : 2014-06-05 12:26:27 -0700 OS X 릴리스 노트 저작권 © 2014 Apple Inc. 모든 권리 보유.

OS X 10.10 릴리스 노트 Cocoa Foundation Framework

NSString에는 다음과 같은 두 가지 편리한 방법이 있습니다.

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

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

스위프트 놀이터에서 이것에 대한 나의 첫 찌르기입니다. 두 가지 새로운 기능 (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

나는 어떤 의견을 환영합니다 :)

여기에있는 모든 대답 중, 나는 그들이 작동하지 않거나 약간의 해킹이라고 생각합니다 (NSString으로 다시 캐스팅). 이에 대한 정답이 다른 베타 버전으로 변경되었을 가능성이 큽니다.

내가 사용하는 것은 다음과 같습니다.

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

베타 5에서는 "! = nil"이 필요합니다.

여기 있어요:

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

이를 위해 사용자 정의 코드를 작성할 필요가 없습니다. 1.2 버전부터 Swift에는 필요한 모든 방법이 이미 있습니다.

• 문자열 길이를 얻는 중 : count(string);
• 문자열에 하위 문자열이 포함되어 있는지 확인 : contains(string, substring);
• 문자열이 하위 문자열로 시작하는지 확인 : startsWith(string, substring)
• 등

스위프트 3 년

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

여기 있습니다! 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

string.containsString은 10.10 Yosemite (및 아마도 iOS8)에서만 사용할 수 있습니다. 또한 ObjectiveC에 연결하면 10.9에서 충돌이 발생합니다. NSString을 NSCFString에 전달하려고합니다. 차이점을 모르지만 OS X 10.9 앱 에서이 코드를 실행할 때 10.9 barfs라고 말할 수 있습니다.

다음은 Swift와 10.9 및 10.10의 차이점입니다. https://developer.apple.com/library/prerelease/mac/documentation/General/Reference/APIDiffsMacOSX10_10SeedDiff/index.html containsString containsString은 10.10에서만 사용할 수 있습니다

위의 문자열 범위는 10.9에서 훌륭하게 작동합니다. 10.9에서 개발하는 것이 Xcode beta2로 매우 안정적이라는 것을 알았습니다. 나는 통해 놀이터 나 운동장의 명령 행 버전을 사용하지 마십시오. 적절한 프레임 워크를 가져 오면 자동 완성이 매우 도움이됩니다.

swift 4의 새로운 구문을 사용하면

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

문자열은 문자열 변수입니다

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

'Hello'가 포함되어 있는지 확인하십시오.

let s = "Hello World"

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

필요한 Foundation(또는 UIKit) 프레임 워크 가져 오기를 포함하여 하위 문자열을 확인하는 Swift 4 방법 :

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

Foundation(또는 UIKit) 프레임 워크를 가져 오지 않으면 str.contains("Can")컴파일러 오류가 발생합니다.

이 답변은 manojlds의 답변을 철회하고 있습니다. 왜 그렇게 많은 답변이 너무 많은 문제를 겪고 Foundation의 String.contains(subString: String)방법 을 재현하는 지 모릅니다 .

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

스위프트 3 : 여기에 문자열이 포함되어 있는지 확인하거나 검색 텍스트를 기반으로 컬렉션을 필터링 할 수있는 스마트 검색 확장 프로그램이 문자열로 표시됩니다.

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

iOS 8 이상에서는 다음 두 가지 NSString방법을 사용할 수 있습니다 .

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

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

몇 가지 흥미로운 사용 사례를 발견했습니다. 이 변형은 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
    }()

한 문자열에 다른 하위 문자열이 포함되어 있는지 확인하려면 다음과 같이 확인할 수도 있습니다.

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

이 특정 문자열에서 과일 이름 'apple'이 포함되어 있는지 여부를 알고 싶다면 할 수 있습니다.

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

이것이 효과가 있기를 바랍니다.

당신은 당신이 언급 한 것을 할 수 있습니다 :

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

문서에서 :

스위프트 String타입은 재단의 NSString 클래스와 완벽하게 연결되어 있습니다. Cocoa 또는 Cocoa Touch에서 Foundation 프레임 워크를 NSString사용하는 String경우이 장에서 설명하는 문자열 기능 외에도 전체 API를 사용하여 생성 한 모든 값 을 호출 할 수 있습니다. NSString 인스턴스가 필요한 API와 함께 String 값을 사용할 수도 있습니다.

당신은 할 필요가 import Foundation브리지에 NSString방법 및 스위프트의 String 클래스에 사용할 수 있도록.

SWIFT 4는 매우 쉽습니다!

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