нет, суть в том, что мы заменяем вычитание сложением. Например, рассматриваем 4-битные числа. 16 - это по сути ноль (10000b)

заменяем вычитание сложением: a - b = a + 16-b (16-b - дополнение до двойки)

почему же это все-таки работает или что-то типа алгебраического смысла? a + 16-b = 16 + a-b. Т.е. мы к нулю (16) прибавляем положительное (a>b) либо отрицательное (a<b) число и оставляем четыре младших бита результата. А все значения, которые принимает число - зациклены (посмотри на таблицу, вверх - сложение, вниз - вычитание)

а то, что есть альтернативный способ получения дополнения до двойки - это уже другой вопрос. Он делается через дополнение до единиц, а там в качестве точки отсчета выбрано на единицу меньше число. Поэтому сначала дополняем до единиц, а потом прибавляем еще одну единицу

Kolyaj, но мы же не про IEEE 754 разговариваем

Я сейчас бегло просмотрел (сегодня читать уже не буду, спать хочется) и насколько я понял там речь идет об общем 64-х разрядном представлении чисел в котором есть и +0 и -0, а в побитовых операциях числа представляются, насколько я понимаю, в 32-х разрядном знаковом целочисленном формате в котором есть только один ноль, завтра подробно прочитаю статью, может ошибся.

x-yuri,
спасибо за пояснения, завтра буду разбираться дальше, сейчас уже отрубаюсь, позже напишу о результатах :)

-------
update

Все, теперь разобрался! Вобщем смысл такой - мы представляем отрицательные числа в таком виде, чтобы заменить вычитание сложением, т.е. если первое число больше, то при сложении у нас будет переполнение, а значимые биты как раз дадут разность, а если отрицательное больше, то мы при сложении получим меньшее отрицательное число, т.к. положительного "не хватит" чтобы "переполнить". Ну и чтобы это все работало, отрицательные числа мы представляем в "обратном" порядке, начиная с -1 = 1111 (для 4-х разрядного числа), а т.к. у нас в данном случае (речь о побитовых операциях, а не о представлении типа number) нет отрицательного нуля, то чтобы получить отрицательное число мы применяем побитовое НЕ к такому же положительномц, при этом получаем отрицательное число по модулю на 1 больше начального, т.к. отрицательные числа начинаются с -1 а не с нуля и чтобы компенсировать это мы добавляем единицу.

x-yuri,
правильно я все понял-то? (:

да. Скажу только, что я бы назвал вариант перевода с помощью побитового НЕ и прибавления единицы - альтернативным. Основной - вычитание из степени двойки (10000b для 4-хразрядных чисел). А потом уже можно осознать, что побитовое НЕ - это вычитание из 1111b. Отсюда разница в единицу

Ясно, понял, спасибо за объяснения (:

Всем привет!Позвольте и мне вставить 5 копеек. Так же читаю Флэнагана и возник вопрос. Никак не могу разобрать метод call(). Прочел сдесь на сайте - так и не дошло. Первый аргумент как я понял ссылается на объект посредством которого будет выполнен метод. В данном случае атрибут принимает значение null, и объектом соответственно становится window.

function fx(x){return x+x;}
z = 1;
alert(fx.call(null, z));

Дык почему же он зараза не пашет в этом случае?:-/

function fx(x){return x+x;}
var q = {z: 100}
alert(fx.call(q, z));

как миниму, качестве аргумента вы передаете неправильно вызваное свойство объекта

alert(function(x){return x + x}.call(null, {a: 100})); //{a: 100} + {a: 100} - [object Object][object Object]

var x = {a: 100};
alert(function(x){return x.a + x.a}.call(null, x)); //200

alert(function(x){return x + x}.call(null, {a: 100}));// хм... такого синтаксиса не встречал. я про такой ввод {a: 100} непосредственно в аргумент.

Спасибо за ответ но не понял почему этот код не идентичен вышеизложенному.

function f(x){return x+x;}
windows.a =100;
alert(f.call(null,a));

Говорит нет свойства такого. А в вашем примере есть.


но как закодить без изменения функции

{return x + x}

. я имею ввиду без вызова свойства x.a в лоб?:blink:

В моем первом приеме оно работает но только как вызов свойства глобального объекта.

function fx(x){return x+x;}
z = 1;
alert(fx.call(null, z));

потому, что не windows, а window

alert(function(x){return x+x;}.call(null, this.a=100));
alert(function(x){return x+x;}.call(null, window.a=100));

:( мде... ну я и лопух))). с виндовсом как то резко вышло)))
Но все же так для ясности... просто функцию

function(x){return x+x;}

вызвать методом call посредством к примеру a.b = 100; нельзя?