JS:передача по ссылке и по значению.

Если вы из скрипта, изменив его, не понимаете "что происходит", то вам катастрофически не достаёт некоторых  знаний...
Даю наводку: изучите понятие контекста.
А в рамках контекста - передачу ссылок на переменные и объекты (+ особенность js  в этом плане), именование переменных.

P.S.:
Фраза "определение объекта y с параметром а со значением 1" неверна в корне.
Верно будет: объявление переменной "y" в текущем контексте, создание объекта со свойством "a" со значением "1", присвоение переменной "y" ссылки на этот объект.

В первом случае объявлена локальная в контексте функции переменная с именем "y" (вкратце, ей присваивается значение первого аргумента при вызове функции), которая ничего общего с "глобальной" переменной с именем "y" не имеет. Ей присваивается ссылка на новый объект со свойствами "a" и "b". Эта переменная существует только в локальном контексте функции.
Во втором случае в контексте функции нет объявления переменной с именем "y", поэтому осуществляется обращение к более вышестоящему контексту, где уже есть такая переменная. Ей присваивается ссылка на новый объект.

Ссылки: http://www.google.ru/search?q=%D0%BA%D0 … javascript
Особенно: http://javascript.ru/ecma/part10 и, вообще, все статьи и учебник...

Если я правильно понял что ожидается, то должно быть так:

function f(y)
{
   y.a = 100;
   y.b = 100;        
};

var y = {a:1};

WScript.Echo("#1: у.а=" + y.a + " у.b=" + y.b);

f(y);

WScript.Echo("#2: у.а=" + y.a + " у.b=" + y.b);

или

function f(arg0)
{
   arg0.a = 100;
   arg0.b = 100;        
};

var y = {a:1};

WScript.Echo("#1: у.а=" + y.a + " у.b=" + y.b);

f(y);

WScript.Echo("#2: у.а=" + y.a + " у.b=" + y.b);

Оба ваших примера никаких сомнений и возражений не вызывают, вопрос не в этом....
вот смотрите:

function f(h)
    {
       y = {a:100, b:100};        
    };

f();                         // вызываю ф-ю без всяких параметров, объект ссылка на который хранится в переменной y, не 
                              //  только "будет создан", но и доступен за пределами ф-ции, т.к. он относиться к
                              // "глобальному контексту" (объявлен без var!)

WScript.Echo(y.a + "----" + y.b);                 // увидим 100 ---- 1000

изменим:

function f(h)
    {
       var y = {a:100, b:100};        
    };

f();                         // вызываю ф-ю без всяких параметров, объект ссылка на который хранится в переменной y, 
                              // "будет создан", но НЕ доступен за пределами ф-ции, т.к. он относиться к 
                              // "локальнлму контексту" объявлен с var

WScript.Echo(y.a + "----" + y.b);                 // увидим ошибку выполнения, т.к.  никакого у здесь не существует 

как вытащить такой объект "локального контекста"?:

function f(h)
    {
      var y = {a:100, b:100}; 
      return y;       
    };

r = f();                                  // результат вызова ф-ции (а это ссылка на объект) записана в r

WScript.Echo(r.a + "----" + r.b);  // увидим 100 ---- 1000

во всех этих примерах (хоть интуитивно), но понятно как ведёт себя интерпретатор JS...

изменю в примере 1:

function f(y)                    // вот здесь НЕ ПОНЯТНО
    {
       y = {a:100, b:100};        
    };

f();             
WScript.Echo(y.a + "----" + y.b);          // выдаст ошибку      

что делает интерпретатор при выполнении вышеуказанного кода, кто знает объясните "по-пунктам" .

Вы затрагиваете очень интересные темы, которые не возможно описать в два-три предложения. Есть желание рассказать, но нет желания много печатать. Все-таки поищите хорошие учебники по языку. Хотя бы онлайн. Хотя бы на javascript.ru почитайте. Там все доходчиво.

// объявлена функция с одним аргументом
function f(y)
{
    // мы в праве сделать что-то с ЭТИМ АРГУМЕНТОМ (не переменной!)
    y = {a:100, b:100};
};

// явно вызвали функцию, но ничего не передали
// Тоже имеем право - ничего не передавать в функцию
f();

