迅速从方法开始？

在 Swift 中有 StartsWith ()方法或类似的东西吗？

我基本上是在检查某个字符串是否以另一个字符串开头。我也希望它不区分大小写。

正如你可能能够告诉，我只是试图做一个简单的搜索功能，但我似乎在这方面惨败。

这就是我想要的:

输入“ sa”应该会得到“ San Antonio”、“ Santa Fe”等等的结果。 输入“ SA”或“ SA”甚至“ sA”也应该返回“ San Antonio”或“ Santa Fe”。

我在吸毒

self.rangeOfString(find, options: NSStringCompareOptions.CaseInsensitiveSearch) != nil

在 iOS9之前，它工作得很好。然而，升级到 iOS9之后，它就停止工作了，现在的搜索是区分大小写的。

    var city = "San Antonio"
var searchString = "san "
if(city.rangeOfString(searchString, options: NSStringCompareOptions.CaseInsensitiveSearch) != nil){
print("San Antonio starts with san ");
}


var myString = "Just a string with san within it"


if(myString.rangeOfString(searchString, options: NSStringCompareOptions.CaseInsensitiveSearch) != nil){
print("I don't want this string to print bc myString does not start with san ");
}
54851 次浏览
小开

编辑: 更新为 Swift 3。

Swift String 类具有区分大小写的方法 hasPrefix()，但是如果您希望进行区分大小写的搜索，则可以使用 NSString 方法 range(of:options:)。

注意: 默认情况下，NSString 方法是 没有可用的，但是如果是 import Foundation，它们是。

所以:

import Foundation
var city = "San Antonio"
var searchString = "san "
let range = city.range(of: searchString, options:.caseInsensitive)
if let range = range {
print("San Antonio starts with san at \(range.startIndex)");
}

这些选项可以作为 .caseInsensitive或 [.caseInsensitive]给出。如果希望使用其他选项，可以使用第二个选项，例如:

let range = city.range(of: searchString, options:[.caseInsensitive, .backwards])

这种方法还有一个优点，即能够在搜索中使用其他选项，例如 .diacriticInsensitive搜索。对字符串使用 . lowercased()不能简单地获得相同的结果。

小开

以下是 StartsWith 的 Swift 扩展实现:

extension String {


func startsWith(string: String) -> Bool {


guard let range = rangeOfString(string, options:[.AnchoredSearch, .CaseInsensitiveSearch]) else {
return false
}


return range.startIndex == startIndex
}


}

示例用法:

var str = "Hello, playground"


let matches    = str.startsWith("hello") //true
let no_matches = str.startsWith("playground") //false
小开
最佳答案

使用 hasPrefix代替 startsWith。

例如:

"hello dolly".hasPrefix("hello")  // This will return true
"hello dolly".hasPrefix("abc")    // This will return false
小开

Swift 3版本:

func startsWith(string: String) -> Bool {
guard let range = range(of: string, options:[.caseInsensitive]) else {
return false
}
return range.lowerBound == startIndex
}
小开

为了回答具体的案例 麻木不仁前缀匹配:

在纯斯威夫特(推荐大部分时间)

extension String {
func caseInsensitiveHasPrefix(_ prefix: String) -> Bool {
return lowercased().hasPrefix(prefix.lowercased())
}
}

或:

extension String {
func caseInsensitiveHasPrefix(_ prefix: String) -> Bool {
return lowercased().starts(with: prefix.lowercased())
}
}

注意: 对于一个空前缀 ""，两个实现都将返回 true

使用基金会 range(of:options:)

extension String {
func caseInsensitiveHasPrefix(_ prefix: String) -> Bool {
return range(of: prefix, options: [.anchored, .caseInsensitive]) != nil
}
}

注意: 对于一个空前缀 ""，它将返回 false

和丑陋的正则表达式(我见过... ...)

extension String {
func caseInsensitiveHasPrefix(_ prefix: String) -> Bool {
guard let expression = try? NSRegularExpression(pattern: "\(prefix)", options: [.caseInsensitive, .ignoreMetacharacters]) else {
return false
}
return expression.firstMatch(in: self, options: .anchored, range: NSRange(location: 0, length: characters.count)) != nil
}
}

注意: 对于一个空前缀 ""，它将返回 false

小开

