Schneller Start Mit Methode?

Gibt es eine SwiftWith () -Methode oder ähnliches in Swift?

Ich versuche im Grunde zu überprüfen, ob eine bestimmte Zeichenfolge mit einer anderen Zeichenfolge beginnt. Ich möchte auch, dass die Groß- und Kleinschreibung nicht berücksichtigt wird.

Wie Sie vielleicht sehen können, versuche ich nur, eine einfache Suchfunktion durchzuführen, aber ich scheine kläglich daran zu scheitern.

Das möchte ich:

Wenn Sie "sa" eingeben, erhalten Sie Ergebnisse für "San Antonio", "Santa Fe" usw. Wenn Sie "SA" oder "Sa" oder sogar "sA" eingeben, wird auch "San Antonio" oder "Santa Fe" zurückgegeben.

Ich habe benutzt

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

vor iOS9 und es funktionierte gut. Nach dem Upgrade auf iOS9 funktionierte es jedoch nicht mehr und bei der Suche wird zwischen Groß- und Kleinschreibung unterschieden.

    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 ");
    }

verwenden hasPrefixstatt startsWith.

Beispiel:

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

Hier ist eine Swift-Erweiterungsimplementierung von StartsWith:

extension String {

  func startsWith(string: String) -> Bool {

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

    return range.startIndex == startIndex
  }

}

Anwendungsbeispiel:

var str = "Hello, playground"

let matches    = str.startsWith("hello") //true
let no_matches = str.startsWith("playground") //false

Um speziell auf die Groß- und Kleinschreibung zu achten, wird das Präfix nicht berücksichtigt:

in reinem Swift (meistens empfohlen)

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

oder:

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

Hinweis: Bei einem leeren Präfix werden ""beide Implementierungen zurückgegebentrue

mit Foundation range(of:options:)

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

Hinweis: Für ein leeres Präfix wird ""es zurückgegebenfalse

und hässlich mit einem regulären Ausdruck sein (ich habe es gesehen ...)

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
    }
}

Hinweis: Für ein leeres Präfix wird ""es zurückgegebenfalse

In func starts<PossiblePrefix>(with possiblePrefix: PossiblePrefix) -> Bool where PossiblePrefix : Sequence, String.Element == PossiblePrefix.ElementKürze wird 4 eingeführt.

Beispiel Verwendung:

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

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

Bearbeiten: aktualisiert für Swift 3.

Die Swift String-Klasse verfügt zwar über die Methode hasPrefix(), bei der zwischen Groß- und Kleinschreibung unterschieden wird . Wenn Sie jedoch eine Suche ohne Berücksichtigung der Groß- und Kleinschreibung wünschen, können Sie die NSString-Methode verwenden range(of:options:).

Hinweis: Standardmäßig sind die NSString-Methoden nicht verfügbar, wenn Sie import Foundationdies jedoch tun .

So:

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)");
}

Die Optionen können entweder .caseInsensitiveoder angegeben werden [.caseInsensitive]. Sie würden die zweite verwenden, wenn Sie zusätzliche Optionen verwenden möchten, z.

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

Dieser Ansatz hat auch den Vorteil, dass bei der Suche andere Optionen verwendet werden können, z. B. .diacriticInsensitiveSuchvorgänge. Das gleiche Ergebnis kann nicht einfach durch Verwendung . lowercased()der Zeichenfolgen erzielt werden .

Swift 3 Version:

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

In Swift 4 mit Erweiterungen

Meine Dehn-Beispiel enthält drei Funktionen: Check tun ein String beginnen mit einer Teilzeichen , machen einen String Ende zu einer Teilzeichen und machen Sie einen String enthält einen Substring.

Setzen Sie den Parameter isCaseSensitive auf false. Wenn Sie die Zeichen "A" oder "a" ignorieren möchten, setzen Sie ihn andernfalls auf "true".

Weitere Informationen zur Funktionsweise finden Sie in den Kommentaren im Code.

Code:

    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
            }
        }
    }

Beispiele zur Verwendung:

Zur Überprüfung beginnt der String mit "TEST":

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

Zur Überprüfung beginnt der String mit "test":

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

Zur Überprüfung endet der String mit "G123":

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

Zum Überprüfen endet der String mit "g123":

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

Zur Überprüfung enthält der String "RING12":

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

Zur Überprüfung enthält der String "ring12":

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