" вставляется элемент глобальной (в данном scope)
// переменной arr"

Вот вы и нашли глобальную переменную...

Нашли???

Если смущает str - убери её из обоих тестов...
Оставь только a и arr.
Ну тогда уж точно будет видно, где локальная, где глобальная...

просто во втором тесте тогда нибудет никаких действий в функции: почему? - потому что я ВЫНЕС её инициализацию в глобальный контекст!!!

Прочтите, пожалуйста, пост №11

И скажите - я ответил правильно?

Разве у меня в функции не идёт ОБРАЩЕНИЕ к глобальной переменной?

ZoNT,
Ваш пример наглядно показывает только то, что

array.push(element);

работает медленнее, чем

array[index];

У вас в первом примере используются только локальные переменные, а во втором - две локальные переменные (в своих контекстах), а вторая просто вставляет элемент глобальной.

Локальные переменные работают быстрее в любом контектсте.
Вот два идентичных примера, проверьте самостоятельно:

// Пример с локальной переменной:
function F1(){
    var a = [];
    for (var i=0;i<1000;i++) a.push(i);
}
 
var start = new Date();
for (var i=0;i<1000;i++) F1();
var res1 = (new Date())-start;


// Пример с глобальной переменной:
function F2(){
    for (var i=0;i<1000;i++) b.push(i);
}
 
start = new Date();
for (var i=0;i<1000;i++) {
    var b = [];
    F2();
}
var res2 = (new Date())-start;
 
alert([res1,res2]);

Ну ответь же мне:
1) мой пример работает?
2) Он на мониторе виден (в смысле существует)?
3) Работает быстрее?
4) "а вторая просто вставляет элемент глобальной" - к глобальной переменной обращается?

ZoNT,
Вы увиливаете от ответа и упорствуете в ошибке.
Ваш пример на самом деле абсурден насколько же, насколько вот такой:

function F1(){
    var a = [];
    for (var i=0;i<1000;i++) a.push(i);
}
 
var start = new Date();
for (var i=0;i<1000;i++) F1();
var res1 = (new Date())-start;
 
var b = [];
for (var i=0;i<1000;i++) b.push(i);

function F2(){
    b[i];
}
 
start = new Date();
for (var i=0;i<1000;i++) { F2(); }
var res2 = (new Date())-start;
 
alert([res1,res2]);

Я не спорю, что использование глобальных переменных ускоряет выполнение некоторых конкретных задач. Но в только в общем плане, например использование одного массива несколькими функциями и т.д. Но в каждой конкретной функции вариант с локальными переменными будет работать быстрее. Вот, например:

// Пример с глобальной переменной:
function F1(){
    for (var i=0;i<1000;i++) a.push(i);
}

var start = new Date();
for (var i=0;i<1000;i++) {
    var a = [];
    F1();
};
var res1 = (new Date())-start;
 
 
// Пример с глобальной и локальной переменной:
function F2(){
    var arr = b;
    for (var i=0;i<1000;i++) arr.push(i);
}
 
start = new Date();
for (var i=0;i<1000;i++) {
    var b = [];
    F2();
}
var res2 = (new Date())-start;
 
alert([res1,res2]);

ВОТ!!!

Вот это я и сказал (если прочтесть ветку сначала).

Я привёл конкретную задачу, когда в таблице массивы определялись В ФУНКЦИИ (они были локальными).
Я предложил их определние вынести в глобальный контекст (точно такой пример я и привёл).

Я не прав?

Не в каждой!!! И пример я привёл в какой не будет. И топикстартер так делает и ещё куча новичков!!!

ZoNT,
Попробуйте выполнить код из сообщения #47. Он наглядно показывает, что обработка локальных переменных (работа с ними) происходит быстрее в любом конкретном случае.

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

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

Ну вы же видите пример, где НЕ ВСЕГДА локальные переменные быстрее...

И вот из-за ваших с Дмитрием утверждений люди (как топикстартер) в заблуждении пишут вот такую лабуду...

ZoNT,
Не всегда работают быстрее чего? Вы понимаете, что для сравнение "быстрее чего работают глобальные переменные" вы подобрали некорректный пример?

Вообще, глобальные и локальные переменные используют не потому что одни быстрее других. Просто в разных случаях используются разные подходы. Естественно, что если функция внутри себя каждый раз объявляет одинаковый огромный массив, то это неверно и лучше хранить массив глобально. Тогда будет быстрее работать вызов этой функции. Я не спорю с этим и вы абсолютно правы на этот счет. Тем не менее, работа (изменение, добавление элементов, удаление элементов и т.д.) с локальными переменными происходит быстрее, чем с глобальными.

Я этого и не говорил!!!

