Tipo de dados booleano - Boolean data type
Na ciência da computação , o tipo de dados booleano é um tipo de dados que tem um de dois valores possíveis (geralmente denotados como verdadeiro e falso ), que se destina a representar os dois valores verdadeiros da lógica e da álgebra booleana . Tem o nome de George Boole , que primeiro definiu um sistema algébrico de lógica em meados do século XIX. O tipo de dados booleano está principalmente associada com condicionais demonstrações, que permitem que as acções diferentes, alterando o fluxo de controlo , dependendo se um especificado pelo programador booleana condição avalia a verdadeira ou falsa. É um caso especial de uma forma mais geral tipo de dados lógico (ver lógica probabilística ) - lógica nem sempre precisa ser booleano.
Generalidades
Em linguagens de programação com um tipo de dados booleano integrado, como Pascal e Java , os operadores de comparação como >
e ≠
geralmente são definidos para retornar um valor booleano. Comandos condicionais e iterativos podem ser definidos para testar expressões com valor booleano.
Linguagens sem tipo de dados booleano explícito, como C90 e Lisp , ainda podem representar valores verdade por algum outro tipo de dados. Common Lisp usa uma lista vazia para false e qualquer outro valor para true. A linguagem de programação C usa um número inteiro tipo, em que as expressões relacionais como i > j
e expressões lógicos ligados por &&
e ||
são definidos para ter um valor verdadeiro se e 0 se falsa, enquanto que as peças de teste de if
, while
, for
, etc., tratamento de qualquer valor diferente de zero quanto verdade. Na verdade, uma variável booleana pode ser considerada (e implementada) como uma variável numérica com um dígito binário ( bit ), que pode armazenar apenas dois valores. A implementação de booleanos em computadores é mais provavelmente representada como uma palavra completa , em vez de um bit; isso geralmente se deve à maneira como os computadores transferem blocos de informações.
A maioria das linguagens de programação, mesmo aqueles com nenhum tipo booleano explícita, tem suporte para operações algébricas booleanas como conjunto ( AND
, &
, *
), disjunção ( OR
, |
, +
), equivalência ( EQV
, =
, ==
), exclusivo ou / não-equivalência ( XOR
, NEQV
, ^
, !=
), e negação ( NOT
, ~
, !
).
Em algumas linguagens, como Ruby , Smalltalk e Alice, os valores verdadeiro e falso pertencem a classes separadas , ou seja, True
e False
, respectivamente, portanto, não há um tipo booleano .
Em SQL , que usa uma lógica de três valores para comparações explícitas por causa de seu tratamento especial de nulos , o tipo de dados booleano (introduzido em SQL: 1999 ) também é definido para incluir mais de dois valores verdade, de modo que os booleanos SQL podem armazenar todos valores lógicos resultantes da avaliação de predicados em SQL. Uma coluna do tipo booleano pode ser restrita a apenas TRUE
e FALSE
embora.
ALGOL e o tipo booleano integrado
Uma das primeiras linguagens de programação a fornecer um tipo de dados booleano explícito é ALGOL 60 (1960) com valores verdadeiro e falso e operadores lógicos denotados por símbolos ' ' (e), ' ' (ou), ' ' (implica), ' ' (equivalência) e ' ' (não). Devido ao dispositivo de entrada e aos limites do conjunto de caracteres em muitos computadores da época, entretanto, a maioria dos compiladores usava representações alternativas para muitos dos operadores, como ou .
AND
'AND'
Essa abordagem com o booleano como tipo de dados embutido ( primitivo ou predefinido) foi adotada por muitas linguagens de programação posteriores, como Simula 67 (1967), ALGOL 68 (1970), Pascal (1970), Ada (1980), Java (1995) e C # (2000), entre outros.
Fortran
A primeira versão de FORTRAN (1957) e seu sucessor FORTRAN II (1958) não possuem valores lógicos ou operações; até mesmo a IF
declaração condicional assume uma expressão aritmética e se ramifica para uma das três localizações de acordo com seu sinal; veja aritmética IF . Fortran IV (1962), no entanto, segue o exemplo ALGOL 60, fornecendo um tipo booleano dados ( LOGICAL
), literais verdade ( .TRUE.
e .FALSE.
), booleana-valorizado operadores numéricos de comparação ( .EQ.
, .GT.
, etc.), e operadores lógicos ( .NOT.
, .AND.
, .OR.
). Nas FORMAT
instruções, um descritor de formato específico (' L
') é fornecido para a análise ou formatação de valores lógicos.
Lisp e Scheme
A linguagem Lisp (1958) nunca teve um tipo de dados booleano embutido. Em vez disso, construções condicionais como cond
assumem que o valor lógico false é representado pela lista vazia ()
, que é definida como igual ao átomo especial nil
ou NIL
; enquanto qualquer outra expressão s é interpretada como verdadeira . Por conveniência, a maioria dos dialetos modernos do Lisp predefinem o átomo t
para ter valor t
, de modo que t
pode ser usado como uma notação mnemônica para verdadeiro .
Esta abordagem ( qualquer valor pode ser usado como um valor booleano ) foi mantida na maioria dos dialetos Lisp ( Common Lisp , Scheme , Emacs Lisp ), e modelos semelhantes foram adotados por muitas linguagens de script , mesmo aquelas tendo um tipo booleano distinto ou valores booleanos; embora quais valores são interpretados como falsos e quais são verdadeiros variam de idioma para idioma. No Esquema, por exemplo, o valor falso é um átomo distinto da lista vazia, portanto, a última é interpretada como verdadeira . O Common Lisp, por outro lado, também fornece o boolean
tipo dedicado , derivado como uma especialização do símbolo.
Pascal, Ada e Haskell
A linguagem Pascal (1970) introduziu o conceito de tipos enumerados definidos pelo programador . Um Boolean
tipo de dados embutido foi então fornecido como um tipo enumerado predefinido com valores FALSE
e TRUE
. Por definição, todas as comparações, operações lógicas e declarações condicionais aplicadas e / ou produziram Boolean
valores. Caso contrário, o Boolean
tipo tinha todas as facilidades que estavam disponíveis para tipos enumerados em geral, como ordenação e uso como índices. Em contraste, a conversão entre se Boolean
inteiros (ou quaisquer outros tipos) ainda exigia testes explícitos ou chamadas de função, como em ALGOL 60. Esta abordagem ( booleano é um tipo enumerado ) foi adotada pela maioria das linguagens posteriores que tinham tipos enumerados, como Modula , Ada e Haskell .
C, C ++, Objective-C, AWK
As implementações iniciais da linguagem C (1972) não forneceram nenhum tipo booleano e, até hoje, os valores booleanos são comumente representados por inteiros ( int
s) em programas C. Os operadores de comparação ( >
, ==
, etc.) são definidos para voltar um inteiro assinado ( int
) resultado, ou 0 (para falso) ou 1 (por verdadeiro). Os operadores lógicos ( &&
, ||
, !
, etc.) e declarações de teste de condição ( if
, while
) assumir que zero é falso e todos os outros valores são verdadeiras.
Depois que os tipos enumerados enum
foram adicionados à versão de C do American National Standards Institute , ANSI C (1989), muitos programadores C se acostumaram a definir seus próprios tipos booleanos como tais, por razões de legibilidade. No entanto, os tipos enumerados são equivalentes a inteiros de acordo com os padrões de linguagem; portanto, a identidade efetiva entre booleanos e inteiros ainda é válida para programas C.
O padrão C (desde C99 ) fornece um tipo booleano, chamado _Bool
. Ao incluir o cabeçalho stdbool.h
, pode-se usar o nome mais intuitivo bool
e as constantes true
e false
. A linguagem garante que quaisquer dois valores verdadeiros serão comparados da mesma forma (o que era impossível de se conseguir antes da introdução do tipo). Os valores booleanos ainda se comportam como inteiros, podem ser armazenados em variáveis inteiras e usados em qualquer lugar em que os inteiros sejam válidos, incluindo indexação, aritmética, análise sintática e formatação. Esta abordagem (os valores booleanos são apenas inteiros ) foi mantida em todas as versões posteriores de C. Observe que isso não significa que qualquer valor inteiro pode ser armazenado em uma variável booleana.
C ++ tem um tipo de dados booleano separado bool
, mas com conversões automáticas de valores escalares e de ponteiro que são muito semelhantes aos de C. Essa abordagem foi adotada também por muitas linguagens posteriores, especialmente por algumas linguagens de script como AWK .
Objective-C também tem um tipo de dados booleano separado BOOL
, com os valores possíveis sendo YES
ou NO
, equivalentes de verdadeiro e falso, respectivamente. Além disso, em compiladores Objective-C que suportam C99, o _Bool
tipo de C pode ser usado, uma vez que Objective-C é um superconjunto de C.
Java
Em Java , o valor do tipo de dados booleano só pode ser true
ou false
.
Perl e Lua
Perl não tem tipo de dados booleano. Em vez disso, qualquer valor pode se comportar como booleano no contexto booleano (condição de if
ou while
instrução, argumento de &&
ou ||
, etc.). O número 0
, as strings "0"
e ""
, a lista vazia ()
e o valor especial são undef
avaliados como falsos. Todo o resto é avaliado como verdadeiro.
Lua tem um tipo de dados booleano, mas valores não booleanos também podem se comportar como booleanos. O valor sem valor é nil
avaliado como falso, enquanto todos os outros valores de tipo de dados são avaliados como verdadeiro. Isso inclui a string vazia ""
e o número 0
, que muitas vezes são considerados false
em outros idiomas.
Tcl
Tcl não possui um tipo booleano separado. Como em C, os inteiros 0 (falso) e 1 (verdadeiro - na verdade, qualquer inteiro diferente de zero) são usados.
Exemplos de codificação:
set v 1
if { $v } { puts "V is 1 or true" }
O acima irá mostrar V é 1 ou verdadeiro já que a expressão é avaliada como 1.
set v ""
if { $v } ....
O acima irá gerar um erro, pois a variável v não pode ser avaliada como 0 ou 1.
Python, Ruby e JavaScript
Python , da versão 2.3 em diante, tem um bool
tipo que é uma subclasse do int
tipo inteiro padrão. Ele tem dois valores possíveis: True
e False
, os quais são versões especiais de 1 e 0, respectivamente, e comportam-se como tal em contextos aritméticas. Além disso, um valor numérico de zero (inteiro ou fracionário), o valor nulo ( None
), a string vazia e os contêineres vazios (listas, conjuntos , etc.) são considerados booleanos falsos; todos os outros valores são considerados booleanos verdadeiros por padrão. As classes podem definir como suas instâncias são tratadas em um contexto booleano por meio do método especial __nonzero__
(Python 2) ou __bool__
(Python 3). Para contêineres, __len__
(o método especial para determinar o comprimento dos contêineres) é usado se o método explícito de conversão booleana não for definido.
Em Ruby , em contraste, apenas nil
(valor nulo de Ruby) e um false
objeto especial são falsos ; tudo o mais (incluindo o inteiro 0 e matrizes vazias) é verdadeiro .
Em JavaScript , uma string vazia ( ""
), null
, undefined
, NaN
, 0, -0 e false
às vezes são chamados Falsas (do qual o complemento é truthy ) para distinguir entre estritamente Type-verificados e coagidos Booleans. Ao contrário do Python, recipientes vazios (matrizes, mapas, conjuntos) são considerados verdadeiros. Linguagens como PHP também usam essa abordagem.
Shell de próxima geração
Next Generation Shell tem um Bool
tipo. Tem dois valores possíveis: true
e false
. Bool
não é intercambiável com Int
e deve ser convertido explicitamente, se necessário. Quando um valor booleano de uma expressão é necessário (por exemplo, em uma if
instrução), o Bool
método é chamado. Bool
o método para tipos integrados é definido de forma que retorne false
para um valor numérico de zero, o null
valor, a string vazia, recipientes vazios (listas, conjuntos, etc.), processos externos que saíram com código de saída diferente de zero ; para outros valores, Bool
retorna verdadeiro. Os tipos para os quais o Bool
método é definido podem ser usados no contexto booleano. Ao avaliar uma expressão no contexto booleano, se nenhum Bool
método apropriado for definido, uma exceção é lançada.
SQL
Os booleanos aparecem no SQL quando uma condição é necessária, como a cláusula WHERE , na forma de predicado que é produzido usando operadores como operadores de comparação, operador IN , IS (NOT) NULL etc. No entanto, além de TRUE e FALSE , esses operadores também pode gerar um terceiro estado, chamado UNKNOWN , quando a comparação com NULL
é feita.
O padrão SQL92 introduziu os operadores IS (NOT) TRUE, IS (NOT) FALSE e IS (NOT) UNKNOWN que avaliam um predicado, que antecedeu a introdução do tipo booleano no SQL: 1999 .
O padrão SQL: 1999 introduziu um tipo de dados BOOLEAN como um recurso opcional (T031). Quando restrito por uma restrição NOT NULL , um SQL BOOLEAN se comporta como Booleanos em outras linguagens, que podem armazenar apenas valores TRUE e FALSE . No entanto, se for anulável, que é o padrão como todos os outros tipos de dados SQL, ele também pode ter o valor nulo especial. Embora o padrão SQL defina três literais para o tipo BOOLEAN - TRUE, FALSE e UNKNOWN - ele também diz que o NULL BOOLEAN e UNKNOWN "podem ser usados alternadamente para significar exatamente a mesma coisa". Isso causou alguma controvérsia porque a identificação sujeita UNKNOWN às regras de comparação de igualdade para NULL. Mais precisamente, UNKNOWN = UNKNOWN
não é TRUE, mas UNKNOWN / NULL . Em 2012, poucos sistemas SQL importantes implementaram o recurso T031. Firebird e PostgreSQL são exceções notáveis, embora PostgreSQL não implemente nenhum literal DESCONHECIDO ; NULL
pode ser usado em seu lugar.
O tratamento dos valores booleanos difere entre os sistemas SQL.
Por exemplo, no Microsoft SQL Server , o valor booleano não é suportado, nem como um tipo de dados independente, nem representável como um inteiro. Ele mostra a mensagem de erro "Uma expressão de tipo não booleano especificada em um contexto onde uma condição é esperada" se uma coluna for usada diretamente na cláusula WHERE , por exemplo , enquanto uma instrução como produz um erro de sintaxe. O tipo de dados BIT , que só pode armazenar inteiros 0 e 1 além de NULL , é comumente usado como uma solução alternativa para armazenar valores booleanos, mas soluções alternativas precisam ser usadas, como converter entre o inteiro e a expressão booleana.
SELECT a FROM t WHERE a
SELECT column IS NOT NULL FROM t
UPDATE t SET flag = IIF(col IS NOT NULL, 1, 0) WHERE flag = 0
O Microsoft Access , que usa o mecanismo de banco de dados Microsoft Jet , também não tem um tipo de dados booleano. Semelhante ao MS SQL Server, ele usa um tipo de dados BIT . No Access, é conhecido como tipo de dados Sim / Não, que pode ter dois valores; Sim (verdadeiro) ou Não (falso). O tipo de dados BIT no Access também pode ser representado numericamente; Verdadeiro é -1 e Falso é 0. Isso difere do MS SQL Server de duas maneiras, embora ambos sejam produtos da Microsoft:
- O acesso representa VERDADEIRO como -1, enquanto é 1 no SQL Server
- O Access não oferece suporte ao estado triplo nulo, compatível com o SQL Server
O PostgreSQL tem um tipo BOOLEANO distinto como no padrão, que permite que predicados sejam armazenados diretamente em uma coluna BOOLEAN e permite o uso de uma coluna BOOLEAN diretamente como um predicado em uma cláusula WHERE .
No MySQL , BOOLEAN é tratado como um alias de ; TRUE é o mesmo que o inteiro 1 e FALSE é o mesmo que o inteiro 0. Qualquer número inteiro diferente de zero é verdadeiro nas condições.
TINYINT(1)
Quadro
Tableau Software tem um tipo de dados BOOLEAN. O literal de um valor booleano é True
ou False
.
A INT()
função Tableau converte um booleano em um número, retornando 1 para Verdadeiro e 0 para Falso.
Veja também
- Verdadeiro e falso (comandos) para script de shell
- Expansão de Shannon
- Cálculo diferencial booleano
- Lógica de três valores