Pregunta

Tengo un compañero de trabajo que sostiene que VERDADERO solía definirse como 0 y que todos los demás valores eran FALDOS.Podría jurar que en todos los idiomas con los que he trabajado, si pudiera obtener un valor para un booleano, el valor de FALSO es 0.¿VERDADERO solía ser 0?Si es así, ¿cuándo cambiamos?

¿Fue útil?

Solución

Lo que confunde a su compañero de trabajo 0 / no 0 probablemente se refiere a cuando las personas usan valores numéricos como valor de retorno que indica el éxito, no la verdad (es decir,en scripts bash y algunos estilos de C/C++).

Usar 0 = éxito permite una precisión mucho mayor al especificar las causas del fracaso (p. ej.1 = lima faltante, 2 = extremidad faltante, etc.).

Como nota al margen:en Ruby, los únicos valores falsos son nulo y falso.0 es verdadero, pero no a diferencia de otros números.0 es verdadero porque es una instancia del objeto 0.

Otros consejos

Podría ser en referencia a un código de resultado de 0 que, en la mayoría de los casos, después de ejecutar un proceso, un código de resultado de 0 significaba: "Oye, todo funcionó bien, no hay problemas aquí".

Trabajé en una empresa con una gran cantidad de código C antiguo.Algunos de los encabezados compartidos definieron sus propios valores para VERDADERO y FALSO, y algunos de hecho tenían VERDADERO como 0 y FALSO como 1.Esto llevó a "guerras de la verdad":

/* like my constants better */
#undef TRUE
#define TRUE 1

#undef FALSE
#define FALSE 0

Al menos, los shells bash todavía usan 0 para verdadero y 1 para falso.

Varias funciones de la biblioteca estándar de C devuelven como resultado un número entero de 'código de error'.Dado que noErr se define como 0, una comprobación rápida puede ser "si es 0, está bien".La misma convención se aplica al "código de resultado" de un proceso Unix;es decir, un número entero que daba alguna indicación sobre cómo terminó un proceso determinado.

En las secuencias de comandos de shell de Unix, el código de resultado de un comando recién ejecutado está disponible y normalmente se usa para indicar si el comando "tuvo éxito" o no, donde 0 significa éxito y cualquier otra condición específica de no éxito.

A partir de eso, todas las construcciones tipo prueba en los scripts de shell usan 'éxito' (es decir, un código de resultado de 0) para significar VERDADERO, y cualquier otra cosa para significar FALSO.

En un plano totalmente diferente, los circuitos digitales utilizan con frecuencia "lógica negativa".es decir, incluso si 0 voltios se denomina '0 binario' y algún valor positivo (comúnmente +5v o +3,3v, pero hoy en día no es raro usar +1,8v) se denomina '1 binario', algunos eventos se 'afirman' por un pin dado que va a 0.Creo que la resistencia al ruido tiene algunas ventajas, pero no estoy seguro de los motivos.

Tenga en cuenta, sin embargo, que no hay nada "antiguo" o algún "tiempo de cambio" en esto.Todo lo que sé sobre esto se basa en viejas convenciones, pero son totalmente actuales y relevantes en la actualidad.

No estoy seguro, pero puedo decirte esto:Los trucos que se basan en la naturaleza subyacente de VERDADERO y FALSO son propensos a errores porque la definición de estos valores se deja en manos del implementador del lenguaje (o, al menos, del especificador).

Las llamadas al sistema en la biblioteca estándar de C normalmente devuelven -1 en caso de error y 0 en caso de éxito.Además, la declaración if calculada por Fotran saltaría (y probablemente todavía lo hace) a uno de los tres números de línea dependiendo de la condición que se evalúe como menor, igual o mayor que cero.

p.ej:SI (I-15) 10,20,10

probaría la condición de I == 15 saltando a la línea 20 si es verdadero (evalúa a cero) y a la línea 10 en caso contrario.

Sam tiene razón acerca de los problemas de confiar en conocimientos específicos de los detalles de implementación.

Regla general:

  1. Shells (DOS incluidos) Use "0" como "sin error" ...no necesariamente cierto.

  2. Los lenguajes de programación usan distintos de cero para denotar verdadero.

Dicho esto, si estás en un lenguaje que te permite definir VERDADERO o FALSO, defínelo y usa siempre las constantes.

Incluso hoy en día, en algunos idiomas (Ruby, lisp, ...) 0 es verdadero porque todo excepto nil es verdadero.Más a menudo 1 es cierto.Este es un problema común y, por lo tanto, a veces se considera una buena práctica no confiar en que 0 sea falso, sino realizar una prueba explícita.Java requiere que hagas esto.