Вот кусок поста:
"Сообщение от ZoNT:
Быстрее, в некоторых случаях.

Dmitry A. Soshnikov: Во всех случаях."

Разве я не написал топикстартеру, что:
"В данном же случае приходится в функции каждый раз создавать огромный массив. Соответсвенно создать используемые данные всегда лучше 1 раз..."

Ключевые слова: "В данном же случае..."

Случай есть? Есть!
Я его написал? Не я...

"Dmitry A. Soshnikov: Во всех случаях." == false,
так как этот "Случай есть? Есть!"

ZoNT,
Мы с вами как глухой со слепым разговариваем. Я вам говорю, что функция будет быстрее работать с локальной переменной, чем с глобальной. А вы мне отвечаете, что функция, которая объявляет в себе огромный локальный массив будет работать медленнее, чем функция работающая с огромным глобальным массивом. Это очевидно. Но с локальной ссылкой на глобальный массив будет работать еще быстрее. Потому что работа с локальными переменными будет быстрее, чем с глобальными.

Это тебе очевидно!!!

Но форум не твой личный!!!

На него заходят нубы и задают вопросы. И им надо разжовывать.
Понимаешь?

И утверждение "всегда быстрее", как видишь, неверно. Это очевидно...

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

И я в 19(20) лет был таким :) как Андрей (Dmitry)

ZoNT,
Я рад тому, что вы переросли меня. Я признаю, что ваша точка зрения - правильная. Точка зрения, что в конкретном случае скрипт будет быстрее работать, если функции будут использовать глобальные переменные. Тем не менее, формулировка "код функции всегда работает быстрее с локальными переменными, чем с глобальными" абсолютно верна.

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

А что под ним понимают другие люди, которые не понимают даже как устроен компьютер? Это знают только сами люди...

Надо уметь чётко формулировать не только вопросы, но и ответы. Иначе человек, котрому ты ответил поймёт в меру своей образованности.

Сформулируй так, чтобы нельзя было понять иначе (только одно толкование), тогда будешь прав...

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

Вот так намного лучше!
Если бы эту формулировку топикстартер услышал раньше (а не "всегда быстрее"), он бы такой код не написал бы, и вопрос бы не задал...

Андрей Параничев, да, я сразу не заметил, но ZoNT, возможно, просто не знаком с контекстами и не видит, что глобальная переменная для объекта Global (в браузере Global === window) будет (относительно scope'a) играть такую роль же, как локальная переменная в функции. Поэтому, чтобы проводить опыты, чтобы эмпирически подтверждать теорию, надо конкретно, однозначно определить - какие переменные (какого скопа) участвуют в тестах.

ZoNT, разжевываю:

var a = 10; - глобальная переменная
alert(window['a']); // это свойство объекта Global (window)

function test() {
  var c = 20; - локальная переменная
  alert([c, a]);
}

Переменная "c" стала свойством объекта variable object (10.1.3) - этот объект имеется у каждой функции и хранит все локальные переменные, все формальные параметры, а также все декларации функций. Т.е. в нашем случае variable object (далее для сокращения - VO) функции "test" имеет одно свойство "c". Схематично отобразим так:

VO(test) = {c: 20};

Далее, мы видим alert([c, a]);. Спрашивается, откуда выдается "20,10", если VO(test) не имеет у себя свойства "а"? А дело в scope chain'e (10.1.4) - цепи скопов (variable object'ов, начиная от VO функции и вверх до родительских скопов), которые хранит функция. Это еще один объект (хранится во внутреннем свойстве [[scope]]), который ассоциирован с каждой функцией. Т.е. схематически [[scope]] функции test будет таким:

[[scope]](test) = {
  VO(Global): {
    a: 10
  },
  VO(test): {
    c: 20;
  }
};

А далее - самое интересное (опять же - смотреть в 10.1.4). При обращении к переменной внутри функции она ищется в скоп-чейне последовательно вверх, начиная от VO самой функции. Все. Больше никаких чудес нет.

Поэтому ясно видно, что: alert(c); сработает быстрее, т.к. свойство "c" будет сразу же найдено в первом просматриваемом скопе.

Что же касается alert(a):

- смотрим в VO(test); - не нашли;
- смотрим в VO(Global) - нашли.

Два действия против одного (поиск в двух скопах (обращение к глобальной переменной) против моментального нахождения в первом скопе (обращение к локальной переменной)). Есть разница? Ну вот и замечательно.

Поэтому, еще раз - обращение из абстрактного локального скопа к глобальной переменной всегда (всегда!) будет медленней, чем обращение к локальной. Точка.

P.S.: VO(Global) - это утрированно, на самом деле сам Global уже является variable object'ом для глобальных переменных.

