Нормально, это связано с грамматикой языка.

typeof (11.4.3, ES-3) - это рекурсивное UnaryExpression.

UnaryExpression :
  [...]
  typeof UnaryExpression
  [...]

Т.е. можно написать так:

alert(typeof typeof []); // string

Также, UnaryExpression в одном из нетерминалов распадается на PostfixExpression:

UnaryExpression : 
  PostfixExpression
  [...]

Далее, нетерминал PostfixExpression может содержать LeftHandSideExpression:

PostfixExpression :
  LeftHandSideExpression
  [...]

который, в свою очередь одним из нетерминалов имеет CallExpression.

LeftHandSideExpression :
  [...]
  CallExpression

CallExpression имеет у себя MemberExpression.

CallExpression :
  MemberExpression Arguments
  [...]

MemberExpression может содержать PrimaryExpression:

MemberExpression :
  PrimaryExpression
  [...]

А уже PrimaryExpression (наконец-то ;)) одним из своих нетерминалов имеет Identifier:

PrimaryExpression :
  [...]
  Identifier
  [...]

А дальше, работает обычное разрешение идентификаторов в Scope chain (10.1.4). И в этом случае будет возвращён объект типа Reference с базой null и именем свойства - "X". Главное здесь - база null, поскольку далее отрабатывает пункт (3) алгоритма typeof:

3. If GetBase(Result(1)) is null, return "undefined".

В обоих случаях работает разрешение имени идентификатора. Во втором случае ищется имя "window" и дальше вызывается [[Get]] по имени свойства "addEventListener", во первом случае ищется имя "addEventListener" без дополнительных доступов к свойствам.

Просто анализируется цепь прототипов на получение значения свойства. Если свойства нет, вернётся undefined.

Анализируется цепь прототипов на наличие свойства. Данный случай предостерегает, если значение свойства будет false (проверка предыдущего примера не отработала бы).

Логика работы известна - выбирай ;)

Спасибо :)

Читать большой код может быть неудобно.

Начитался блин всяких style guide'ов и черновиков ECMAScript 5 :-E надо же всегда помнить про IE!

По новому стандарту ссылка arguments.callee не будет работать в "strict mode"; Решил попонтоваться и избавится он нее заранее следующим образом:

(function callee() {

    …

    if (…) {
        setTimeout(callee, …);
    }

}());

Но у нас же есть JScript, в котором такая функция будет видна и в текущем контексте исполнения:

(function callee() {});
alert(callee);

Ага, удобно значит дебажить, свойство name функции будет не пустой строкой, но в JScript этот OO_observe вывалится в глобальное пространство.

Вот и улучшили код)

Это ещё что! ;) Дальше - больше, JScript создаёт два объекта в этом случае:

var referenceToNFE = function testNFE() {
  alert('testNFE');
};
 
alert(referenceToNFE === testNFE); // false
 
referenceToNFE.newProperty = 10;
alert(testNFE.newProperty); // undefined
 
// однако, два объекта выполняют
// одинаковые действия
testNFE(); // "testNFE"
referenceToNFE(); // "testNFE"

Подробней.

А вот чем им, собственно, arguments.callee не угодил?

А чем им модель w3c не угодила Вот-вот. Её ведь в конце концов можно расширить и не превратив в модель Microsoft-а

Присоединяюсь к вопросу. Кому, собственно, мешает arguments.callee?

Назовёте некропостером... Но спрошу: почему в javascript используется чаще всего «египетский» стиль расставления фигурных скобок? Мне кажется читаемее (ну и слово) то есть читабельнее(ещё хуже) было бы как в Java/C/C++?

И если я пишу вот эдак:

function print(txt)
{
	document.write(txt,"<br>");
}

Это приемлемо?

Египетская сила =)

try
{
// Code
}
catch (e)
{
// Code
}

Так тоже читабельнее? Или так:

do
{
// Code
}
while ();

Имхо, код разрастается неоправдано.