sport - ¿Verifica cadena vacía en Swift?

swift sport

Question

En Objective C, uno podría hacer lo siguiente para verificar cadenas:

if ([myString isEqualToString:@""]) {
    NSLog(@"myString IS empty!");
} else {
    NSLog(@"myString IS NOT empty, it is: %@", myString);
}

¿Cómo se detectan cadenas vacías en Swift?

Answer 1

En veloz 4.0

Utilizar

var isEmpty: Bool { get } 

Ejemplo

let lang = "Swift 4"

if lang.isEmpty {
print("Empty string")
}

Answer 2

Ahora está la capacidad incorporada para detectar cadenas vacías con .isEmpty :

if emptyString.isEmpty {
    print("Nothing to see here")
}

Documentación preliminar de Apple: "Cadenas y caracteres" .

Answer 3

Así es como compruebo si la cadena está en blanco. Con ''en blanco'' me refiero a una cadena que está vacía o contiene solo caracteres de espacio / nueva línea.

struct MyString {
  static func blank(text: String) -> Bool {
    let trimmed = text.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceAndNewlineCharacterSet())
    return trimmed.isEmpty
  }
}

Cómo utilizar:

MyString.blank(" ") // true

Answer 4

Esto es lo que uso (funciona tanto para cadenas como para otros objetos):

func checkValidityOfData(_ data: Any?, withStringCheck mode: Bool) -> Bool {

    // Check if the data is valid or not.

    if ((data != nil) && !(data is NSNull)) {

        // Check if we need to perform string checks.

        if (mode == true) {

            // Check the input data string.
            let dataCheck = (data as! String).trimmingCharacters(in: CharacterSet.whitespacesAndNewlines)

            // Check if the string is valid.

            if (dataCheck.count > 0) {

                // Ensure the string is not literally "<null>".

                if ((data as! String) == "<null>") {
                    return false
                } else {
                    return true
                }

            } else {
                return false
            }

        } else {
            return true
        }

    } else {
        return false
    }
}

Answer 5

Estoy reescribiendo por completo mi respuesta ( again ). Esta vez es porque me he convertido en un fan de la declaración de guard y el regreso temprano . Hace un código mucho más limpio.

Cadena no opcional

Verifique la longitud cero.

let myString: String = ""

if myString.isEmpty {
    print("String is empty.")
    return // or break, continue, throw
}

// myString is not empty (if this point is reached)
print(myString)

Si pasa la instrucción if , entonces puede usar la cadena de forma segura sabiendo que no está vacía. Si está vacío, la función volverá temprano y nada después de que importe.

Cadena opcional

Verifique nulo o longitud cero.

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)

Esto desenvuelve el opcional y comprueba que no esté vacío al mismo tiempo. Después de pasar la declaración de guard , puede usar con seguridad su cuerda no vacía sin envolver.

Answer 6

Para cuerdas opcionales, qué tal:

if let string = string where !string.isEmpty
{
    print(string)
}

Answer 7

Para hacer la comprobación nil y la longitud simultáneamente Swift 2.0 e iOS 9 en adelante, podrías usar

if(yourString?.characters.count > 0){}

Answer 8

Qué pasa

if let notEmptyString = optionalString where !notEmptyString.isEmpty {
    // do something with emptyString 
    NSLog("Non-empty string is %@", notEmptyString)
} else {
    // empty or nil string
    NSLog("Empty or nil string")
}

Answer 9

También puede usar una extensión opcional para que no tenga que preocuparse por desenvolver o usar == true :

extension String {
    var isBlank: Bool {
        return self.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
    }
}
extension Optional where Wrapped == String {
    var isBlank: Bool {
        if let unwrapped = self {
            return unwrapped.isBlank
        } else {
            return true
        }
    }
}

Nota: cuando llame a esto en una opción, asegúrese de no utilizar ? de lo contrario, aún será necesario desenvolverlo.

Answer 10

Una manera concisa de verificar si la cadena es nula o vacía sería:

var myString: String? = nil

if (myString ?? "").isEmpty {
    print("String is nil or empty")
}

Answer 11

Verificación de solo espacios y caracteres de líneas nuevas en el texto

extension String
{
    var  isBlank:Bool {
        return self.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceAndNewlineCharacterSet()).isEmpty
    }
}

utilizando

if text.isBlank
{
  //text is blank do smth
}

Answer 12

isEmpty hará lo que creas, si string == "", devolverá true. Algunas de las otras respuestas apuntan a una situación en la que tiene una cadena opcional.

POR FAVOR use el encadenamiento opcional !!!!

Si la cadena no es nula, se usará Vacío, de lo contrario no lo hará.

A continuación, la cadena opcional NO se establecerá porque la cadena es nula

let optionalString: String? = nil
if optionalString?.isEmpty == true {
     optionalString = "Lorem ipsum dolor sit amet"
}

Obviamente, no usarías el código anterior. Las ganancias provienen del análisis JSON u otras situaciones similares en las que tiene un valor o no. Este código de garantías se ejecutará si hay un valor.