Какова семантика движка Geavo для интерпретатора Javascript?

Question

редактировать

Принимая во внимание ответный ответ ниже относительно справочной спецификации языка 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 Language Specification, кажется неадекватной, хотя для создания таких сценариев, как:

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 не показан, частично определен, частично определен,        
 РА не показан, частично определен.,       2,      
 РА не показан, частично определен.,       

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

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

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:

С помощью:
Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.2.3)
        Gecko/20100423 Ubuntu/10.04 (lucid) Firefox/3.6.3

Функция f() имеет вид:
 function () {
    на += 1;
    возврат 10;
}

Что за!!?!? изначально на 0

Вызывается как процедура:      f() равно 10 и теперь 1

но вместо 12      o.n+=f() равен 11, и теперь он равен 11

однако eval'd          o.n+=f() равен 22, и теперь он равен 22!

Это не делает функциональной разницы, если вместо on используется o['n'].
Ожидаемая последовательность оценки составляет 0, 1, (+1+10=) 12, (+1+10=) 23.
_____ _____ _____ _____ _____ _____ _____ _____^^ отсутствует в результате

Answer 1

В JavaScript есть модель исполнения с высокой степенью оценки (вызов по значению), четко изложенная в стандарте ECMA. Все эти вопросы могут быть решены путем тщательного прочтения стандарта. Например, причина, по которой результат равен 11 выше, а не 12, четко изложена в 11.13.2 стандарта. on оценивается до вызова функции f(), а не после, как указано в шаге 2.