тировать

С учетомответ ниже относительно ссылкиСпецификация языка ECMAScript - 11.13.2 Назначение соединений

Учитывая, почему это,

javascript:
   o="";  o = o + (o+=1)    ; alert(o);
   o="";  o =     (o+=1) + o; alert(o);

НЕ одинаковы. Существуют временные семантические проблемы с оценкой сценария слева направо (ссылка:ECMA спец. - оператор сложения). Одним из следствий является то, что+ Оператор не обязательно коммутативный.

Это также можно увидеть с помощью:

javascript:
   o=1;  o = o + (o+=1)    ; alert(o);
   o=1;  o =     (o+=1) + o; alert(o);

или же

javascript:
   o=" _ ";  o = o + (o+=1)    ; alert(o);
   o=" _ ";  o =     (o+=1) + o; alert(o);

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

Оригинальный пост

Следующие соображения, возможно, уже были учтены, хотя, похоже, нет. Если да, можно ли предоставить ссылки на обсуждения?

Формальная денотационная семантика движка Gecko Javascript является загадкой. Эмпирические испытания утомительны и не могут быть исчерпывающими.

Имеется ли официальная официальная спецификация или официальная ссылка, определяющая, как именно Gecko интерпретирует Javascript?

Ссылка,Спецификация языка ECMAScript, кажется неадекватным, хотя для создания таких сценариев, как,

javascript: alert( function(){return {}}().life=42 )

с последующим значением таких конструкций при связывании значений.

Существует ли определенная парадигма, описывающая интерпретацию кода Javascript для оценки объекта и экземпляра?

Это позволило бы прояснить концепцию вызова по (или, скорее, по использованию) потребностью, ценностью, ссылкой, умозаключением, именем, ... как уместно или нет. Это, Javascript - это интерпретатор прототипов, придающий неявное значение некоторым из нижеприведенных проблем.

Каков ожидаемый результат:

javascript: o={n:0}; f=function(){o.n+=1; return 10};
   alert([
      o.n,            f(),
      o.n,       o.n+=f(),
      o.n, eval('o.n+=f()'), 
      o.n, eval('o.n+='+f()),
      o.n,
   ].join(",\t"));

? Легко ли предсказать результаты (правильно!)?

Вопрос немного риторический, так как он был специально придуманevalНужно привести и подчеркнуть тонкие нюансы интерпретации. Можно ли выполнить оценку этого сценария (и приведенную ниже) с помощьюСпецификация языка ECMAScript или другой документ, упоминавшийся ранее?

(В сторону, рассмотрим:

javascript: ra=[];
   alert([
      ra, ra[ra.length]=" partially defined.",
      ra, ra.push("\n RA is not shown"),
      ra, ra.reverse()[42],
   ].join(",\t\t"));

который отображает:

 RA is not shown, partially defined.,        partially defined.,        
 RA is not shown, partially defined.,       2,      
 RA is not shown, partially defined.,       

где частичные оценкиra НЕ аналогичныo.n«S!

и следующее, что менее экзотично, чем использование o.n:

javascript: o=""; f=function(){o+=1; return 0};
   alert([
      o,          f(),
      o,       o+=f(),
      o, eval('o+=f()'), 
      o, eval('o+='+f()),
      o,
   ].join(",\t"));

который отображает:

,   0,  1,  10, 10, 100,    100,    10010,  10010

)

Учитывая следующий сценарий:

javascript:
   asn="\t\t and so now,\t o.n is "; nl="\n\n";
   o={}; f=function(){o.n+=1; return 10};
   alert(["Using:\n",window.navigator.userAgent,
   nl,"The function f() is:\n ",f,
   nl,"What the!!?!? \t\t\t\t\t\t\t initially \t\t o.n is ",          o.n = 0,
 nl,"Called as a procedure: \t\tf() is ", f(),                   asn, o.n,
nl,"but, instead of 12 \t\to.n+=f() is ", o.n+=f(),              asn, o.n,
     nl,"however eval'd\t\to.n+=f() is ", eval("o.n+="+f()),     asn, o.n,
    "!\n\nIt makes no functional difference if, instead of o.n, o['n'] is used.",
    "\nThe expected o.n evaluation sequence is 0, 1, (+1+10=) 12, (+1+10=) 23.",
    "\n_____ _____ _____ _____ _____ _____ _____ _____^^ missing in result",
  ].join(""));

Выходы двигателя Gecko:

Using:
Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.2.3)
        Gecko/20100423 Ubuntu/10.04 (lucid) Firefox/3.6.3

The function f() is:
 function () {
    o.n += 1;
    return 10;
}

What the!!?!?                                initially       o.n is 0

Called as a procedure:      f() is 10        and so now,     o.n is 1

but, instead of 12      o.n+=f() is 11       and so now,     o.n is 11

however eval'd          o.n+=f() is 22       and so now,     o.n is 22!

It makes no functional difference if, instead of o.n, o['n'] is used.
The expected o.n evaluation sequence is 0, 1, (+1+10=) 12, (+1+10=) 23.
_____ _____ _____ _____ _____ _____ _____ _____^^ missing in result