빠른 출발방법으로?

빠른 출발방법으로?

스위프트에 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 ");
    }

…을 대신하여 쓰다

예:

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

대/소문자를 구분하지 않는 접두사 일치에 대해 구체적으로 답변하려면:

순수한 스위프트 (대부분의 경우 권장)

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

기초 사용

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

여기 시작의 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

편집: Swift 3용으로 업데이트되었습니다.

SwiftString 클래스에는 대소문자를 구분하는 메서드가 있습니다.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()현악기로

인스위프트 4func 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"

확장 기능이 있는 Swift 4에서

내 확장 예제에는 subString으로 String 시작하기, subString 끝으로 String 종료하기, subString에 subString 포함하기 등 세 가지 기능이 있습니다.

isCaseSensitive-매개 변수를 false로 설정하고, 무시하려면 문자 "A" 또는 "a"를 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"로 String을 시작합니다.

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

확인하려면 "test"로 String을 시작합니다.

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

확인을 위해 "G123"으로 String end를 수행합니다.

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

확인을 위해 "g123"으로 String end를 수행합니다.

    "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

Swift 3 버전:

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

언급URL : https://stackoverflow.com/questions/32664543/swift-startswith-method