En lugar de esto

int x;    
....
x = 0;
if (x)  // might be ambiguous
{
}

hacer es explícito

if (0 != x)
{
}

Recuerdo haber hecho algo de programación en VB en un formulario de acceso donde True era -1.

Recuerdo que PL/1 no tenía clase booleana.Podrías crear un bit y asignarle el resultado de una expresión booleana.Luego, para usarlo, había que recordar que 1 era falso y 0 era verdadero.

En su mayor parte, falso se define como 0 y verdadero es distinto de cero.Algunos lenguajes de programación usan 1, algunos usan -1 y algunos usan cualquier valor distinto de cero.

Sin embargo, para los shells de Unix, utilizan la convención opuesta.

La mayoría de los comandos que se ejecutan en un shell de Unix son en realidad programas pequeños.Devuelven un código de salida para que pueda determinar si el comando fue exitoso (un valor de 0) o si falló por algún motivo (1 o más, según el tipo de falla).

Esto se usa en los intérpretes de shell sh/ksh/bash dentro de los comandos if/ while/until para verificar las condiciones:

if command
then
   # successful
fi

Si el comando tiene éxito (es decir, devuelve un código de salida cero), se ejecuta el código dentro de la declaración.Normalmente, el comando que se utiliza es el comando [, que es un alias del comando de prueba.

Lo curioso es que depende del idioma con el que estés trabajando.En lua es verdadero == cero interno para el rendimiento.Lo mismo ocurre con muchas llamadas al sistema en C.

Es fácil confundirse cuando las declaraciones de retorno verdadero/falso de bash son al revés:

$ false; echo $?
1
$ true; echo $?
0

He oído hablar y he usado compiladores más antiguos donde verdadero > 0 y falso <= 0.

Esa es una de las razones por las que no desea utilizar if(puntero) o if(number) para comprobar si hay cero, ya que podrían evaluarse como falso inesperadamente.

De manera similar, he trabajado en sistemas donde NULL no era cero.

En el lenguaje C, antes de C++, no existía el booleano.Los condicionales se hicieron probando enteros.Cero significaba falso y cualquier valor distinto de cero significaba verdadero.Entonces podrías escribir

if (2) {
  alwaysDoThis();
} else {
  neverDothis();
}

Afortunadamente, C++ permitió un tipo booleano dedicado.

En cualquier idioma en el que haya trabajado (remontándonos a BASIC a finales de los 70), falso se ha considerado 0 y verdadero no es cero.

no puedo recordar TRUE ser 0. 0 Sin embargo, es algo que un programador de C volvería a indicar éxito.Esto se puede confundir con TRUE.

no siempre es 1 cualquiera.Puede ser -1 o simplemente distinto de cero.

Para lenguajes sin un tipo booleano incorporado, la única convención que he visto es definir VERDADERO como 1 y FALSO como 0.Por ejemplo, en C, el if La declaración ejecutará la cláusula if si la expresión condicional se evalúa como algo distinto de 0.

Incluso una vez vi un documento de pautas de codificación que decía específicamente no redefinir VERDADERO y FALSO.:)

Si está utilizando un lenguaje que tiene un booleano incorporado, como C++, entonces las palabras clave true y false son parte del lenguaje y no debe confiar en cómo se implementan realmente.

En lenguajes como C no había ningún valor booleano por lo que había que definir el suyo propio.¿Podrían haber trabajado en anulaciones de BOOL no estándar?

¡DOS y los códigos de salida de las aplicaciones generalmente usan 0 para significar éxito y distinto de cero para significar algún tipo de falla!

Los códigos de error de DOS son 0-255 y cuando se prueban usando la sintaxis 'errorlevel' significan cualquier valor superior o incluido el valor especificado, por lo que lo siguiente coincide con 2 y superiores con el primer punto, 1 con el segundo y 0 (éxito) con el final. !

IF errorlevel 2 goto CRS
IF errorlevel 1 goto DLR
IF errorlevel 0 goto STR

El motor de base de datos de SQL Server optimiza el almacenamiento de columnas de bits.Si hay 8 o menos columnas de bits en una tabla, las columnas se almacenan como 1 byte.Si hay columnas de 9 a 16 bits, las columnas se almacenan como 2 bytes, y así sucesivamente.Los valores de cadena VERDADERO y FALSO se pueden convertir a valores de bits:VERDADERO se convierte en 1 y FALSO se convierte en 0.La conversión a bit promueve cualquier valor distinto de cero a 1.

Cada idioma puede tener 0 como verdadero o falso, así que deje de usar el número Use palabras verdaderas lol o t y f 1 byte almacenamiento

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top