¿Qué significa una sola barra vertical en JavaScript?

Question

¿Qué significa esta expresión en JS?

Value |= this.value 

Answer 1

Es binario "OR", al igual que en C o C++ o Java. En este caso, se utiliza en su forma operador de asignación, por lo

value |= this.value 

significa que this.value y value están ambos convertidos a números enteros de 32 bits, y se realiza una operación OR operación. Si value fueron 10 y this.value fueron 3 antes de la operación (es decir, 01010 y 011 en binario), el resultado sería 11 (01011 en binario).

Los operadores lógicos binarios en Javascript son notables en Javascript porque el trabajo se lleva a cabo en los valores enteros.

El término "bit-wise" es quizás más preciso que "binary". Las operaciones actúan sobre cada bit de un valor numérico, específicamente los valores numéricos forzados a enteros de 32 bits con signo. El resultado es también un entero de 32 bits con signo (según la especificación).

Sin embargo, los números de JavaScript "en reposo" son siempre valores binarios de coma flotante de 64 bits. Por lo tanto, los resultados de los operadores bit a bit, aunque se computan con enteros matemáticos de 32 bits, se almacenan en forma de coma flotante. Eso funciona porque la gama de enteros de 32 bits se ajusta cómodamente y con precisión en un flotador de 64 bits.

Answer 2

Esto llevará a cabo un bitwise OR entre los bits en this.value y los bits ya almacenados en Value, a continuación, almacenar el resultado de nuevo en Value.

var Value = 42; // 00101010 
Value |= 96;  // 01100000 
window.alert(Value); // 01101010 -> 106 

Answer 3

Es un operador bit a bit o de asignación, similar a +=. Si ejecuta una prueba de esta manera:

<ol> 
<script language="javascript"> 
var x=false; 
document.writeln("<li>"+x+"</li>"); 
x|=true; 
document.writeln("<li>"+x+"</li>"); 
x&=false; 
document.writeln("<li>"+x+"</li>"); 
</script> 
</ol> 

que obtendrá esta salida (en IE)

1.false 
2.1 
3.0 

Esencialmente, x|=y es lo mismo que decir x=x|y

Answer 4

Como otros tienen señalado, este es el operador O bit a bit. Sin embargo, no creo que la gente lo use mucho en valores numéricos en Javascript ya que, en general, no se realizan muchos cálculos en Javascript. Para darle una mejor idea de por qué este operador es útil, considere el escenario mucho más común que el usuario necesita para completar al menos uno de los múltiples campos de texto.

Digamos que tiene este código HTML:

<input type="text" class="phone-nr" id="home-phone-nr-1" /> 
<input type="text" class="phone-nr" id="home-phone-nr-2" /> 
<input type="text" class="phone-nr" id="home-phone-nr-3" /> 
<input type="text" class="phone-nr" id="mobile-phone-nr-1" /> 
<input type="text" class="phone-nr" id="mobile-phone-nr-2" /> 
<input type="text" class="phone-nr" id="mobile-phone-nr-3" /> 

El usuario tiene la opción de llenar varios números de teléfono, pero tendrá que proporcionar al menos una.

La forma más sencilla de hacer esto (con jQuery en este caso) es:

var valid = false; 
$('.phone-nr').each(function(i, item){ 
    valid |= $(item).val(); 
}); // untested code 

valid será verdadera si al menos un campo de entrada con la clase phone-nr tiene un valor que no esté vacía.

Si todos los campos necesidad ser rellenado (un requisito más común), puede hacerlo de esta manera con el operador AND:

var valid = true; 
$('.phone-nr').each(function(i, item){ 
    valid &= $(item).val(); 
}); // untested code 

valid sólo será cierto si todos campos de entrada tienen un valor.

Si al menos único campo se requiere para ser rellenado, pero no más de un puede utilizar el operador XOR:

var valid = false; 
$('.phone-nr').each(function(i, item){ 
    valid ^= $(item).val(); 
}); // untested code 

Esos son, en mi opinión, el mundo real utiliza de operadores bit a bit en Javascript.

Answer 5

un uso práctico para el operador que he encontrado:

(3|0) === 3;    // целые числа не изменяет 
(3.3|0) === 3;   // у дробных чисел отбрасывает дробную часть 
(3.8|0) === 3;   // не округляет, а именно отбрасывает дробную часть 
(-3.3|0) === -3;   // в том числе и у отрицательных дробных чисел 
(-3.8|0) === -3;   // у которых Math.floor(-3.3) == Math.floor(-3.8) == -4 
("3"|0) === 3;   // строки с числами преобразуются к целым числам 
("3.8"|0) === 3;   // при этом опять же отбрасывается дробная часть 
("-3.8"|0) === -3;  // в том числе и у отрицательных дробных чисел 
(NaN|0) === 0;   // NaN приводится к нулю 
(Infinity|0) === 0;  // приведение к нулю происходит и с бесконечностью, 
(-Infinity|0) === 0;  // и с минус бесконечностью, 
(null|0) === 0;   // и с null, 
((void 0)|0) === 0;  // и с undefined, 
([]|0) === 0;   // и с пустым массивом, 
([3]|0) === 3;   // но массив с одним числом приводится к числу, 
([-3.8]|0) === -3;  // в том числе с отбрасыванием дробной части, 
([" -3.8 "]|0) === -3; // и в том числе с извлечением чисел из строк, 
([-3.8, 22]|0) === 0  // но массив с несколькими числами вновь зануляется 
({}|0) === 0;    // к нулю также приводится пустой объект 
({'2':'3'}|0) === 0;   // или не пустой 
((function(){})|0) === 0; // к нулю также приводится пустая функция 
((function(){ return 3;})|0) === 0; 

y un poco de magia para mí:

3 | '0px' === 3;