How do I check if a string contains another string in Swift?
SwiftStringNsstringSubstringSwift Problem Overview
In Objective-C the code to check for a substring in an NSString is:
NSString *string = @"hello Swift";
NSRange textRange =[string rangeOfString:@"Swift"];
if(textRange.location != NSNotFound)
{
NSLog(@"exists");
}
But how do I do this in Swift?
Swift Solutions
Solution 1 - Swift
You can do exactly the same call with Swift:
Swift 4 & Swift 5
In Swift 4 String is a collection of Character values, it wasn't like this in Swift 2 and 3, so you can use this more concise code1:
let string = "hello Swift"
if string.contains("Swift") {
print("exists")
}
###Swift 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")
}
###Older Swift
var string = "hello Swift"
if string.rangeOfString("Swift") != nil{
println("exists")
}
// alternative: not case sensitive
if string.lowercaseString.rangeOfString("swift") != nil {
println("exists")
}
I hope this is a helpful solution since some people, including me, encountered some strange problems by calling containsString().1
PS. Don't forget to import Foundation
Footnotes
- Just remember that using collection functions on Strings has some edge cases which can give you unexpected results, e. g. when dealing with emojis or other grapheme clusters like accented letters.
Solution 2 - Swift
Extension way
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
Generally Swift 4 has contains method however it available from iOS 8.0+
Swift 3.1
You can write extension contains: and containsIgnoringCase for 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
}
}
Older Swift version
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
}
}
Example:
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
Solution 3 - Swift
From the docs, it seems that calling containsString() on a String should work:
> Swift’s String type is bridged seamlessly to Foundation’s NSString > class. If you are working with the Foundation framework in Cocoa or > Cocoa Touch, the entire NSString API is available to call on any > String value you create, in addition to the String features described > in this chapter. You can also use a String value with any API that > requires an NSString instance.
However, it doesn't seem to work that way.
If you try to use someString.containsString(anotherString), you will get a compile time error that states 'String' does not contain a member named 'containsString'.
So, you're left with a few options, one of which is to explicitly bridge your String to Objective-C by using bridgeToObjectiveC() other two involve explicitly using an NSString and the final one involves casting the String to an NSString
By bridging, you'd get:
var string = "hello Swift"
if string.bridgeToObjectiveC().containsString("Swift") {
println("YES")
}
By explicitly typing the string as an NSString, you'd get:
var string: NSString = "hello Swift"
if string.containsString("Swift") {
println("YES")
}
If you have an existing String, you can initialize an NSString from it by using NSString(string:):
var string = "hello Swift"
if NSString(string: string).containsString("Swift") {
println("YES")
}
And finally, you can cast an existing String to an NSString as below
var string = "hello Swift"
if (string as NSString).containsString("Swift") {
println("YES")
}
Solution 4 - Swift
Another one. Supports case and diacritic options.
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
}
}
Usage
MyString.contains("Niels Bohr", substring: "Bohr") // true
iOS 9+
Case and diacritic insensitive function available since iOS 9.
if #available(iOS 9.0, *) {
"Für Elise".localizedStandardContains("fur") // true
}
Solution 5 - Swift
As of Xcode 7.1 and Swift 2.1 containsString() is working fine for me.
let string = "hello swift"
if string.containsString("swift") {
print("found swift")
}
Swift 4:
let string = "hello swift"
if string.contains("swift") {
print("found swift")
}
And a case insensitive Swift 4 example:
let string = "Hello Swift"
if string.lowercased().contains("swift") {
print("found swift")
}
Or using a case insensitive 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
Solution 6 - Swift
In Swift 4.2
Use
func contains(_ str: String) -> Bool
Example
let string = "hello Swift"
let containsSwift = string.contains("Swift")
print(containsSwift) // prints true
Solution 7 - Swift
> IN SWIFT 3.0
let str = "Hello Swift"
if str.lowercased().contains("Swift".lowercased()) {
print("String Contains Another String")
} else {
print("Not Exists")
}
Output
String Contains Another String
Solution 8 - Swift
You can do this very easily in Swift using the code:
let string = "hello Swift";
let subString = (string as NSString).containsString("Swift")
if(subString){println("Exist")}
Solution 9 - Swift
Just an addendum to the answers here.
You can also do a local case insensitive test using:
- (BOOL)localizedCaseInsensitiveContainsString:(NSString *)aString
Example:
import Foundation
var string: NSString = "hello Swift"
if string.localizedCaseInsensitiveContainsString("Hello") {
println("TRUE")
}
UPDATE
This is part of the Foundation Framework for iOS & Mac OS X 10.10.x and was part of 10.10 at Time of my original Posting.
> Document Generated: 2014-06-05 12:26:27 -0700 OS X Release Notes
> Copyright © 2014 Apple Inc. All Rights Reserved.
>
> OS X 10.10 Release Notes Cocoa Foundation Framework
>
> NSString now has the following two convenience methods:
>
> - (BOOL)containsString:(NSString *)str;
>
> - (BOOL)localizedCaseInsensitiveContainsString:(NSString *)str;
Solution 10 - Swift
Of all of the answers here, I think they either don't work, or they're a bit of a hack (casting back to NSString). It's very likely that the correct answer to this has changed with the different beta releases.
Here is what I use:
let string: String = "hello Swift"
if string.rangeOfString("Swift") != nil
{
println("exists")
}
The "!= nil" became required with Beta 5.
Solution 11 - Swift
Here is my first stab at this in the swift playground. I extend String by providing two new functions (contains and containsIgnoreCase)
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
}
}
Use it like this
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
I'd welcome any feedback :)
Solution 12 - Swift
Here you are:
let s = "hello Swift"
if let textRange = s.rangeOfString("Swift") {
NSLog("exists")
}
Solution 13 - Swift
You don't need to write any custom code for this. Starting from the 1.2 version Swift has already had all the methods you need:
- getting string length:
count(string); - checking if string contains substring:
contains(string, substring); - checking if string starts with substring:
startsWith(string, substring) - and etc.
Solution 14 - Swift
In Swift 3
if((a.range(of: b!, options: String.CompareOptions.caseInsensitive, range: nil, locale: nil)) != nil){
print("Done")
}
Solution 15 - Swift
You can just do what you have mentioned:
import Foundation
...
string.contains("Swift");
From the docs:
> Swift’s String type is bridged seamlessly to Foundation’s NSString
> class. If you are working with the Foundation framework in Cocoa or
> Cocoa Touch, the entire NSString API is available to call on any
> String value you create, in addition to the String features described
> in this chapter. You can also use a String value with any API that
> requires an NSString instance.
You need to import Foundation to bridge the NSString methods and make them available to Swift's String class.
Solution 16 - Swift
Here you go! Ready for Xcode 8 and 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
Solution 17 - Swift
string.containsString is only available in 10.10 Yosemite (and probably iOS8). Also bridging it to ObjectiveC crashes in 10.9. You're trying to pass a NSString to NSCFString. I don't know the difference, but I can say 10.9 barfs when it executes this code in a OS X 10.9 app.
Here are the differences in Swift with 10.9 and 10.10: https://developer.apple.com/library/prerelease/mac/documentation/General/Reference/APIDiffsMacOSX10_10SeedDiff/index.html containsString is only available in 10.10
Range of String above works great on 10.9. I am finding developing on 10.9 is super stable with Xcode beta2. I don't use playgrounds through or the command line version of playgrounds. I'm finding if the proper frameworks are imported the autocomplete is very helpful.
Solution 18 - Swift
Xcode 8/Swift 3 version:
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")
}
You can also use contains:
string.contains("swift") // false
string.contains("Swift") // true
Solution 19 - Swift
Swift 4 way to check for substrings, including the necessary Foundation (or UIKit) framework import:
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
Unless Foundation (or UIKit) framework is imported, str.contains("Can") will give a compiler error.
This answer is regurgitating manojlds's answer, which is completely correct. I have no idea why so many answers go through so much trouble to recreate Foundation's String.contains(subString: String) method.
Solution 20 - Swift
With and new syntax in swift 4 you can just
string.contains("Swift 4 is the best")
string is your string variable
Solution 21 - Swift
Check if it contains 'Hello'
let s = "Hello World"
if s.rangeOfString("Hello") != nil {
print("Yes it contains 'Hello'")
}
Solution 22 - Swift
// 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.
}
Solution 23 - Swift
Swift 3: Here you can see my smart search extension fro string that let you make a search on string for seeing if it contains, or maybe to filter a collection based on a search text.
Solution 24 - Swift
If you want to check that one String contains another Sub-String within it or not you can check it like this too,
var name = String()
name = "John has two apples."
Now, in this particular string if you want to know if it contains fruit name 'apple' or not you can do,
if name.contains("apple") {
print("Yes , it contains fruit name")
} else {
print("it does not contain any fruit name")
}
Hope this works for you.
Solution 25 - Swift
In iOS 8 and newer, you can use these two NSString methods:
@availability(iOS, introduced=8.0)
func containsString(aString: String) -> Bool
@availability(iOS, introduced=8.0)
func localizedCaseInsensitiveContainsString(aString: String) -> Bool
Solution 26 - Swift
I've found a couple of interesting use cases. These variants make use of the rangeOfString method and I include the equality example to show how one might best use the search and comparison features of Strings in Swift 2.0
//In viewDidLoad() I assign the current object description (A Swift String) to self.loadedObjectDescription
self.loadedObjectDescription = self.myObject!.description
> Later after I've made changes to self.myObject, I can refer to the > following string comparison routines (setup as lazy variables that > return a Bool). This allows one to check the state at any time.
lazy var objectHasChanges : Bool = {
guard self.myObject != nil else { return false }
return !(self.loadedObjectDescription == self.myObject!.description)
}()
> A variant of this happens when sometimes I need to analyze a missing > property on that object. A string search allows me to find a > particular substring being set to nil (the default when an object is created).
lazy var isMissingProperty : Bool = {
guard self.myObject != nil else { return true }
let emptyPropertyValue = "myProperty = nil"
return (self.myObject!.description.rangeOfString(emptyPropertyValue) != nil) ? true : false
}()
Solution 27 - Swift
Swift 5, case insensitive:
if string.localizedLowercase.contains("swift".localizedLowercase){
Solution 28 - Swift
SWIFT 4 is very easy!!
if (yourString.contains("anyThing")) {
print("Exist")
}