P.S.[2]: еще раз (уже зная теорию) смотрите результаты своего же примера:

<html>
<body>
<script type="text/javascript">

// local var
function F1(){
  var arr = [];
  // здесь идет обращение к *локальной* переменной
  // arr
  for (var i=0;i<1000;i++) arr.push(i);
}

var start = new Date();
for (var i=0;i<1000;i++) F1();
var res1 = (new Date())-start;
//**********************************


// Global var

function F2(){
  for (var i=0;i<1000;i++) arr.push(i);
}

var start = new Date();
var arr = [];
for (var i=0;i<1000;i++) F2();
var res2 = (new Date())-start;

// test 3

var start = new Date();
var arr2 = [];
for (var i=0;i<1000;i++) {
  for (var k=0;k<1000;k++) arr.push(k);
}
var res3 = (new Date())-start;

//**********************************


alert([res1, res2, res3]);

</script>
</body>
</html>

P.S.[3]: ZoNT, я пока закрываю глаза на все твои переходы на личности (в надежде, что мои подробные разъяснения помогут тебе более детально понять, как работает JavaScript), но это последнее предупреждение. Общаться - давай общаться, но рассуждать тут о нубстве и о возрастах, когда ты сам не далеко ушел от нубства в данном конкретном вопросе - это излишне.

P.S.[4]: а по поводу выделения памяти каждый раз (вместо уже существующей - не важно - в глобальном контексте, или же в прототипе конструктора, как я отмечал) - это уже другой вопрос совсем. И не зачем подменять понятия, говоря, что работает быстрее - "обращение к локальной или глобальной переменной?". Я и сам отметил (о хранении однотипного объекта в одном месте).

Dmitry A. Soshnikov,
На самом деле тут все просто. Ты говоришь: код функции будет всегда быстрее работать с локальной переменной, чем с глобальной. Это очевидно. Он говорит: не любой скрипт, где неоднократно вызывается функция использующая локальные переменные, будет работать быстрее, чем тот, в котором функция использует глобальные переменные. И приводит в пример код топикстартера. Тут чисто дурацкие придирки к формулировкам.

Тем не менее на вопрос
ответ: да, сама функция всегда будет работать быстрее. Но если в скрипте она запускается много раз, а в себе инициализирует огромные массивы, то этот скрипт будет работать медленнее, чем тот, в котором столько же раз запускается функция, работающая с один раз глобально инициализированным огромным массивом.

Спасибо за познавательную дискуссию!
Изначально я делал переменные для многократно вызываемых функций глобальными, потом решил посмотреть, что будет в случае локальных.
Так вот, во втором случае в ФФ и Опере тормозить стало меньше, ну а ИЕ - по барабану.
Дело, наверно, в том, что функция обращается к переменным не 1 раз, а 4

функция F1 работает медленне (с локальной переменной а) чем F2, так как ей приходится инициализировать свою переменную локально...

Никаких "скрипт".

ZoNT, ну так и надо говорить о работе каких-то там функций, а не об "обращении к локальным и глобальным переменным".

ну не правда - смотри результаты.

неверный логический вывод, эта инициализация может пройти намного быстрей, чем обращение к глобальной переменной (что и показывает пример - функция F1 работает быстрей F2)

Залил с глобальными. Что-то разницы не видно

А разницу в размере скрипта не увидел???

Какой смысл на эту тему спорить дальше? Повторяйте выполнять примеры кода из этой темы до полного понимания.

Если интересно, вот тест с локальными/глобальными
(там пробег по всем элементам)

Мне очень интересно узнать две вещи.
Во первых объясните пожалуйста с какой целью http://chem.50webs.com/mendeleev/table.html генерируется полностью Ява скриптом.
Во вторых http://chem.50webs.com/mendeleev/table.html использует кодировку UTF-8 и все символы прекрасно отображаются. Но стоит мне своей страничке выставить charset=UTF-8 как напроч перестают отображатся все русские буквы. Вместо них абракадабра. Приходится использовать windows-1251. С чем это связано?
P.S. http://chem.50webs.com/mendeleev/table.html Мне очень понравился, появилось желание сверстать нечто подобное.

Дело в том, что сгенерированная страница весит около 50 КБ, а кусок скрипта, который её генерит - 15 КБ.
Плюс к тому я скоро залью апдейт(осталось чуть-чуть доделать), и некоторые куски контента будут различаться в зависимости от браузера.
Зю Ыю что-то не могу войти на форум

document.write распиханный по сайту может больно аукнуться при переводе сайта на аякс и баста.

Зацените, пожалуйста, апдейт

Вау, ты избавился таки от document.write...

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

Не смог отделаться от верхней полосы прокруктки, когда ее потащил. А так - все красиво :)

круто!