c# - check - jquery string is null or empty

string.IsNullOrEmpty() vs string.NotNullOrEmpty()

Question

Tengo curiosidad si algunos desarrolladores usan string.IsNullOrEmpty () más a menudo con un negativo que con un positivo

p.ej

if (!string.IsNullOrEmpty())

Así es como uso el método el 99% del tiempo. ¿Cuál fue la decisión de diseño para esto?

Answer 1

"NotNullOrEmpty" es ambiguo, podría significar "(no nulo) o vacío" o podría significar "no (nulo o vacío)". Para que sea inequívoco, tendrías que usar "NotNullAndNotEmpty", que es un bocado.

Además, la denominación "IsNullOrEmpty" fomenta el uso como cláusula de protección, lo que creo que es útil. P.ej:

if (String.IsNullOrEmpty(someString))
{
   // error handling
   return;
}
// do stuff

que creo que es generalmente más limpio que

if (!String.IsNullOrEmpty(someString))
{
   // do stuff
}
else
{
   // error handling
   return;
}

Answer 2

De hecho, me sentiría inclinado a ofrecer una respuesta diferente a la explicación "es ambigua" proporcionada por varios otros (aunque también estoy de acuerdo con esa respuesta):

Personalmente, me gusta minimizar el anidamiento en mi código, ya que (para mí), cuanto más rizado tiene el código, más difícil es seguirlo.

Por eso preferiría mucho esto (por ejemplo):

public bool DoSomethingWithString(string s) {
    if (string.IsNullOrEmpty(s))
        return false;

    // here''s the important code, not nested
}

a esto:

public bool DoSomethingWithString(string s) {
    if (!string.IsNullOrEmpty(s)) {
        // here''s the important code, nested
    } else {
        return false;
    }
}

Este es un escenario bastante específico (donde una cadena nula / vacía solicita una salida inmediata) y claramente no es la forma en que un método que usa IsNullOrEmpty siempre estaría estructurado; Pero creo que en realidad es bastante común.

Answer 3

Ese es el uso más común que he visto.

Answer 4

Las convenciones de nomenclatura de C # dictan que sus expresiones deben ser positivas, como "Es ..." y no "No es ..."

EDITAR: Por lo general, lo uso cuando realizo la verificación de errores y la validación de entrada al comienzo de un método y levanto una excepción si el parámetro es nulo o está vacío.

if (string.IsNullOrEmpty(myParameter))  {  throw new ....  } 

Answer 5

Los negativos dobles suelen ser desalentados al nombrar cosas. !string.NotNullOrEmpty(...) haría uno.

Answer 6

Para los lógicos que hay por ahí,! String.IsNullOrEmpty no es equivalente a string.IsNotNullOrEmpty. @Guffa lo tiene correcto. Usando la ley de DeMorgan, tendría que ser string.IsNotNullAndNotEmpty para ser equivalente.

¬ (nulo ∨ vacío) ⇔ ¬nulo ∧ ¬ vacío

¬ (nulo ∨ vacío) ≠ ¬ nulo ∨ vacío

El punto aquí, supongo, es que la forma en que está actualmente es inequívoca, por lo que hacer que lo contrario no sea ambiguo sería engorroso.

Answer 7

Personalmente prefiero atender primero el escenario no negado. Simplemente tiene sentido para mí hacer la parte verdadera primero y luego la falsa. Se reduce al estilo personal.

Answer 8

Por supuesto, siempre puede usar string.IsNullOrWhiteSpace(string) ahora en lugar de string .IsNullOrEmpty(string) de .NET 4.0

Answer 9

Porque "IsNullOrEmpty" es más fácil de entender que "NotNullOrEmpty". Este último podría interpretarse como:

1. No es nulo y no está vacío.
2. No es nulo o está vacío.

Answer 10

Siempre creo un método de extensión para "HasContent ()" que generalmente tiene sentido, sigue las especificaciones "positivas" y ahorra en el código inflado porque lo uso mucho más a menudo que su contraparte:

public static bool HasContent(this string s) {
    return !string.IsNullOrEmpty(s);
}

Answer 11

Siempre he pensado que me parecía al revés, ya que uso el negativo con mucha más frecuencia que el positivo.

También me gustaría que haya una instancia IsEmpty () o IsNotEmpty () para usar cuando la variable se declara dentro de la función. Esto no podría ser IsNullOrEmpty () o IsNotNullOrEmpty () como si la instancia fuera nula, entonces obtendría una excepción de referencia nula.

Answer 12

Solo como nota al margen, prefiero el método de extensión:

public static class StringExtensions
{
    public static bool IsNullOrEmpty(this string value)
    {
        return string.IsNullOrEmpty(value);
    }
}

Me parece que se lee mejor decir:

if(myValue.IsNullOrEmpty())

o

if(!myValue.IsNullOrEmpty())

Answer 13

Tal vez porque entonces el nombre tendría que ser el largo IsNotNullAndNotEmpty para ser tan específico.