Понимание побитового оператора JavaScript

Ответ 1

Я знаю, что Java использует два дополнения для представления отрицательных чисел, а 11111111111111111111111111111110 в двоичном формате, что дает ~ 1, представляет -2. Или, представленный в двоичном формате с отрицательным знаком, -10, это то, что вы получили.

То, как вы вычисляете отрицательный результат 10 (в базе 2) с использованием двух дополнений, состоит в том, что вы сначала инвертируете все бит, предоставляя вам:

11111111111111111111111111111101

то вы добавляете 1, давая вам:

11111111111111111111111111111110

Я думаю, что то же самое происходит в Javascript.

Ответ 2

Вы можете использовать оператор сдвига → > для преобразования числа в целое число без знака перед преобразованием в двоичный файл:

(~1 >>> 0).toString(2) // "11111111111111111111111111111110"

Ответ 3

Краткий ответ:

• Побитовое NOT (~1) выполняет 1 дополнение преобразования десятичной, что дает нам -2
• Функция .toString() в основном принимает десятичное значение без знака 2, преобразует его в двоичный 10 и добавляет знак -, который дает нам -10.

Более подробный ответ:

В функции .toString(). Когда вы выводите число через .toString():

Если numObj отрицательный, знак сохраняется. В этом случае даже если радиус равен 2; возвращаемая строка является положительным двоичным представление numObj, которому предшествует знак a, а не два дополнение numObj.

Взято из developer.mozilla.org, мы получили эту формулу, которая вычисляет 1 дополнение целого числа, это используется, когда вы выполняете NOT ( ~) по десятичной дроби:

Побитовое указание любого числа x дает - (x + 1). Например, ~ 5 дает -6.

Возможно, это объясняется с этой таблицей и примером:

+-------------------------+-----+-----+-----+-----+-----+-----+------+
| Base 10 Integer         | -3  | -2  | -1  | 0   | 1   | 2   | 3    |
+-------------------------+-----+-----+-----+-----+-----+-----+------+
| Base 10 1 Complement  |  2  |  1  |  0  | -1  | -2  | -3  | -4   |
+-------------------------+-----+-----+-----+-----+-----+-----+------+
| Base 2                  |     |     |     | 0   |  1  |  10 |  11  |
+-------------------------+-----+-----+-----+-----+-----+-----+------+
| Result ~x.toString(2)   | 10  |  1  |  0  | -1  | -10 | -11 | -100 |
+-------------------------+-----+-----+-----+-----+-----+-----+------+

• Начиная с Base 10 integer "2"
• Base 10 integer "2" его 1 "Дополнение" - "-3". Это то же самое, что выполнение NOT (~)
• .toString принимает значение unsigned (= "3" в базе 10 и = "11" в базе 2)
• .toString добавляет символ "-"
• .toString выводит "-11"

Ответ 4

Это предполагает, что вы работаете в 32 битах...

var valueToNot = parseInt("11110000", 2);
var notResult = 0xFFFFFFFF - valueToNot;
console.log(notResult.toString(2));

приводит к 11111111111111111111111100001111

Ответ 5

Вот решение реализовать НЕ в javascript. Это не очень, но это работает.

// Since ~ is the two complement, then the one complement is ~(num -1).
var num = 9;
num.toString(2);            //returns 1001
~(num - 1).toString(2);    //returns -1001
// WHAT the hell?? I guess the negative sign acts as a sign bit.

Если вы хотите просмотреть двоичную строку десятичного разряда после NOT (бит Toggle), используйте следующий код.

// Programer: Larry Battle
// Purpose: Provide a bit toggle function for javascript.
var getStrCopy = function (str, copies) {
    var newStr = str;
    copies = (copies > 0) ? copies : 1;
    while (--copies) {
        newStr += str;
    }
    return newStr;
};
var convertDecToBase = function ( dec, base, length, padding ) {
    padding = padding || '0' ;
    var num = dec.toString( base );
    length = length || num.length;
    if (num.length !== length) {
        if (num.length > length) {
            throw new Error("convertDecToBase(): num(" + num + ") > length(" + length + ") too long.");
        }
        num = getStrCopy( padding, (length - num.length)) + num;
    }
    return num;
};
var formatBinaryStr = function( str ){
    return str.replace( /\d{4}/g, '$& ' ).replace( /\s$/,'');
};
var toggleBits = function( dec, length, doFormat ){
    length = length || 8;
    var str = convertDecToBase( dec, 2, length || 8 );
    var binaryStr = str.replace( /0/g, 'o' ).replace( /1/g, '0').replace( /o/g, '1' );
    return ( doFormat ) ? formatBinaryStr( binaryStr ) : binaryStr ;
};

// The following requires Firebug or Google Chrome Dev Tools
clear();
console.log( toggleBits( 1 ) );    // returns "11111110"
console.log( toggleBits( 2 ) );    // returns "11111101"
console.log( toggleBits( 50, 16 ) );// returns "1111111111001101"
console.log( toggleBits( 15, 8, true ) );    // returns "1111 0000"
console.log( toggleBits( 520, 16, true ) ); //returns "1111 1101 1111 0111"