ios - saving - the swift programming language swift 3




Swift startsWith método? (5)

Editar: atualizado para o Swift 3.

A classe Swift String tem o método hasPrefix() , que é sensível a maiúsculas e minúsculas, mas se você quiser uma pesquisa que não hasPrefix() maiúsculas de minúsculas, poderá usar o range(of:options:) método NSString range(of:options:) .

Nota: Por padrão, os métodos NSString não estão disponíveis, mas se você import Foundation eles estarão.

Assim:

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

As opções podem ser fornecidas como .caseInsensitive ou [.caseInsensitive] . Você usaria o segundo se quisesse usar opções adicionais, como:

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

Essa abordagem também tem a vantagem de poder usar outras opções com a pesquisa, como .diacriticInsensitive searches. O mesmo resultado não pode ser alcançado simplesmente usando . lowercased() . lowercased() nas cordas.

Existe algo como um método startsWith () ou algo similar no Swift?

Eu estou basicamente tentando verificar se uma determinada string começa com outra string. Eu também quero que seja insensível a maiúsculas e minúsculas.

Como você pode saber, estou apenas tentando fazer um recurso de pesquisa simples, mas parece que estou falhando miseravelmente nisso.

Isso é o que eu gostaria:

digitando "sa" deve me dar resultados para "San Antonio", "Santa Fe", etc digitando "SA" ou "Sa" ou mesmo "sA" também deve retornar "San Antonio" ou "Santa Fe".

Eu estava usando

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

antes do iOS9 e estava funcionando muito bem. Após a atualização para o iOS9, no entanto, ele parou de funcionar e agora as pesquisas diferenciam maiúsculas de minúsculas.

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

Em swift 4 func starts<PossiblePrefix>(with possiblePrefix: PossiblePrefix) -> Bool where PossiblePrefix : Sequence, String.Element == PossiblePrefix.Element será introduzido.

Exemplo de uso:

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

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

Versão Swift 3:

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

aqui está uma implementação da extensão Swift de startsWith:

extension String {

  func startsWith(string: String) -> Bool {

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

    return range.startIndex == startIndex
  }

}

Exemplo de uso:

var str = "Hello, playground"

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

No Swift 4 com extensões

Meu exemplo de extensão contém 3 funções: faça uma String começar com um subString, faça um String para um subString e faça um String contém um subString.

Defina o parâmetro isCaseSensitive como false, se você quiser ignorar os caracteres "A" ou "a", caso contrário, defina-o como true.

Veja os comentários no código para mais informações de como funciona.

Código:

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

Exemplos como usar:

Para verificar, o String começa com "TEST":

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

Para verificar, o String começa com "test":

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

Para verificar, faça o final da cadeia com "G123":

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

Para verificar, faça o final da string com "g123":

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

Para verificar se o String contém "RING12":

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

Para verificar, o String contém "ring12":

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




swift