Reputation: 31091
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?
Upvotes: 660
Views: 616086
Reputation: 119917
There is a native function called: localizedCaseInsensitiveContains(_ other:)
. So it would be like:
"Some string". localizedCaseInsensitiveContains("some")
Based on the documentations, the above function uses range
function under the hood. So you can go further and remake it with fine control over the options like this:
"Some string".contains("some", options: .caseInsensitive) // Or some locale
It would be as easy as extending the StringProtocol
in a way that takes required parameters like:
import Foundation
extension StringProtocol {
public func contains<T>(_ other: T, options: CompareOptions, locale: Locale? = nil
) -> Bool where T : StringProtocol {
range(of: other, options: options, locale: locale) != nil
}
}
💡 Note that we didn't assign a default value to the options
parameter so that the original contains
overload can be reached undisrupted.
Upvotes: 0
Reputation: 99
When you have optionals and code completion suggests testing for '!= nil', you must keep in mind true and false are both not nil. In this scenario it's best to do something like this:
if let bool = data?.contains("string") {
boolVariable = bool
}
Upvotes: -1
Reputation: 199
Swift 5, case insensitive:
if string.localizedLowercase.contains("swift".localizedLowercase){
// your code here
}
Upvotes: 8
Reputation: 3138
SWIFT 4 is very easy!!
if (yourString.contains("anyThing")) {
print("Exist")
}
Upvotes: 2
Reputation: 91
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.
Upvotes: 2
Reputation: 17460
You can do exactly the same call with Swift:
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")
}
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")
}
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
Upvotes: 1280
Reputation: 137
With and new syntax in swift 4 you can just
string.contains("Swift 4 is the best")
string is your string variable
Upvotes: 3
Reputation: 301417
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’sNSString
class. If you are working with the Foundation framework in Cocoa or Cocoa Touch, the entireNSString
API is available to call on anyString
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.
Upvotes: 9
Reputation: 6024
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.
Upvotes: 3
Reputation: 11577
Use
func contains(_ str: String) -> Bool
let string = "hello Swift"
let containsSwift = string.contains("Swift")
print(containsSwift) // prints true
Upvotes: 23
Reputation: 77910
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+
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
}
}
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
Upvotes: 203
Reputation: 8674
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
Upvotes: 31
Reputation:
Check if it contains 'Hello'
let s = "Hello World"
if s.rangeOfString("Hello") != nil {
print("Yes it contains 'Hello'")
}
Upvotes: 2
Reputation: 20786
> 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
Upvotes: 16
Reputation: 556
In Swift 3
if((a.range(of: b!, options: String.CompareOptions.caseInsensitive, range: nil, locale: nil)) != nil){
print("Done")
}
Upvotes: 5
Reputation: 37349
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
}
}
MyString.contains("Niels Bohr", substring: "Bohr") // true
Case and diacritic insensitive function available since iOS 9.
if #available(iOS 9.0, *) {
"Für Elise".localizedStandardContains("fur") // true
}
Upvotes: 41
Reputation: 353
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
Upvotes: 4
Reputation: 42479
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
Upvotes: 3
Reputation: 13181
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
}()
Upvotes: 0
Reputation: 6932
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;
Upvotes: 10
Reputation: 13621
Here you are:
let s = "hello Swift"
if let textRange = s.rangeOfString("Swift") {
NSLog("exists")
}
Upvotes: 6
Reputation: 366
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:
count(string)
;contains(string, substring)
;startsWith(string, substring)
Upvotes: 5
Reputation: 110
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")}
Upvotes: 15
Reputation: 551
// 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.
}
Upvotes: 1
Reputation: 56372
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")
}
Upvotes: 51
Reputation: 31486
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
Upvotes: 0
Reputation: 2980
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.
Upvotes: 10
Reputation: 111
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.
Upvotes: 3
Reputation: 107
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 :)
Upvotes: 9