// нет переменной, получаем ошибку
WScript.Echo(y.a + "----" + y.b);

Очень хороший и показательный пример, почему надо читать учебник.

Есть переменная - объект y, есть функция f, которой эту переменную передали. Так как переменная - объект, то передается она по ссылке (!!!). И, предполагается, что ее (переменную) можно изменить.

Но!!! Внутри функции создается новый объект, ссылка на который назначается аргументу функции. В результате ссылка на оригинальный объект внутри функции потеряна. Так как это происходит только внутри функции и "ломается" только ссылка на внешний объект, то внешняя программа просто печатает не измененный оригинал.

Чтобы изменить свойства внешнего объекта изнутри функции используйте точечную или скобочную нотацию явно для каждого свойства объекта.

Rumata, прочти то что ты написал как бы "отстранёно", и "увидь", пожалуйста, всю смысловую абсурдность этого предложения с точки зрения точных значений понятий и русского языка.

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

"Есть переменная - объект y", - переменная содержит, ссылается (может "обозначает") объект, она не может "быть" объектом.

"которой эту переменную передали", - переменную в js "передать" невозможно, можно передать значение, объект.

"Так как переменная - объект, то передается она по ссылке", - переменная не может быть объектом, она "переменная" и ссылается на объект. Передать переменную в js "по ссылке" невозможно.

"И, предполагается, что ее (переменную) можно изменить", - переменная не передаётся в js "по ссылке", и её невозможно "изменить", передаётся объект (на который ссылалась переменная), его можно изменить.

Rumata корректнее наверное была бы в цвете дискуссии такая запись ?
(хотя результат тот же)

function f(x)
{
    x.a = 1;
};

var o = {};
f(o);
WScript.Echo(o.a);

"Спасибо", меня впервые обозвали "грамма-наци".

У меня "разрыв шаблона". Я то думал, что исходный код интерпретируется/компилируется/исполняется в соответствии со спецификацией. А он оказывается "истолковывается". Спасибо, я это запомню и возьму на вооружение ;-)

function f(o)
{
    o.a = 1;
};

var o = {};
f(o);
WScript.Echo(o.a);

Распарсен/проанализирован/скомпилирован я буду называть "обработан".

Если вкратце, то:

0. Обработан текст скрипта.
1. В текущем контексте объявлена именованная функция "f" ("скрытая" переменная),
2.0. Её код также обработан.
2.1. Объявлена в контексте функции переменная "o".
2.2. Подготовлен код для исполнения.
3. В текущем контексте объявлена переменная "o".
4. Подготовлен код для исполнения.
5. Исполнение...
6. Создан объект.
7. Переменной (текущего контекста) "o" присвоена ссылка на этот объект.
8. Из переменной (текущего контекста) "f" получена ссылка на функцию.
9. Из переменной (текущего контекста) "o" получена ссылка на объект.
10. Во внутренней структуре функции, хранящей массив переданных аргументов, по индексу [0] записана ссылка на объект.
11. Вызов функции, создан новый контекст исполнения.
12.0. В контекст функции.
12.1. Переменной (в контексте функции) "o" присвоено значение по индексу [0] из массива аргументов.
12.2. Из переменной (в контексте функции) "o" получена ссылка на объект.
12.3. Создание/запрос у объекта свойства с именем "a".
12.4. Запись значения свойства...
12.5. Выход из функции, "разрушение" контекста.
13. Возврат в вышестоящий контекст.
14. ... получена ссылка на функцию из WScript.Echo ...
(в данном случае условно, так как здесь вызов через ActiveX/IDispatch)
15. Из переменной (текущего контекста) "o" получена ссылка на объект.
16. По ссылке на объект ... получено значение свойства с именем "a".
17. Во внутренней структуре функции, хранящей массив переданных аргументов, по индексу [0] записано число 1.
18. Вызов функции...
19. и т. д.

Никак этого не должно быть. Переменная — это ящик. Глобальная переменная — один ящик, параметр функции — другой ящик, даже если у них одно и то же имя. При передаче в функцию вы берёте вещь из одного ящика, делаете её копию и кладёте в другой, так она попадает в функцию. Если там вы её выкинете и положите в ящик-параметр что-то другое, то как это скажется на глобальном ящике? Никак. Там что лежало, то и будет лежать.

