If my main array is ["Hello","Bye","Halo"], and I'm searching for "lo", it will filter the array only to ["Hello", "Halo"].
This is what I've tried:
let matchingTerms = filter(catalogNames) {
$0.rangeOfString(self.txtField.text!, options: .CaseInsensitiveSearch) != nil
}
It throws
Type of expression is ambiguous without more context
Any suggestions?
Use contains instead:
let arr = ["Hello","Bye","Halo"]
let filtered = arr.filter { $0.contains("lo") }
print(filtered)
Output
["Hello", "Halo"]
Thanks to @user3441734 for pointing out that functionality is of course only available when you import Foundation
lowercased() for better resultsIn Swift 3.0
let terms = ["Hello","Bye","Halo"]
var filterdTerms = [String]()
func filterContentForSearchText(searchText: String) {
filterdTerms = terms.filter { term in
return term.lowercased().contains(searchText.lowercased())
}
}
filterContentForSearchText(searchText: "Lo")
print(filterdTerms)
Output
["Hello", "Halo"]
Swift 3.1
let catalogNames = [ "Hats", "Coats", "Trousers" ]
let searchCatalogName = "Hats"
let filteredCatalogNames = catalogNames.filter { catalogName in
return catalogName.localizedCaseInsensitiveContains(searchCatalogName)
}
print(filteredCatalogNames)
my try...
let brands = ["Apple", "FB", "Google", "Microsoft", "Amazon"]
let b = brands.filter{(x) -> Bool in
(x.lowercased().range(of: "A".lowercased()) != nil)
}
print(b) //["Apple", "Amazon"]
with help of String extension you can use pure Swift solution (without import Foundation). I didn't check the speed, but it shouldn't be worse as the foundation equivalent.
extension String {
func contains(string: String)->Bool {
guard !self.isEmpty else {
return false
}
var s = self.characters.map{ $0 }
let c = string.characters.map{ $0 }
repeat {
if s.startsWith(c){
return true
} else {
s.removeFirst()
}
} while s.count > c.count - 1
return false
}
}
let arr = ["Hello","Bye","Halo"]
let filtered = arr.filter { $0.contains("lo") }
print(filtered) // ["Hello", "Halo"]
"a".contains("alphabet") // false
"alphabet".contains("") // true
You also need to compare to NSNotFound. The documentation for rangeOfString:options: says:
An NSRange structure giving the location and length in the receiver of the first occurrence of aString, modulo the options in mask. Returns {NSNotFound, 0} if aString is not found or is empty (@"").
import Foundation
let catalogNames = [ "Hats", "Coats", "Trousers" ]
let matchingTerms = catalogNames.filter {
$0.rangeOfString(self.txtField.text!, options: .CaseInsensitiveSearch).location != NSNotFound
}
Swift 5:
Considered below example. Filtering (case insensitive) out data from array 1 and populating 2nd array with that
let data = ["Apple", "Oranges", "Banana", "Grapes"]
var filteredData = [String]()
func filterText(_ text: String?) {
guard let text = text else {return}
filteredData.removeAll()
for element in data {
if element.lowercased().starts(with: text.lowercased()){
filteredData.append(element)
}
}
}
