As palavras anteriores
Os operadores de bits são operações muito subjacentes e não são comumente usados porque não são intuitivos. No entanto, é extremamente rápido e pode obter bons resultados quando usado razoavelmente. Este artigo apresentará o operador frequentemente esquecido em JavaScript - Operador de Bit
Representação binária
Todos os valores no ECMAScript são armazenados no formato IEEE-754 de 64 bits, mas o operador de bits não opera diretamente o valor de 64 bits, mas é calculado como um número inteiro assinado de 32 bits e o valor de retorno também é um número inteiro assinado de 32 bits.
Essa conversão de bits permite que ambos os valores sejam tratados como 0 ao aplicar operações de bits em valores especiais de nan e infinito
Se um operador de bits for aplicado a um valor não numérico, o valor será convertido em um valor numérico usando o número () primeiro, e o resultado é um valor numérico
// '|' significa bit netwise ou, um número inteiro e 0 bit ou operação podem se obter, e um decimal e 0 bit ou operação podem obter o console de efeito arredondado.log (1.3 | 0); // 1console.log (1.8 | 0); // 1console.log (infinidade | 0); // 0Consol.Ong (-inininity (-inininity | 0); // 0console.log ('12px' | 0); // 0console.log ('12 '| 0); // 12Um número inteiro assinado usa os 31 primeiros dos 32 bits para representar o valor inteiro, o 32 bit para representar o símbolo inteiro, 0 representa o número positivo e 1 representa o número negativo. O bit representando um símbolo é chamado de bit de sinal e o valor do bit de sinal determina o formato de outros valores de bits. Entre eles, números positivos são armazenados em formato binário puro, e cada um dos 31 bits representa um poder de 2. O primeiro bit (chamado bit 0) representa 0 vezes 2, o segundo bit representa 1 tempo de 2 e assim por diante. Bits não utilizados são preenchidos com 0, ou seja, eles são ignorados.
Por exemplo, a representação binária do valor numérico 18 é 000000000000000000000000000010010, ou quanto mais conciso 10010. Estes são 5 bits válidos, e esses 5 bits determinam o valor real
console.log ((18) .ToString (2)); // "10010"
console.log (0B00000000000000000000000000000000000010010); // 18
Os números negativos também são armazenados em binário, mas o formato usado está no complemento de dois. Para calcular o complemento de um número numérico, você precisa seguir as 3 etapas seguintes:
【1】 Encontre o código binário do valor absoluto desse valor numérico
【2】 Encontre código inverso binário, ou seja, substitua 0 por 1, substitua 1 por 0
【3】 O código inverso binário obtido é adicionado a 1
Por exemplo, para determinar uma representação binária de -18, você deve primeiro obter uma representação binária de 18, como mostrado abaixo:
0000 0000 0000 0000 0000 0000 0001 0010
Em seguida, calcule o código inverso binário da seguinte forma:
1111 1111 1111 1111 1111 1111 1111 1110 1101
Por fim, adicione 1 ao código inverso binário, como segue:
1111 1111 1111 1111 1111 1111 1110 1101 1 --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Portanto, a representação binária de -18 é 1111 1111 1111 1111 1111 1111 1111 1111 1110 1110
O ECMAScript tentará o possível para esconder todas essas informações de nós. Ao emitir um número negativo na forma de uma string binária, tudo o que vemos é que o código binário com o valor absoluto desse número negativo é precedido por um sinal negativo.
var num = -18; console.log (num.toString (2)); // ' -10010'
O operador de bits pode executar 7 tipos de operações, incluindo bit netwise (não), bit e (e), bit ou (ou), exclusivo bit ou (xor), deslocamento esquerdo, mudança direita assinada e mudança direita sem assinatura.
Bitwise não (não)
O não operador bitwee é representado por uma linha ondulada (~). O resultado da execução do não operador bitwise é retornar o código inverso do valor. Sua essência é menos o valor negativo do operando por 1
var num1 = 25; var num2 = ~ num1; console.log (num2); //-26
Você pode obter o efeito de arredondamento por bit bit -in para um número inteiro; Você pode obter o efeito de arredondamento por bit bit -in para um decimal.
console.log (~~ 3); // 3console.log (~~ 3.1); // 3console.log (~~ 3.9); // 3
Bit a bit e (e)
O Bitwise e o operador são representados por um símbolo de soma (&), que possui dois números de operador. Essencialmente, bit -bit e operação é alinhar cada bit de dois valores e, em seguida, executar uma e operação em dois números na mesma posição, de acordo com as regras da tabela a seguir.
O primeiro bit de valor do segundo bit de valor resultado 1 1 11 0 00 1 00 0 0 0 0
Bitwise e a operação retornará 1 somente se os bits correspondentes dos dois valores forem 1. Qualquer bit for 0 e o resultado for 0.
var iresult = 25 & 3; console.log (irresult); // "1"
A análise é a seguinte 25 = 0000 0000 0000 0000 0000 0000 0001 1001 3 = 0000 0000 0000 0000 0000 0000 0000 000000 0000 0000 0000 0000 00 0000 0000 0000 0000 0000 PARA 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0001
Bit nejudado ou (ou)
O bitwise ou o operador é representado por um símbolo vertical (|) e também existem dois operandos. A operação Bitwise ou segue a seguinte tabela de verdade
O primeiro bit de valor do segundo bit de valor resultado 1 1 11 0 10 1 10 0 0 0
Bitwise ou operação retorna 1 se um bit for 1 e somente se os dois bits forem 0.
var iresult = 25 | 3; console.log (irresult); // "27"
// Análise é a seguinte 25 = 0000 0000 0000 0000 0000 0000 0001 1001 3 = 0000 0000 0000 0000 0000 0000 0000 0000 0001 1011
Um número inteiro e 0 bit ou operação podem obtê -lo, e um decimal e 0 bit;
console.log (3.1 | 0); // 3console.log (3.9 | 0); // 3
Bitwise xor (xor)
O operador Bitwise XOR é representado por um caret (^) e possui dois operandos. A seguir é a tabela de verdade do XOR bit
O bit do primeiro valor o bit do segundo valor 1 1 01 0 10 1 10 0 0 0
Retorna 0 quando os dois valores do XOR bit são os mesmos e retornam 1 quando não estão ao mesmo tempo
var iresult = 25 ^ 3; console.log (irresult); // "26"
// Análise é a seguinte 25 = 0000 0000 0000 0000 0000 0000 0001 1001 3 = 0000 0000 0000 0000 0000 0000 0000 0000 0001 1010
"Operação Exoroor" possui um uso especial, que executa três operações XOR em dois números A e B em sucessão, aˆ = b, bˆ = a, aˆ = b e seus valores podem ser trocados. Isso significa que o uso de "exclusivo ou operação" pode trocar os valores de duas variáveis sem introduzir variáveis temporárias
var a = 10, b = 9; a ^= b, b ^= a, a ^= b; console.log (a, b); // 9,10
A análise é a seguinte a = 0000 0000 0000 0000 0000 0000 0000 0000 1010 B = 0000 0000 0000 0000 0000 0000 0000 000000 0000 0000 0000 00 00 00O1 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 1001 ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Um número inteiro com 0 xor bit -net pode se manter, e um decimal com 0 bit xor pode ser arredondado
console.log (3.1 ^ 0); // 3console.log (3,9 ^ 0); // 3
Mover para a esquerda
O operador de turno esquerdo é representado por dois sinais a menos que (<<). Este operador moverá todos os bits do valor para a esquerda pelo número especificado de bits.
Por exemplo, se o valor 2 (o código binário for 10) for deslocado 5 bits para a esquerda, o resultado será 64 (1000000)
var OldValue = 2; var newValue = OldValue << 5; console.log (newValue); // 64
Mover para a esquerda não afetará o bit de sinal do operando. Em outras palavras, se -2 for movido 5 bits para a esquerda, o resultado será -64
var OldValue = -2; var newValue = OldValue << 5; console.log (newValue); // -64
O turno esquerdo 0 bits pode alcançar um efeito de arredondamento
console.log (3.1 << 0); // 3console.log (3.9 << 0); // 3
Assinado direito
O operador de deslocamento direito assinado é representado por dois maiores que os sinais (>>), que move o valor para a direita, mas mantém os bits de sinal (ou seja, marcas de sinal). A operação de mudança direita assinada é exatamente o oposto da operação de turno esquerdo, ou seja, se 64 for movido de 5 bits para a direita, o resultado será alterado de volta para 2.
var OldValue = 64; var newValue = OldValue >> 5; console.log (newValue); // 2
Da mesma forma, durante o processo de mudança, a vaga também aparecerá no valor original. No entanto, desta vez a vaga aparece no lado esquerdo do valor original e no lado direito do bit de sinal. No momento, o ECMAScript preencherá todos os espaços vazios com o valor do bit de sinal para obter um valor completo
Mova -se para a direita para simular a operação do divisor de 2
console.log (5 >> 1); // 2console.log (15 >> 1); // 7
Certo não assinado
O operador de mudança direto não assinado é representado por 3 maiores que os sinais (>>>), que move todos os 32 bits do valor para a direita. Para números positivos, o resultado da mudança direita não assinada é a mesma que a mudança direita assinada. É conveniente mover a placa bem na frente dele. Se você mover os 64 não assinados por 5 bits, o resultado ainda é 2
var OldValue = 64; var newValue = OldValue >>> 5; console.log (newValue); // 2
No entanto, o número negativo é diferente. Primeiro, a mudança direita não assinada preenche o bit vazio com 0, em vez de preencher o bit vazio com o valor do bit assinado como o turno direito assinado. Portanto, o resultado da mudança direita não assinada para um número positivo é o mesmo que o resultado de uma mudança de título para um título, mas o resultado de um número negativo é diferente. Em segundo lugar, o operador de mudança direita não assinado tratará o código binário negativo como o código binário positivo. Além disso, como o número negativo é representado no complemento dos dois de seu valor absoluto, o resultado será muito grande após a mudança direita não assinada.
var OldValue = -64; var newValue = OldValue >>> 5; console.log (newValue) // 134217726
Para determinar a representação binária de -64, você deve primeiro obter a representação binária de 64, como mostrado abaixo:
0000 0000 0000 0000 0000 0000 0100 0000
Em seguida, calcule o código inverso binário da seguinte forma:
1111 1111 1111 1111 1111 1111 1111 1011 11111
Finalmente, adicione 1 ao código inverso binário, como mostrado abaixo
1111 1111 1111 1111 1111 1111 1111 1011 1111 1 ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Depois de mover 5 bits para a direita, como mostrado abaixo:
0000 0111 1111 1111 1111 1111 11111 11111 1110console.log (0B0000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
Aplicações comuns
【1】 Operação múltipla
Use o turno esquerdo (<<) para realizar a operação de multiplicação
console.log (2 << 1); // 4console.log (3 << 1); // 6console.log (4 << 1); // 8
【2】 Divida operação
Use o turno direito assinado (>>) para simular a operação do divisor de 2
console.log (2 >> 1); // 1console.log (5 >> 1); // 2console.log (8 >> 1); // 4console.log (9 >> 1); // 4console.log (9 >> 1); // 4
【3】 troca de valor
O efeito do intercâmbio de valor pode ser alcançado usando a operação XOR (^)
var a = 10, b = 9; a ^= b, b ^= a, a ^= b; console.log (a, b); // 9,10
【4】 Resuma o decimal
O efeito de arredondamento decimal pode ser alcançado tomando dois bits bit-bits, 0 bit ou 0 bit ou, 0 bits à esquerda e 0 bits à direita.
console.log (~~ 3.1); // 3console.log (3.1 | 0); // 3console.log (3.1^0); // 3console.log (3.1 << 0); // 3console.log (3.1 >> 0; // 3Console.log (3.1>> 0);
【5】 interruptor
O operador de bit pode ser usado como um comutador para definir propriedades de objeto. Suponha que um objeto tenha quatro interruptores, cada switch é uma variável. Em seguida, você pode definir um número binário de quatro bits, cada um dos quais corresponde a um interruptor.
var flag_a = 1; // 0001var Flag_b = 2; // 0010VAR Flag_C = 4; // 0100VAR Flag_D = 8; // 1000
O código acima define quatro comutadores A, B, C e D, cada comutador possui um bit binário, respectivamente.
Agora, suponha que os três interruptores ABD precisem ser ativados, podemos construir uma variável de máscara
var máscara = flag_a | Flag_b | Flag_d; // 0001 | 0010 | 1000 => 1011
O código acima executa "ou operação" em três variáveis abd para obter 1011 com um valor de máscara de binário
// "Operação" garante que o interruptor especificado seja ativado em sinalizadores = sinalizadores | máscara;
// "Associação" pode desativar todos os itens na configuração atual que são diferentes das configurações do Switch. sinalizadores = sinalizadores e máscara;
// "Exclusivo ou operação" pode alternar (alternar) a configuração atual, ou seja, o valor reverso da configuração atual pode ser obtido pela primeira vez, e o valor original pode ser obtido executando novamente. Sinalizadores = sinalizadores ^ máscara;
// "sem operação" pode girar a configuração atual, ou seja, a configuração original é 0 e se torna 1 após a operação; A configuração original é 1 e se torna 0 flags após a operação = ~ sinalizadores;
A introdução abrangente acima ao operador JavaScript - o operador de bit é o conteúdo inteiro compartilhado pelo editor. Espero que possa lhe dar uma referência e espero que você apoie mais o wulin.com.