В случае "передачи объекта" делается копия ссылки, сам объект не копируется. По ссылке объект можно изменить, и эти изменения будут видны и снаружи, т.к. объект один и тот же.

Немного подправил

function f(y_link)
    {
//Не правильно теряеем ссылку на объект
//y_link = {a:100, b:100};

 // мы в праве сделать что-то со свойствами   Объекта y
        y_link.a=100
        y_link.b=100
    };
 
var y = {a:1};             // определение объекта y с параметром а со значением 1
f(y);                            // вызов функции 
WScript.Echo("Параметр у.а = " + y.a + "\nПараметр у.b = " + y.b);   

Тот кусок, который вы разбираете далее "составил" не я, а уважаемый Rumata, просто такое толкование было наиболее близко "моему пониманию", вот я и сослался... .
Что касается ваших замечаний. По поводу действий интерпретатора, которые вы изложили в п. 0-19, было много непоняток и вопросов,  просто обсуждать не стал, тема простая, и так раздута, чтоб "не засорять" так сказать. Что касается замечаний в вашем последнем комментарии, которые "с заглавной буквы" вот смотрите, что получается:

Согласно изложенному вами:

function f(y)
    {
/* 
что происходит, после вызова ф-ии, с параметром как указано ниже? в локальную переменную у записывается
аргумент с индексом [0]. что это за аргумент? это ссылка на массив {a:1}, т.е. в нашей ф-ции как бы появилась 
запись y = {a:1}; затем по контексту имеется запись:  y = {a:100, b:100};  что произойдёт? переменная у 
потеряет ссылку на объект {a:1}, а вместо этого "приобретёт" ссылку на объект {a:100, b:100}. 
казалось бы WScript.Echo должна показать результат 100 и 100... ан нет! показывает 1 и underfined! 
почему?! да переменная y внутри ф-ции локальная (с чего и начинался разбор), за пределами ф-ции "не видна", 
там другая, своя у есть! почему локальная где var? не нужно var, сам JS "так устроен"
*/
        y = {a:100, b:100};        
    };
var y = {a:1};    
f(y);                            // вызов функции 
WScript.Echo("Параметр у.а = " + y.a + "\nПараметр у.b = " + y.b);   

Вот как-то так получается, согласен, что такое не очевидное  допущение (что у локальная)  выглядит более
"привлекательно", чем моё объяснение {a:1} = {a:100, b:100}!!! .
Всем спасибо. Тема закрыта, вопросов больше нет!

хотел оставить тему "в покое", но не удержался! .

function f(y)
    {
    y.a = 100, y.b = 100;        
/*
определить в объекте у свойства а и b с указанными значениями, если конечно такой объект
существует
*/
         };
 
var y = {a:1};                // запись ссылки на объект в перем. у
 

f(y);                            // вызов функции, передача в ф-ю ссылки на объект
 
WScript.Echo("Значения ПОСЛЕ применения функции:\n" + "Параметр у.а = " + y.a + "\n" + "Параметр у.b = " + y.b);
                    /* 
                    что происходит в процессе выполнения ф-ии согласно max 7:
                    1. внутри функции создана переменная у со значением arguments[0] (var y = arguments[0]);
                    2. переменная y получает ссылку, на объект, переданный ф-ции при вызове: var y = {a:1};
                    3. т.к. объект существует, св-во "а" принимает значение "100", добавляется св-во "b" , 
                                            также со значением "100".
                    4. поскольку у "локальная переменная", её значение - ссылка на объект {a:100, b:100} 
                                            будет актуальна       только в пределах данной функции.
                    5. инструкция WScript.Echo вернёт результат "1" и "underfined", т.е. те значения для 
                                            объекта а, которые определены вне пределов функции f
                    */

однако "непослушная" WScript.Echo возвращает 100 и 100. .
Всё, теперь точно закрыта тема.

2max7: коллега, спокойнее, пожалуйста.

Вопрос: Как это может привести к "путанице", если всё выше написанное тебе понятно?