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

小开

你可以按照你刚才提到的去做:

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

从文档中可以看出:

Swift的String类型无缝桥接到Foundation的NSString 类。如果您正在使用Cocoa中的Foundation框架或 Cocoa Touch，整个NSString API可以在任何情况下调用 String你创建的值，除了String特性描述在本章中。你也可以在任何API中使用String值

你需要import Foundation来桥接NSString方法，并使它们对Swift的String类可用。

小开

从文档中可以看出，在String对象上调用containsString()应该可以工作:

Swift的String类型无缝桥接到Foundation的NSString 类。如果您正在使用Cocoa中的Foundation框架或 Cocoa Touch，整个NSString API可以调用任何您所创建的字符串值，以及所描述的字符串特性在本章中。你也可以在任何API中使用String值

然而，事情似乎并不是这样的。

如果您尝试使用someString.containsString(anotherString)，您将得到一个编译时错误，声明'String' does not contain a member named 'containsString'。

所以，你剩下几个选项，其中一个是通过使用bridgeToObjectiveC()显式地将String桥接到Objective-C，其他两个涉及显式地使用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(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")
}

小开

这是我在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做同样的事情:

Swift 4 &斯威夫特5

在Swift 4中，字符串是Character值的集合，在Swift 2和3中不像这样，所以你可以使用更简洁的代码¹:

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

脚注

只要记住，在字符串上使用集合函数会有一些边界情况，这可能会给你意想不到的结果，例如在处理表情符号或其他字母群(如重音字母)时。

小开

< p >字符串。containsString只在10.10 Yosemite(可能还有iOS8)中可用。而且在10.9中将它连接到objecvec也会崩溃。你试图传递一个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

中可用

上面的String范围在10.9上工作得很好。我发现在10.9上开发Xcode beta2非常稳定。我不使用游乐场的命令行版本。我发现如果导入了合适的框架，自动补全功能是非常有用的。

小开

这只是对答案的补充。

你也可以使用以下方法进行本地不区分大小写的测试:

 - (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苹果公司
. cn
OS X 10.10发布说明可可基础框架

NSString现在有以下两个方便的方法:

# EYZ0

# EYZ0

小开

在这里的所有答案中，我认为它们要么不工作，要么有点hack(转换回NSString)。这个问题的正确答案很可能随着不同的beta版本而改变。

以下是我使用的方法:

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

”!= nil”成为Beta 5的要求。

小开

扩展的方法

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

您可以为String编写扩展contains:和containsIgnoringCase

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中string的搜索和比较功能

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

小开

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

< em > < / em >输出

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

小开

在这里你可以看到我的智能搜索扩展从字符串，让你对字符串进行搜索，看看它是否包含，或者可能过滤一个基于搜索文本的集合。

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

小开

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

小开

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

除非导入Foundation(或UIKit)框架，否则str.contains("Can")将给出编译器错误。

这个答案是完全正确的manojlds的回答。我不知道为什么这么多答案要经历这么多麻烦来重新创建Foundation的String.contains(subString: String)方法。

小开

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

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

希望这对你有用。

小开

有了swift 4的新语法，你就可以

# EYZ0

String是你的字符串变量

小开

Swift 5，不区分大小写:

如果string.localizedLowercase.contains(“swift" .localizedLowercase) {