Czy istnieje sposób sprawdzenia ciągów znaków dla języka Swift nil
i ""
w nim? W Railsach mogę blank()
sprawdzić.
Obecnie to mam, ale wydaje się przesadą:
if stringA? != nil {
if !stringA!.isEmpty {
...blah blah
}
}
Odpowiedzi:
Jeśli masz do czynienia z opcjonalnymi ciągami znaków, działa to:
(string ?? "").isEmpty
??
Operator zwraca nil koalescencyjny z lewej strony, jeżeli jest to non-zero, w przeciwnym wypadku zwraca prawą stronę.Możesz również użyć tego w ten sposób, aby zwrócić wartość domyślną:
(string ?? "").isEmpty ? "Default" : string!
źródło
Być może możesz użyć klauzuli if-let-where:
Swift 3:
if let string = string, !string.isEmpty { /* string is not blank */ }
Swift 2:
if let string = string where !string.isEmpty { /* string is not blank */ }
źródło
fatal error: unexpectedly found nil while unwrapping an Optional value
ale moja stałastring
ma dane łańcuchowe.if let string = string, !string.isEmpty { /* string is not blank */ }
guard let
jest alternatywą, jeśli chcesz zakończyć przepływ sterowania poniżej instrukcji. Jednak nic nie jest rozpakowywane w klauzuli gdzie tutaj (! Jest logiczną negacją)Jeśli używasz Swift 2, oto przykład, który wymyślił mój kolega, który dodaje właściwość isNilOrEmpty do opcjonalnych ciągów znaków:
protocol OptionalString {} extension String: OptionalString {} extension Optional where Wrapped: OptionalString { var isNilOrEmpty: Bool { return ((self as? String) ?? "").isEmpty } }
Następnie możesz użyć isNilOrEmpty na samym opcjonalnym ciągu
func testNilOrEmpty() { let nilString:String? = nil XCTAssertTrue(nilString.isNilOrEmpty) let emptyString:String? = "" XCTAssertTrue(emptyString.isNilOrEmpty) let someText:String? = "lorem" XCTAssertFalse(someText.isNilOrEmpty) }
źródło
where Wrapped:
musi określać protokół, a nie typ.isNilOrEmpty
nahasValue
(lub coś takiego) i odwrócić logikęKorzystanie z
guard
instrukcjiUżywałem Swift przez jakiś czas, zanim dowiedziałem się o
guard
oświadczeniu. Teraz jestem wielkim fanem. Jest używany podobnie doif
instrukcji, ale umożliwia wczesny powrót i ogólnie zapewnia znacznie czystszy kod.Aby użyć guard podczas sprawdzania, czy łańcuch nie jest zerowy ani pusty, możesz wykonać następujące czynności:
let myOptionalString: String? = nil guard let myString = myOptionalString, !myString.isEmpty else { print("String is nil or empty.") return // or break, continue, throw } /// myString is neither nil nor empty (if this point is reached) print(myString)
Spowoduje to rozpakowanie opcjonalnego ciągu i sprawdzenie, czy nie jest on jednocześnie pusty. Jeśli jest nil (lub pusty), natychmiast wracasz z funkcji (lub pętli) i wszystko po niej jest ignorowane. Ale jeśli instrukcja guard przejdzie pomyślnie, możesz bezpiecznie użyć rozpakowanego ciągu.
Zobacz też
źródło
nil
lub pusty, nie chciałoby się dzwonićprint(myString)
. Jeśli potrzebujesz kontynuować wykonywanie po anil
lub pustym miejscuString
, użyjif let
zamiastguard
.Dzięki Swift 5 możesz zaimplementować
Optional
rozszerzenieString
typu z właściwością logiczną, która zwraca, jeśli opcjonalny ciąg nie ma wartości lub jest pusty:extension Optional where Wrapped == String { var isNilOrEmpty: Bool { return self?.isEmpty ?? true } }
Jednak
String
implementujeisEmpty
właściwość zgodnie z protokołemCollection
. Dlatego możemy zastąpić ogólne ograniczenie poprzednim kodzie'S (Wrapped == String
) z szerszym jeden (Wrapped: Collection
), dzięki czemuArray
,Dictionary
aSet
także korzystać z nowegoisNilOrEmpty
właściwość:extension Optional where Wrapped: Collection { var isNilOrEmpty: Bool { return self?.isEmpty ?? true } }
Użycie z
String
s:let optionalString: String? = nil print(optionalString.isNilOrEmpty) // prints: true
let optionalString: String? = "" print(optionalString.isNilOrEmpty) // prints: true
let optionalString: String? = "Hello" print(optionalString.isNilOrEmpty) // prints: false
Użycie z
Array
s:let optionalArray: Array<Int>? = nil print(optionalArray.isNilOrEmpty) // prints: true
let optionalArray: Array<Int>? = [] print(optionalArray.isNilOrEmpty) // prints: true
let optionalArray: Array<Int>? = [10, 22, 3] print(optionalArray.isNilOrEmpty) // prints: false
Źródła:
źródło
isNilOrEmpty
na,isEmptyOrNil
aby pasowała do prefiksu, aby można go było łatwo znaleźć za pomocą tego samego wzorca dla autouzupełniania. Zauważyłem, że to rozszerzenie jest bardziej popularne od kolegów, z którymi pracuję, tylko od tego, jak znaleźli to w ten sposób.var str: String? = nil if str?.isEmpty ?? true { print("str is nil or empty") } str = "" if str?.isEmpty ?? true { print("str is nil or empty") }
źródło
Wiem, że istnieje wiele odpowiedzi na to pytanie, ale żadna z nich nie wydaje się być tak wygodna (moim zdaniem) do walidacji
UITextField
danych, co jest jednym z najczęstszych przypadków korzystania z nich:extension Optional where Wrapped == String { var isNilOrEmpty: Bool { return self?.trimmingCharacters(in: .whitespaces).isEmpty ?? true } }
Możesz po prostu użyć
Możesz również pominąć,
.trimmingCharacters(in:.whitespaces)
jeśli nie traktujesz białych znaków jako pustego ciągu lub użyć go do bardziej złożonych testów wejściowych, takich jakvar isValidInput: Bool { return !isNilOrEmpty && self!.trimmingCharacters(in: .whitespaces).characters.count >= MIN_CHARS }
źródło
Chciałbym polecić.
if stringA.map(isEmpty) == false { println("blah blah") }
map
stosuje argument funkcji, jeśli opcjonalny jest.Some
.Przechwytywanie placu zabaw pokazuje również inną możliwość z nowym Swift 1.2, jeśli pozwolisz na opcjonalne wiązanie.
źródło
Jeśli chcesz uzyskać dostęp do ciągu jako nieobowiązkowego, powinieneś użyć odpowiedzi Ryana , ale jeśli zależy ci tylko na braku pustości ciągu, moim preferowanym skrótem jest to
if stringA?.isEmpty == false { ...blah blah }
Ponieważ
==
działa dobrze z opcjonalnymi wartościami logicznymi, myślę, że pozostawia to kod czytelny bez przesłania pierwotnego zamiaru.Jeśli chcesz sprawdzić coś odwrotnego: jeśli ciąg to
nil
lub""
, wolę wyraźnie sprawdzić oba przypadki, aby pokazać prawidłową intencję:if stringA == nil || stringA?.isEmpty == true { ...blah blah }
źródło
SWIFT 3
extension Optional where Wrapped == String { /// Checks to see whether the optional string is nil or empty ("") public var isNilOrEmpty: Bool { if let text = self, !text.isEmpty { return false } return true } }
Użyj w ten sposób na opcjonalnym ciągu:
if myString.isNilOrEmpty { print("Crap, how'd this happen?") }
źródło
Swift 3 Najlepszym sposobem sprawdzenia pustego sznurka
if !string.isEmpty{ // do stuff }
źródło
Możesz stworzyć własną funkcję niestandardową, jeśli spodziewasz się dużo pracy.
func isBlank (optionalString :String?) -> Bool { if let string = optionalString { return string.isEmpty } else { return true } } var optionalString :String? = nil if isBlank(optionalString) { println("here") } else { println("there") }
źródło
Rozwiązanie Swift 3 Użyj opcjonalnej nieopakowanej wartości i porównaj z wartością logiczną.
if (string?.isempty == true) { // Perform action }
źródło
Korzystanie z isEmpty
"Hello".isEmpty // false "".isEmpty // true
Korzystanie z allSatisfy
extension String { var isBlank: Bool { return allSatisfy({ $0.isWhitespace }) } } "Hello".isBlank // false "".isBlank // true
Korzystanie z opcjonalnego ciągu znaków
extension Optional where Wrapped == String { var isBlank: Bool { return self?.isBlank ?? true } } var title: String? = nil title.isBlank // true title = "" title.isBlank // true
Źródła: https://useyourloaf.com/blog/empty-strings-in-swift/
źródło
Jest to ogólne rozwiązanie dla wszystkich typów zgodnych z
Collection
protokołem, które obejmujeString
:extension Optional where Wrapped: Collection { var isNilOrEmpty: Bool { self?.isEmpty ?? true } }
źródło
Utwórz rozszerzenie klasy String:
extension String { // returns false if passed string is nil or empty static func isNilOrEmpty(_ string:String?) -> Bool { if string == nil { return true } return string!.isEmpty } }// extension: String
Zwróć uwagę, że zwróci to wartość TRUE, jeśli ciąg zawiera jeden lub więcej odstępów. Aby traktować pusty ciąg jako „pusty”, użyj ...
return string!.trimmingCharacters(in: CharacterSet.whitespaces).isEmpty
... zamiast. To wymaga Fundacji.
Użyj go w ten sposób ...
if String.isNilOrEmpty("hello world") == true { print("it's a string!") }
źródło
Swift 3 Działa to dobrze, aby sprawdzić, czy łańcuch jest naprawdę pusty. Ponieważ isEmpty zwraca wartość true, gdy występuje spacja.
extension String { func isEmptyAndContainsNoWhitespace() -> Bool { guard self.isEmpty, self.trimmingCharacters(in: .whitespaces).isEmpty else { return false } return true } }
Przykłady:
let myString = "My String" myString.isEmptyAndContainsNoWhitespace() // returns false let myString = "" myString.isEmptyAndContainsNoWhitespace() // returns true let myString = " " myString.isEmptyAndContainsNoWhitespace() // returns false
źródło
Powinieneś zrobić coś takiego:
if !(string?.isEmpty ?? true) { //Not nil nor empty }
Operator łączenia zerowego sprawdza, czy argument opcjonalny nie jest zerowy, w przypadku, gdy nie jest zerowy, sprawdza następnie jego właściwość, w tym przypadku isEmpty. Ponieważ ta opcja może wynosić zero, podajesz wartość domyślną, która będzie używana, gdy opcja jest równa zero.
źródło
Moim zdaniem najlepszym sposobem sprawdzenia ciągów zerowych i pustych jest obliczenie liczby ciągów.
var nilString : String? print(nilString.count) // count is nil var emptyString = "" print(emptyString.count) // count is 0 // combine both conditions for optional string variable if string?.count == nil || string?.count == 0 { print("Your string is either empty or nil") }
źródło
Mając do czynienia z przekazywaniem wartości z lokalnej bazy danych do serwera i odwrotnie, miałem zbyt wiele problemów z? I !, a co nie.
Dlatego stworzyłem narzędzie Swift3.0 do obsługi przypadków zerowych i mogę prawie całkowicie uniknąć znaków? I! W kodzie.
func str(_ string: String?) -> String { return (string != nil ? string! : "") }
Dawny:-
Przed :
let myDictionary: [String: String] = ["title": (dbObject?.title != nil ? dbObject?.title! : "")]
Po :
let myDictionary: [String: String] = ["title": str(dbObject.title)]
i kiedy trzeba sprawdzić poprawny ciąg,
if !str(dbObject.title).isEmpty { //do stuff }
To zaoszczędziło mi kłopotów z dodawaniem i usuwaniem wielu znaków? I! Po napisaniu kodu, który ma sens.
źródło
Użyj operatora trójargumentowego (znanego również jako operator warunkowy
C++ forever!
):if stringA != nil ? stringA!.isEmpty == false : false { /* ... */ }
stringA!
Siły Unwrapping dzieje tylko wtedystringA != nil
, więc jest bezpieczne. Szczegółowość== false
jest nieco bardziej czytelna niż kolejny wykrzyknik w!(stringA!.isEmpty)
.Osobiście wolę nieco inną formę:
if stringA == nil ? false : stringA!.isEmpty == false { /* ... */ }
W powyższym stwierdzeniu jest od razu bardzo jasne, że cały
if
blok nie jest wykonywany, gdy zmienna jestnil
.źródło
pomocny podczas pobierania wartości z UITextField i sprawdzanie
nil
iempty
łańcuch@IBOutlet weak var myTextField: UITextField!
Oto twoja funkcja (po dotknięciu a
button
), która pobiera ciąg z UITextField i wykonuje inne rzeczy@IBAction func getStringFrom_myTextField(_ sender: Any) { guard let string = myTextField.text, !(myTextField.text?.isEmpty)! else { return } //use "string" to do your stuff. }
To zajmie się zarówno
nil
wartością, jak iempty
ciągiem znaków.U mnie zadziałało doskonale.
źródło
możesz użyć tej funkcji
class func stringIsNilOrEmpty(aString: String) -> Bool { return (aString).isEmpty }
źródło
nil
zgłasza wyjątku, ponieważ nie można w ogóle przejść do tej funkcji (z wyjątkiem objc, w którym to przypadku rzeczywiście ulegnie awarii).