¿Todos los lenguajes de programación tienen evaluación de cortocircuito booleano?

No es cierto para VB6.

En VB.net tienes que usar " AndAlso "en lugar de" And " si quieres que se salte la evaluación de la segunda expresión.

¿Es esto cierto para TODOS los lenguajes, como JAVA, C#, etc?

En C# esto solo es cierto para los operadores de cortocircuito '||' y '&&'; si solo usa '|' o '&', evaluará ambos lados cada vez.

Se llama evaluación de cortocircuito y la mayoría de los idiomas hacen esto. En algunos idiomas existen operadores que no hacen esto.

La versión original de Pascal no lo hizo, lo que causó mucho dolor. Los Pascales modernos, como Delphi, funcionan de la misma manera que C et al.

Ada tiene formas especiales de condicionales cortocircuitados:

and then
or else

Usado así:

if p.next /= null and then p.next.name = 'foo'
if x = 0 or else 1/x = y

De alguna manera es algo agradable porque se puede deducir que el programador sabía que la expresión necesitaba ser cortocircuitada y que el condicional no funciona por accidente.

Es cierto para los lenguajes que son "hijos" del C : PHP, Java, C++, C#, ... o en la misma "inspiración", como Perl.

Pero no es cierto para VB (al menos antes de.NET, que introdujo nuevas palabras clave para eso).
(Y eso es realmente perturbador la primera vez que trabajas con VB ^^ )

Microsoft VBScript (a menudo utilizado junto con ASP 'Classic') no tenía evaluación de cortocircuito para operadores booleanos, en su lugar utiliza evaluación bitwise. ¡Lo cual es una de las muchas razones por las que posiblemente sea el peor idioma de la historia!

" Lo que está pasando es que VBScript es no es lógico. VBScript es bit a bit. Todo los llamados operadores lógicos funcionan en números, no en valores Booleanos! No, Y, O, XOr, Eqv y Imp todos convertir sus argumentos a cuatro bytes enteros, hacer la operación lógica en cada par de bits en los enteros, y devuelve el resultado. Si True es -1 y False es 0 entonces todo funciona, porque -1 tiene todos sus bits encendidos y 0 tiene todos sus bits apagados. Pero si otros números entran ahí, todos bets are off"(en inglés).

Tomado de este blog. por Eric Lippert.

En Delphi es una opción de compilador.

Esto también es cierto para Java, pero los operadores|, & etc evaluarán ambos lados.

En Erlang, los operadores and y or no hacen la evaluación de cortocircuitos; tiene que usar los operadores orelse y andalso si desea un comportamiento de cortocircuito.

La mayoría de los lenguajes (todo lo que he visto) utilizan la evaluación de cortocircuitos en operadores CONDICIONALES como && y ||. Dejarán de evaluar tan pronto como una de las condiciones haya satisfecho el requisito. (La primera false &&. El primer verdadero en ||)

Se procesan todos los operadores BINARIOS como & y|. (Original)

Todos los operadores BITWISE tales como & y |, son procesados. (Edit: 5/10/17)

Esto se llama evaluación de cortocircuito y es común para todos los lenguajes en los que he trabajado (C, C++, C#, Java, Smalltalk, Javascript, Lisp) excepto para VB, VB.NET y Fortran.

En realidad es una característica bastante útil. Sin cortocircuito no sería capaz de hacer esto:

if (a != null && a.isBlank())

Sin cortocircuito, tendría que haber anidado las sentencias if porque la segunda parte arrojaría un error si a fuera nulo.

Coldfusion hará de forma nativa la evaluación de circuito corto. Estoy seguro de que todos los desarrolladores de CF han escrito:

<cfif isdefined("somevariable") and somevariable eq something>
//do logic
</cfif>

MATLAB es un lenguaje que distingue entre operadores lógicos" estándar " y operadores de cortocircuito :

• & (AND operator) y | (OR operator) pueden operar en matrices de una manera element-wise.
• && y || son versiones de cortocircuito para las que el segundo operando se evalúa solo cuando el resultado no está completamente determinado por el primer operando. Estos solo pueden operar en escalares, no en matrices.

En FORTRAN estándar o Fortran, los operandos de una expresión booleana se pueden evaluar en cualquier orden. Se permite la evaluación incompleta, pero se define la implementación.

Esto permite la optimización de expresiones booleanas que no estarían permitidas si se aplicara un orden estricto de Izquierda A Derecha. Las expresiones que requieren un orden estricto deben descomponerse en condicionales separados, o se pueden hacer suposiciones dependientes de la implementación.

Dado que la descomposición se utiliza para hacer cumplir ordenando, se deduce que las declaraciones separadas SI no siempre se pueden optimizar en una sola expresión. Sin embargo, la evaluación de cortocircuito es explícita con la descomposición, y esto nunca es peor que los lenguajes que imponen un orden estricto de izquierda a derecha para permitir la evaluación perezosa.

Los lenguajes que se derivan de FORTRAN (Fortran, BASIC, VBn), y los lenguajes que fueron diseñados para lograr una eficiencia similar a FORTRAN (Pascal, Ada) inicialmente siguieron el ejemplo de FORTRAN de permitir fuera de orden evaluación.

Otras respuestas han dado buenos ejemplos de lenguajes con y sin evaluación de cortocircuito, así que no los repetiré.

Solo un punto interesante para agregar: Lisps como Clojure tienen evaluación de cortocircuito booleano, pero además puede definir bastante trivialmente cualquier operador que desee con la evaluación de cortocircuito a través del uso de macros.

Ejemplo de una operación de cortocircuito "nand" en Clojure:

(defmacro nand 
  ([x] 
    `(not ~x))
  ([x & xs] 
    `(let [nand# (not ~x)]
       (if nand# 
         true               ; short circuit if we can prove the nand is true
         (nand ~@xs)))))    ; continue with the other expressions otherwise

(nand true true)
=> false

(nand false (println "Expression with a side effect!"))
=> true