在快速4 func starts<PossiblePrefix>(with possiblePrefix: PossiblePrefix) -> Bool where PossiblePrefix : Sequence, String.Element == PossiblePrefix.Element将被引入。

示例使用:

let a = 1...3
let b = 1...10


print(b.starts(with: a))
// Prints "true"
小开

在斯威夫特4带有扩展

我的扩展示例包含3个函数: check do a String 开始 with a subString，do a String 结束 to a subString 和 do a String 包含 a subString。

如果您想忽略字符“ A”或“ a”，则将 isCaseSense 参数设置为 false，否则将其设置为 true。

有关其工作原理的更多信息，请参见代码中的注释。

密码:

    import Foundation


extension String {
// Returns true if the String starts with a substring matching to the prefix-parameter.
// If isCaseSensitive-parameter is true, the function returns false,
// if you search "sA" from "San Antonio", but if the isCaseSensitive-parameter is false,
// the function returns true, if you search "sA" from "San Antonio"


func hasPrefixCheck(prefix: String, isCaseSensitive: Bool) -> Bool {


if isCaseSensitive == true {
return self.hasPrefix(prefix)
} else {
var thePrefix: String = prefix, theString: String = self


while thePrefix.count != 0 {
if theString.count == 0 { return false }
if theString.lowercased().first != thePrefix.lowercased().first { return false }
theString = String(theString.dropFirst())
thePrefix = String(thePrefix.dropFirst())
}; return true
}
}
// Returns true if the String ends with a substring matching to the prefix-parameter.
// If isCaseSensitive-parameter is true, the function returns false,
// if you search "Nio" from "San Antonio", but if the isCaseSensitive-parameter is false,
// the function returns true, if you search "Nio" from "San Antonio"
func hasSuffixCheck(suffix: String, isCaseSensitive: Bool) -> Bool {


if isCaseSensitive == true {
return self.hasSuffix(suffix)
} else {
var theSuffix: String = suffix, theString: String = self


while theSuffix.count != 0 {
if theString.count == 0 { return false }
if theString.lowercased().last != theSuffix.lowercased().last { return false }
theString = String(theString.dropLast())
theSuffix = String(theSuffix.dropLast())
}; return true
}
}
// Returns true if the String contains a substring matching to the prefix-parameter.
// If isCaseSensitive-parameter is true, the function returns false,
// if you search "aN" from "San Antonio", but if the isCaseSensitive-parameter is false,
// the function returns true, if you search "aN" from "San Antonio"
func containsSubString(theSubString: String, isCaseSensitive: Bool) -> Bool {


if isCaseSensitive == true {
return self.range(of: theSubString) != nil
} else {
return self.range(of: theSubString, options: .caseInsensitive) != nil
}
}
}

示例如何使用:

为了检查字符串是否以“ TEST”开头:

    "testString123".hasPrefixCheck(prefix: "TEST", isCaseSensitive: true) // Returns false
"testString123".hasPrefixCheck(prefix: "TEST", isCaseSensitive: false) // Returns true

为了检查字符串是否以“ test”开头:

    "testString123".hasPrefixCheck(prefix: "test", isCaseSensitive: true) // Returns true
"testString123".hasPrefixCheck(prefix: "test", isCaseSensitive: false) // Returns true

为了检查字符串是否以“ G123”结尾:

    "testString123".hasSuffixCheck(suffix: "G123", isCaseSensitive: true) // Returns false
"testString123".hasSuffixCheck(suffix: "G123", isCaseSensitive: false) // Returns true

为了检查字符串是否以“ g123”结尾:

    "testString123".hasSuffixCheck(suffix: "g123", isCaseSensitive: true) // Returns true
"testString123".hasSuffixCheck(suffix: "g123", isCaseSensitive: false) // Returns true

为了检查字符串是否包含“ RING12”:

    "testString123".containsSubString(theSubString: "RING12", isCaseSensitive: true) // Returns false
"testString123".containsSubString(theSubString: "RING12", isCaseSensitive: false) // Returns true

为了检查字符串是否包含“ ring12”:

    "testString123".containsSubString(theSubString: "ring12", isCaseSensitive: true) // Returns true
"testString123".containsSubString(theSubString: "ring12", isCaseSensitive: false) // Returns true

提交答案