如何在 Swift 中检查一个字符串是否包含另一个字符串？

你可以按照你提到的去做：

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

从文档中：

Swift 的类型与 Foundation 的类无缝衔接。如果您在 Cocoa 中使用 Foundation 框架或 Cocoa Touch，除了所描述的 String 功能外，整个 API 都可以调用您创建的任何值 在本章中。您还可以将 String 值与任何 API 一起使用，该 API 需要 NSString 实例。StringNSStringNSStringString

你需要桥接这些方法，并使它们可用于 Swift 的 String 类。import FoundationNSString

从文档来看，似乎调用 String 应该有效：containsString()

Swift 的 String 类型与 Foundation 的 NSString 无缝衔接 类。如果您在 Cocoa 中使用 Foundation 框架或 Cocoa Touch，整个 NSString API 可以在任何 您创建的字符串值，以及所述的字符串功能 在本章中。您还可以将 String 值与任何 API 一起使用，该 API 需要 NSString 实例。

然而，它似乎不是那样工作的。

如果尝试使用 ，则会出现编译时错误，指出 。someString.containsString(anotherString)'String' does not contain a member named 'containsString'

因此，您只剩下几个选项，其中一个是通过使用其他两个选项显式桥接 Objective-C 和最后一个涉及将 转换为StringbridgeToObjectiveC()NSStringStringNSString

通过桥接，您将获得：

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

通过将字符串显式键入为 ，您将获得：NSString

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

如果已有 ，则可以使用 NSString（string：） 从中初始化 NSString：String

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

最后，您可以将现有转换为如下所示StringNSString

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

这是我在 swift 操场上的第一次尝试。 我通过提供两个新函数（contains 和 containsIgnoreCase）来扩展 String

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 执行完全相同的调用：

斯威夫特 4 和斯威夫特 5

在 Swift 4 中，String 是一个值的集合，在 Swift 2 和 3 中不是这样的，所以你可以使用这个更简洁的代码¹：Character

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

较旧的 Swift

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. 请记住，在字符串上使用集合函数有一些边缘情况，可能会给您带来意想不到的结果，例如，在处理表情符号或其他字素簇（如重音字母）时。

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 仅在 10.10 中可用

上面的字符串范围在 10.9 上效果很好。我发现使用 Xcode beta2 在 10.9 上开发非常稳定。我不使用 playgrounds through 或 playgrounds 的命令行版本。我发现如果导入了正确的框架，自动完成功能将非常有帮助。

只是这里答案的附录。

您还可以使用以下方法进行本地不区分大小写的测试：

 - (BOOL)localizedCaseInsensitiveContainsString:(NSString *)aString

例：

    import Foundation

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

更新

这是 iOS 和 Mac OS X 10.10.x 基础框架的一部分，在我最初发布时是 10.10 的一部分。

文档生成时间：2014-06-05 12：26：27 -0700 OS X 发行说明 版权所有 © 2014 Apple Inc.保留所有权利。

OS X 10.10 发行说明可可基金会框架

NSString 现在有以下两种方便的方法：

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

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

在这里的所有答案中，我认为它们要么不起作用，要么有点黑客攻击（回放到 NSString）。这个问题的正确答案很可能随着不同的测试版版本而改变。

这是我使用的：

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

Beta 5 需要“！= nil”。

扩展方式

斯威夫特 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

你可以写 extension 和 forcontains:containsIgnoringCaseString

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

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

在 iOS 8 及更高版本中，您可以使用以下两种方法：NSString

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

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

在 Swift 中，您可以使用以下代码轻松完成此操作：

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

另一个。支持大小写和变音符号选项。

斯威夫特 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
}

您无需为此编写任何自定义代码。从 1.2 版本开始，Swift 已经拥有了您需要的所有方法：

• 获取字符串长度：count(string);
• 检查字符串是否包含子字符串：contains(string, substring);
• 检查字符串是否以子字符串开头：startsWith(string, substring)
• 等等。

给你：

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

我发现了一些有趣的用例。这些变体使用了 rangeOfString 方法，我包括了相等示例来展示如何在 Swift 2.0 中最好地使用 Strings 的搜索和比较功能

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

稍后，在我对 self.myObject 进行更改后，我可以参考 以下字符串比较例程（设置为惰性变量 返回布尔值）。这允许人们随时检查状态。

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

从 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

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

给你！支持 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 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 3 中

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

检查它是否包含“Hello”

let s = "Hello World"

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

在 Swift 4.2 中

用

func contains(_ str: String) -> Bool

例

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

SWIFT 4 非常简单！

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

Swift 4 检查子字符串的方法，包括必要的（或）框架导入：FoundationUIKit

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

除非（或）框架被导入，否则会给出编译器错误。FoundationUIKitstr.contains("Can")

---

这个答案是在反刍manojlds的答案，这是完全正确的。我不知道为什么这么多答案要费这么大的力气来重新创建的方法。FoundationString.contains(subString: String)

如果你想检查一个字符串中是否包含另一个子字符串，你也可以像这样检查它，

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 4 中的新语法，您可以

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

string 是你的字符串变量

Swift 5，不区分大小写：

if string.localizedLowercase.contains("swift".localizedLowercase){
    // your code here
}