Понимание JavaScript побитового оператора НЕ и функции toString ()

Question

Спасибо всем заранее -

alert((~1).toString(2));

выходы: -10

Но в PHP / Java он выводит 11111111111111111111111111111110

Я что-то упустил, почему Javascript добавляет "-" к выводу?

Thx, Sam

Answer 1

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

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

Answer 2

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

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

11111111111111111111111111111101

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

11111111111111111111111111111110

Полагаю, то же самое происходит в Javascript.

Answer 3

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

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

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

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

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

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

Побитовое ЗАМЕЧАНИЕ любого числа x дает - (x + 1). Например, ~ 5 дает -6.

Может быть, лучше объяснить с помощью этой таблицы и примера:

+-------------------------+-----+-----+-----+-----+-----+-----+------+
| Base 10 Integer         | -3  | -2  | -1  | 0   | 1   | 2   | 3    |
+-------------------------+-----+-----+-----+-----+-----+-----+------+
| Base 10 1's 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 |
+-------------------------+-----+-----+-----+-----+-----+-----+------+

1. Начиная с целого числа 10 "2"
2. Основание 10, целое число "2", его дополнение к 1 равно "-3". Это то же самое, что выполнить NOT (~)
3. .toString функция принимает значение без знака (= "3" в базе 10 и = "11" в базе 2)
4. .toString функция добавляет символ "-"
5. .toString выводит "-11"

Answer 4

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

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

результатов в 11111111111111111111111100001111

Answer 5

Вот решение для реализации НЕ в JavaScript. Это не красиво, но работает.

// Since ~ is the two's complement, then the one's 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 (переключение битов), используйте следующий код.

// 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"