Операторы объявления

  Формат применения:

      Объявление первичных операндов.
  Первичный операнд ссылается на одно из допустимых значений JavaScript, которое может быть использовано в любом операторе JavaScript создающем выражение. Можно считать, что первичный операнд содержит заданное ему значение.
  В JavaScript первичный операнд может содержать значение, которое можно изменить в ходе выполнения скрипта, или значение, которое изменять нельзя - константу. Неизменность константы поддерживается не программистом а самим языком JavaScript.
  Одно из допустимых значений JavaScript может иметь и выражение, в котором используются первичные операнды. Поэтому любой первичный операнд JavaScript можно считать вырожденным выражением, а выражение, которое имеет конечное допустимое значение JavaScript, может быть использование в качестве операнда в других выражениях наряду с первичными операндами.



  Объявление операнда переменной или константы, или списка разноименных операндов переменных или констант.


Формат записи в коде скрипта:

  1.    var Имя1[= Значение1][, Имя2[= Значение2][, ...[, ИмяN[= ЗначениеN]]]];
  2.    let Имя1[= Значение1][, Имя2[= Значение2][, ...[, ИмяN[= ЗначениеN]]]];
  3.    const Имя1 = Значение1[, Имя2 = Значение2[, ...[, ИмяN = ЗначениеN]]];
  4.    Имя = Значение;


Значения формата записи:

  • var - Ключевое слово.
      Оператор var создает переменные.
       Их значения могут быть изменены в коде скрипта.

      В JavaScript любое объявление переменной оператором var обрабатывается браузером перед выполнением всего остального кода, то есть такое объявление можно делать равнозначно в любом месте кода.
      Однако же, присвоение переменной значения происходит только при достижении соответствующей строки кода, до этого такие переменные будут иметь неопределённые значения.
      Повторное объявление переменной оператором var без присвоения ей значения не изменит её текущее значение, в противном случае значение будет соответственно изменено. То есть неоднократное использование оператора var для переменной с одним и тем же именем допустимо.

      C одним документом посредством нескольких элементов тега SCRIPT может быть связано несколько скриптов.
      При этом все переменные объявленные оператором var в "верхних" (в последовательности HTML кода) скриптах будут доступны "нижним" скриптам.
      Использование же "верхними" скриптами переменных объявленных оператором var только в "нижних" скриптах может привести к ошибке времени выполнения.

      Вообще же говоря, всё же, все объявления переменных оператором var лучше делать в начале скрипта или тела функции.
      Также переменные не следует объявлять неявно.
      Эти строгости помогут избежать недоразумений с локализацией переменных, поскольку надо всегда иметь в виду многообразие браузеров и возможные особенности последовательности интерпретации HTML кода и кода скрипта.
      Косвенным подтверждением необходимости такого подхода стало введение стандартом ECMAScript 6 (ES6) оператора let.
  • let - Ключевое слово.
      Оператор let создает переменные внутри блока изолированного кода.
      Имена и значения этих переменных действительны только в этом блоке, их значения могут быть изменены только внутри него.
      Изолировать код можно не только в контексте какого-либо выражения, а просто выделив фигурными скобками какую-нибудь секцию скрипта для использования функционала оператора let. В случае вложений таких секций, переменная созданная оператором let во внешней секции будет доступна и во внутренней секции, если в последней, своим оператором let, не создана переменная с таким же именем.
      Повторное использование оператора let в одном и том же блоке изолированного кода (на одном уровне) для создания переменной с одним и тем же именем может привести к ошибке времени выполнения.
      Если оператором let создана переменная вне блока изолированного кода, то таким блоком браузер будет считать весь код скрипта выполняющийся в этом элементе тега SCRIPT.

      Оператор let введён стандартом ECMAScript 6 (ES6). Как не парадоксально, необходимость в операторе let возникла вследствие такого декларируемого "достоинства" JavaScript, как свобода использования оператора var в любом месте кода скрипта.
  • const - Ключевое слово.
      Оператор const создает константы внутри блока изолированного кода.
      Их значения не могут быть изменены в коде скрипта.
      При объявлении константы ей всегда должно быть присвоено какое-либо определённое значение (например - константа может быть даже функцией, но только не undefined).
      Если константе, при её объявлении, не присвоить никакого значения, или, если использовать константу объявленную в коде скрипта позже, то это, скорее всего, (в большинстве браузеров) приведёт к ошибке времени выполнения.
      В некоторых браузерах, присвоение нового значения уже объявленной константе не проигнорируется, а может также привести к ошибке времени выполнения.

      Оператор const введён стандартом ECMAScript 6 (ES6). Принцип локализации констант, созданных оператором const, точно такой же как у переменных, созданных оператором let. (По всей видимости, в новых стандартах JavaScript решено покончить с "махновщиной", которую допускало использование оператора var при объявлении первичных операндов.)
  • Имя - Допустимый символьный код, назначенный именем переменной.
      Может начинаться только с буквы или символа "_" (подчёркивание).
      Одна и таже буква в разных регистрах задаёт разный смысл в имени переменной.
      Имя не должно совпадать с зарезервированными именами JavaScript, браузера и подключенных библиотек.
  • = - Оператор присвоения. Ключевое слово в данном формате.
  • Значение - Указывается в одном из узаконенных форматов операнда значения переменной JavaScript.
  • , - Оператор группировки. Ключевое слово в этом формате.
  • ; - Оператор группировки. Ключевое слово в этом формате.
  Четвёртый формат также соответствует присвоению нового значения переменной уже объявленной оператором var.
  Если переменная с заданным именем еще не создана оператором var, то она будет создана неявно оператором присвоения.
  Хотя объявление переменных присвоением и поддерживается JavaScript, но этого лучше не делать, поскольку можно получить проблемы с локализацией таких переменных (например в функциях).
  Одна и та же уже объявленная переменная, в коде скрипта, может быть использована для различных значений и для значений разных типов.
  Cтандартом ECMAScript 6 (ES6) введена возможность объединять переменные в структуры. Такие структуры могут быть двух типов - простая структура и именованая структура.
  В простой структуре переменную характеризует только её место относительно других переменных этой структуры. Формат записи в коде скрипта простой структуры:

     [Имя1, Имя2, ..., ИмяN]

  Здесь имена могут указывать на уже объявленные переменные, если же эти переменные ещё не объявлены, то они могут быть объявлены в структуре в одном из форматов:
  1.    var [Имя1, Имя2, ..., ИмяN] [= массив | структура]
  2.    let [Имя1, Имя2, ..., ИмяN] [= массив | структура]
  3.    const [Имя1, Имя2, ..., ИмяN] = массив | структура
  4.    [Имя1, Имя2, ..., ИмяN] = массив | структура
  Простой структуре присвоен может быть только массив или другая простая структура. При присвоении структуре массива произойдёт так называемая деструктуризация массива, то есть каждая переменная структуры получит значение соответствующего элемента массива.
  Если, при присвоении структуре массива, структура "длиннее" массива, то все оставшиеся в структуре переменные получат значение undefined, независимо от того в структуре они объявлены, или вне её.
  Если, при присвоении структуре массива, не все элементы массива должны быть приняты переменными структуры, то, в выражении присвоения, пропускаемые элементы массива должны быть обозначены в записи структуры дополнительными запятыми (кроме последних элементов). Пример.

  Обратное присвоение массиву - простой структуры также возможно. Такое присвоение сокращает код, и, при этом, принимающий массив полностью сформируется из значений переменных этой структуры (у этого экземпляра объекта Array соответственно изменится значение свойства length).

  Присвоении структуре структуры, кроме того, что тоже сокращает код (одним выражением присвоения можно присвоить значения всем переменным принимающей структуры), но может использоваться и для обмена значениями переменных, поскольку в принимающей структуре могут быть использованы те же переменные, что и в отдающей, но в другой последовательности. Пример.
  Поскольку структуру из уже объявленных переменных можно создать прямо в выражении присвоения, то, по всей видимости, использовать в выражении присвоения структуры разных размерностей не имеет особого смысла.
  Однако если, при присвоении, принимающая структура "длиннее" отдающей, то все оставшиеся в принимающей структуре переменные получат значение undefined, независимо от того в структуре они объявлены, или вне её.

  Таким образом, поскольку одни и те же переменные могут быть использованы в разных структурах (в различных наборах и последовательностях), обычным присвоением можно проделывать множество различных операций над массивами. Например - объединение нескольких массивов, перестановку элементов, обрезание "массива" и т.п.
Объединение массивов:
            let a = null;
            let b = null;
            let c = null;
            let d = null;
            let e = null;
            let f = null;
            let x = [1,2,3];
            let y = [4,5,6];
            let z = [0];
            [a,b,c] = x;
            [d,e,f] = y;
            z = [a,b,c,d,e,f]
Перестановка элементов:
            let a = null;
            let b = null;
            let c = null;
            let d = null;
            let e = null;
            let f = null;
            let x = [1,2,3,4,5,6];
            [a,b,c,d,e,f] = x;
            x = [f,e,d,c,b,a];
"Обрезание" массива:
            let a = null;
            let b = null;
            let c = null;
            let d = null;
            let e = null;
            let f = null;
            let x = [1,2,3,4,5,6];
            [a,b,c,d,e,f] = x;
            x = [c,d];
Выборка из массива:
            let a = null;
            let b = null;
            let c = null;
            let x = [1,2,3,4,5,6,7,8];
            [,a,,b,,c] = x;
Обмен значениями двух переменных:
            let a = 1;
            let b = 2;
            [a,b] = [b,a];
  В именованной структуре, в отличие от простой структуры, переменную характеризует не её место относительно других переменных этой структуры, а структурное имя этой переменной.
  Формат записи в коде простой структуры:

  {[Cтруктурное имя1:] Имя1, [Cтруктурное имя2:] Имя2, ..., [Cтруктурное имяN:] ИмяN}
  Если структурное имя и имя совпадают, то структурное имя вместе с двоеточием можно опустить. И тогда имя объявленной в структуре переменной будет также и структурнным именем этой переменной
  В именованной структуре любое из имён переменных не может указывать на уже объявленную переменную. Поэтому переменные именованной структуры могут быть объявлены только вместе с объявлением этой структуры. (Такое ограничение, конечно же, не удобно, вероятно оно может быть связано с функционалом фигурных скобок используемым оператором let.)
  После объявления именованной структуры все её переменные локализуются в соответствии с форматом объявления структуры, и только тогда будут доступны (со своими значениями) в коде скрипта.
  Формат объявления именованной структуры:
  1.    var {[Cтруктурное имя1:] Имя1, [Cтруктурное имя2:] Имя2, ..., [Cтруктурное имяN:] ИмяN} = экземпляр объекта
  2.    let {[Cтруктурное имя1:] Имя1, [Cтруктурное имя2:] Имя2, ..., [Cтруктурное имяN:] ИмяN} = экземпляр объекта
  Именованной структуре может быть присвоен только экземпляр объекта.

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

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



  Узаконенные форматы операнда значения переменной (типы данных JavaScript)

  Операнд значения переменной позволяет сослаться на значение этой переменной в коде скрипта.
  Однако операнд значения переменной не надо путать со значением переменной, хотя в некоторых случаях они совпадают.
  Так при выполнении операторов присвоения :
        i = 1;
        j = i;
переменные i и j (с именами i и j) получат одинаковое значение - 1.
  Однако в коде скрипта оператор = для i имеет справа операнд значения - 1, а для j операнд значения - i



  string - Экземпляр строки (экземпляр объекта String).

Форматы операнда в коде скрипта:

  1. Непосредственная запись строки символов в коде скрипта.
      Задаётся в виде последовательности (строки кода) любых символов длиной до 2 Гбайт, заключенных в двойные кавычки или одинарные кавычки.
      Некоторые символы невозможно напрямую использовать в записи строкового значения из за связанного функционала, поэтому их можно закодировать, используя так называемые escape-последовательности.
      Например:
    • \f     - Прогон листа.
    • \n     - Перевод строки.
    • \r     - Возврат каретки.
    • \t     - Табуляция.
    • \v     - Вертикальная табуляция.
    • \"     - Двойная кавычка.
    • \'     - Одинарная кавычка.
    • \\     - Обратный слэш.
    • \uXXXX     - Кодовая точка Юникода.
  2. Имя переменной со строковым значением.
  3. Выражение обращения к элементу массива, содержащему строковое значение.
  4. Арифметическое выражение с конечным строковым значением.
  5. Выражение на основе функционального оператора с конечным строковым значением.
  6. Условное выражение с конечным строковым значением.
  7. Выражение присвоения значения с конечным строковым значением.
  8. Выражение обращения к функции, возвращающей строковое значение.
      Например к функции String.
  9. new String(Начальное значение экземпляра объекта String)
  10. Выражение доступа к сущности объекта метод, возвращающему строковое значение.
  11. Выражение доступа к сущности объекта свойство, содержащему строковое значение.
  Примеры операндов строковых значений:

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

        "Рыба " + "кит" - арифметическое выражение.

        Keith = "Рыба кит" - выражение присвоения значения, (в этом случае значение "Рыба кит" получит переменная с именем Keith, однако и само это выражение присвоения, в контексте его использования, вернёт значение "Рыба кит").



  number - Экземпляр числа (экземпляр объекта Number).

Форматы операнда в коде скрипта:

  1. Непосредственная запись числа в коде скрипта.
  2.   Форматы понятны из примеров:
    • 27 - Целое число.
    • 45.098 - Дробное число.
    • 7.2E-5 - Число в экспоненциальной форме.
    • 071 - Целое число в восьмеричном формате (0 - в начале!).
    • 0x87CF - Целое число в шестнадцатеричном формате (Unicode кодовая точка).
  3. Имя переменной с числовым значением.
  4. Выражение обращения к элементу массива, содержащему числовое значение.
  5. Арифметическое выражение с конечным числовым значением.
  6. Условное выражение с конечным числовым значением.
  7. Выражение присвоения значения с конечным числовым значением.
  8. Выражение обращения к функции, возвращающей числовое значение.
      Например к функции Number
  9. new Number(Начальное значение экземпляра объекта Number)
  10. Выражение доступа к сущности объекта метод, возвращающему числовое значение.
  11. Выражение доступа к сущности объекта свойство, содержащему числовое значение.
  Примеры операндов числовых значений:

        1 - непосредственная запись.

        9E-1 + 1E-1 - арифметическое выражение, (конечное значение 1).

        true + false - арифметическое выражение, (конечное значение 1).

        true * false - арифметическое выражение, (конечное значение 0).

        false + false - арифметическое выражение, (конечное значение 0).

        Numb = 0x12BA - выражение присвоения значения, (в этом случае значение 0x12BA4 или 4794 получит переменная с именем Numb, однако и само это выражение присвоения, в контексте его использования, вернёт значение 0x12BA4 или 4794).



  boolean - Экземпляр логического значения (экземпляр объекта Boolean).

Форматы операнда в коде скрипта:

  1. true - Ключевое слово (означает - "истина").
      Непосредственная запись в коде скрипта.
  2. false - Ключевое слово (означает - "не истина").
      Непосредственная запись в коде скрипта.
  3. Имя переменной с логическим значением.
  4. Выражение обращения к элементу массива, содержащему логическое значение.
  5. Арифметическое выражение с конечным значением true или false.
  6. Логическое выражение с конечным значением true или false.
  7. Выражение присвоения значения с конечным значением true или false.
  8. Выражение на основе функционального оператора с конечным значением true или false.
  9. Условное выражение с конечным значением true или false.
  10. Выражение обращения к функции, возвращающей значение true или false.
      Например к функции Boolean
  11. new Boolean(Начальное значение экземпляра объекта Boolean)
  12. Выражение доступа к сущности объекта метод, возвращающему значение true или false.
  13. Выражение доступа к сущности объекта свойство, содержащему значение true или false.
  Примеры операндов логических значений:

        true - непосредственная запись.

       ! true - арифметическое выражение, (конечное значение false).

       2 > 1 - логическое выражение, (конечное значение true).

      Logical = (1 > 2) - выражение присвоения значения, (в этом случае значение false получит переменная с именем Logical, однако и само это выражение присвоения, в контексте его использования, вернёт значение false).



  NaN - Экземпляр числового значения (экземпляр объекта Number), которое не может быть обозначено цифрами.
  Такое значение не совпадает с самим собой при сравнении

Форматы операнда в коде скрипта:

  1. NaN - Ключевое слово (Not a Number).
      Непосредственная запись в коде скрипта.
  2. Имя переменной со значением - NaN.
      Например переменная с именем NaN
  3. Выражение обращения к элементу массива, содержащему значение NaN.
  4. Арифметическое выражение с конечным значением NaN.
  5. Условное выражение с конечным значением NaN.
  6. Выражение присвоения значения с конечным значением NaN.
  7. Выражение обращения к функции, возвращающей значение NaN.
      Например к функции Number
  8. Выражение доступа к сущности объекта метод, возвращающему значение NaN.
  9. Выражение доступа к сущности объекта свойство, содержащему значение NaN.



  null - Экземпляр "пустого" значения.

Форматы операнда в коде скрипта:

  1. null - Ключевое слово.
      Непосредственная запись в коде скрипта.
  2. Имя переменной со значением - null.
  3. Выражение обращения к элементу массива, содержащему значение null.
  4. Арифметическое выражение с конечным значением null.
  5. Условное выражение с конечным значением null.
  6. Выражение присвоения значения с конечным значением null.
  7. Выражение обращения к функции, возвращающей значение null.
  8. Выражение доступа к сущности объекта метод, возвращающему значение null.
  9. Выражение доступа к сущности объекта свойство, содержащему значение null.



  undefined - Экземпляр неопределенного значения.

Форматы операнда в коде скрипта:

  1. undefined - Ключевое слово.
      Непосредственная запись в коде скрипта.
  2. Имя переменной со значением - undefined.
      Например переменная с именем undefined
  3. Выражение обращения к элементу массива, содержащему значение undefined.
  4. Арифметическое выражение с конечным значением undefined.
  5. Выражение на основе функционального оператора с конечным значением undefined.
  6. Условное выражение с конечным значением undefined.
  7. Выражение присвоения значения с конечным значением undefined.
  8. Выражение обращения к функции, возвращающей значение undefined.
  9. Выражение доступа к сущности объекта метод, возвращающему значение undefined.
  10. Выражение доступа к сущности объекта свойство, содержащему значение undefined.



  array - Экземпляр массива (экземпляр объекта Array).
  Массив это список переменных с одним именем.
  Такие переменные называются элементами массива.
  С массивами переменных, например, удобно строить циклы.
  В массивах также удобно хранить значения одного логического смысла, каждое из которых может быть ассоциировано с заданным ключевым словом.

Форматы операнда в коде скрипта:

  1. Непосредственная запись массива в коде скрипта.
      Формат непосредственной записи массива:

          [Значение1, Значение2, ..., ЗначениеN]

      Значения формата непосредственной записи массива:

    • [ - Оператор группировки. Ключевое слово в этом формате.
    • , - Оператор группировки. Ключевое слово в этом формате.
    • Значение - Значение элемента массива, соответствующее его месту в списке (массиве).
        Указывается в одном из узаконенных форматов операнда значения переменной JavaScript.
        Если значением элемента массива является массив, то получается двумерный массив (трехмерные массивы в JavaScript недопустимы).
        Фактически двумерный массив - это одномерный массив, элементами которого являются массивы.
        В квадратных скобках можно не указывать ни одного значения, и тогда объявляется пустой массив.
        При создании не пустого массива каждый его элемент автоматически получает уникальный номер. Последовательно, первый элемент - 0, второй - 1 и т.д.
    • ] - Оператор группировки. Ключевое слово в этом формате.
  2. Имя массива - Имя переменной со значением массив.
  3. Выражение обращения к элементу массива, содержащему массив.
  4. Условное выражение с конечным значением - массив.
  5. Выражение присвоения значения с конечным значением массив.
  6. Выражение обращения к функции, возвращающей массив.
      Например к функции Array
  7. new Array(Начальное значение экземпляра объекта Array)
  8. Выражение доступа к сущности объекта метод, возвращающему массив.
  9. Выражение доступа к сущности объекта свойство, содержащему массив.
  Примеры операндов массива:

        [] - непосредственная запись пустого массива, (нуль элементов).

 ["красный","оранжевый","желтый","зеленый","голубой","синий","фиолетовый"] - непосредственная запись одномерного массива из семи элементов, (нулевой элемент - имеет строковое значение "красный").

       [[1,2],[3,4]] - непосредственная запись двумерного массива, (при обращении к элементу такого массива первый индекс укажет номер одномерного массива, в котором находится этот элемент, а второй индекс укажет номер элемента этого одномерного массива).

      new Array(10) - выражение обращения к функции Array, которая возвращает массив из десяти элементов без значений, (со значениями undefined).

      Arr = [1,2,3,4,5,6,7] - выражение присвоения значения, (в этом случае значение массива из семи элементов получит переменная с именем Arr, однако и само это выражение присвоения, в контексте его использования, вернёт значение массива из семи элементов).
  Формат выражения обращения к элементу массива в коде скрипта
      (для получения его значения, изменения его значения, добавления нового элемента):

  1.   Имя массива[Индекс] [= Значение]
              - для элемента одномерного массива.

  2.   Имя массива[Индекс1][Индекс2] [= Значение]
              - для элемента двумерного массива.

Значения формата выражения обращения к элементу массива:

  Для получения элемента массива с ассоциативным указателем нужно присвоить этому элементу значение, указав для него в квадратных скобках соответствующий ассоциативный указатель.
  Лучше не смешивать в одном массиве элементы с номерами и элементы с ассоциативными указателями.
  Все элементы массива, у которых есть ассоциативный указатель, не могут и не будут одновременно иметь своих номеров, к ним можно обращаться только по их ассоциативным указателям.
  Свойство length соответствующего экземпляра объекта Array не будет учитывать элементы с ассоциативными указателями.
  С помощью безусловного цикла для связанных сущностей можно получить все значения ассоциативных указателей и значения всех соответствующих элементов любого массива.
  Ассоциативный массив не может быть преобразован в строку.
  Вообще говоря, в JavaScript ассоциативный массив - это не объект Array, а созданный объект, у которого свойства совпадают с ассоциативными указателями а значения этих свойств являются значениями соответствующих элементов массива.
  Поэтому непосредственная запись объекта в коде скрипта создаёт и соответствующий ассоциативный массив.
  Поэтому к элементам ассоциативного массива можно обращаться используя оператор построения цепочки доступа к сущности объекта (точку).
  Поэтому все свойства и методы объекта Array не доступны для ассоциативных массивов, а в смешанных массивах будут работать только для элементов, которые имеют номера.



  function - Экземпляр функции (экземпляр объекта Function).
  Функция это локализованный код Javascript, к которому можно обращаться из любого места скрипта.
  Такое обращение называется вызовом функции.
  В вызванную функцию можно передавать определенные значения, которые подставляются на место ее аргументов.
  Вызванная функция может возвращать значение оператором return или yield в любом из допустимых форматов Javascript.

Форматы операнда в коде скрипта:

  1. Непосредственная запись функции в коде скрипта.
      Формат непосредственной записи функции:

          function [Псевдоним]([Аргумент1[, Аргумент2[, ..., АргументN]]])
         {Блок операторов [return [Выражение значения];]}
      Стандартом ECMAScript 6 (ES6) принят так называемый "стрелочный формат" непосредственной записи функции:

      ([Аргумент1[, Аргумент2[, ..., АргументN]]])   =>
      {Блок операторов [return Выражение значения];]}


      В этом формате вообще отсутствует ключевое слово function, зато есть ключевое слово =>. Этот формат как бы указывает, что заданный набор аргументов должен быть передан в указанный блок изолированного кода.
      В "стрелочной" функции ключевое слово this всегда ссылается на значение из окружающего контекста этой функции (как правило, на объект Window или Self).
      Поэтому такую функцию нельзя использовать как конструктор.
      Поэтому, хотя формально для экземпляра объекта Function, созданного стрелочной функцией, можно вызывать методы apply или call, в этом нет никакого смысла.
      Поэтому же назначать "стрелочную" функцию методом объекта не следует.
      Кроме того в "стрелочной" функции не доступен объект Arguments.
      Кроме того "стрелочная" функция допускает так называемый "краткий синтаксис" (без фигурных скобок). Честно говоря, это особо изощрённая форма издевательства над языком JavaScript.
      Кроме того ключевое слово =>, создающее "стрелочную" функцию не является оператором языка JavaScript, что может создать проблемы при парсинге программ.
      Скорее всего, стандартизация этого формата в JavaScript есть ни что иное, как дань моде и шаг к сведению объектной модели JavaScript к канонической.
      Несмотря на то, что "стрелочный" формат как-то уменьшает код скрипта, этот формат не внёс никакой особой новой функциональности. Зато неизбежные издержки, связанные с сопровождением программ, не наглядностью кода, одновременным использованием разработчиками разных форматов в коде, отсутствием внешней логики связи "стрелочного" формата с объектом Function очевидны.
      Тем не менее, браузер, как и в формате с ключевым словом function, создаст переменную с указанным именем, и значением - эта функция (экземпляр объекта Function). Со всеми вытекающими отсюда последствиями. (Например - этой переменной можно будет присвоить другое значение, и не обязательно функцию.)


        Значения формата непосредственной записи функции:

      Весь код, который находится в скобках { } ещё называют телом функции.
      В JavaScript существует формат объявления функции без использования оператора var (или let, или const), который иногда называют декларативным (без выражения присвоения):

       function Имя функции([Аргумент1[, Аргумент2[, ..., АргументN]]])
       {Блок операторов [return Выражение значения];]}


      В отличие от формата с использованием оператора var, декларативно объявленную функцию можно использовать в коде скрипта и до её последующей декларации.
      То есть декларации функций обрабатываются браузером перед выполнением всего остального кода.
      При этом браузер, как и в формате с var, создаст переменную, именем которой будет указанное Имя функции, а значением - эта функция (экземпляр объекта Function). Со всеми вытекающими отсюда последствиями. (Например, этой переменной можно будет присвоить другое значение, и не обязательно функцию.)

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

      Трудно однозначно сказать хорошо это или плохо - иметь возможность декларации функций в любом месте кода.
      Очевидно, что такая логика в современных языках программирования внесена по желанию программистов, в отличие от первых языков, логика которых разрабатывалась математиками.
      Однако разделять код программы на секцию объявления и секцию исполнения можно и в современных языках программирования.
      Такая строгость совсем не повредит, а совсем даже наоборот. Тем более для JavaScript, имея в виду многообразие браузеров. Ведь не зря же для объявления функции тут предусмотрен также и формат с оператором var. Впрочем, декларацию функций можно делать и в выделенной в начале кода секции объявлений.
      Совершенно же точно можно утверждать, что на практике лучше использовать один из форматов, а не перемешивать их в коде программы.

      В этом справочнике формат объявления функции с оператором var (или let или const) взят за основу, потому что он хорошо вписался в логику раздела "Объявление операндов и типы данных".
      Кроме того, декларативный формат, судя по всему, не очень соответствует тенденциям развития JavaScript, определённым в стандарте ECMAScript 6 (ES6), поскольку декларативный формат не позволяет использовать функции - константы, объявлять функции оператором let, и использовать "стрелочный формат" объявления функций.
  2. Имя функции - Имя переменной со значением функция.
  3. Условное выражение с конечным значением функция.
  4. Выражение присвоения значения с конечным значением функция.
  5. Выражение обращения к элементу массива, содержащему функцию.
  6. Выражение обращения к функции, возвращающей функцию.
      Например к функции Function
  7. new Function(Значение экземпляра объекта Function).
  8. Выражение доступа к сущности объекта метод, возвращающему функцию.
  9. Выражение доступа к сущности объекта свойство, содержащему функцию.
      Вообще говоря, такое свойство - это метод.
  Примеры операндов функции:

          непосредственная запись c ключевым словом function:

        function (x,y,z) {let xy = x * y; return xy + z;}

             пример кода:

       let Func = function (x,y,z) {let xy = x * y; return xy + z;};

       let Callf = Func(1,2,3);

          непосредственная запись c ключевым словом =>:

        (x,y,z) => {let xy = x * y; return xy + z;}

             пример кода:

       let Func = (x,y,z) => {let xy = x * y; return xy + z;};

       let Callf = Func(1,2,3);

          непосредственная запись c аргументом списка:

        function (...m) {let xy = m[0] * m[1]; return xy + m[2];}

             пример кода:

       let Func = function (...m) {let xy = m[0] * m[1]; return xy + m[2];};

       let Callf = Func(1,2,3);

          пример кода с использованием операнда переменной содержащей функцию:

       let Func = function (x,y,z) {let xy = x * y; return xy + z;};

       let Funv = Func;

       let Callf = Funv(1,2,3);
  Формат выражения обращения к функции в коде скрипта:
  1. Имя функции([Значение1[, Значение2[, ...[, ЗначениеN]]]])
  2. Имя функции.apply(Аргументы)
  3. Имя функции.call(Аргументы)

    Значения формата выражения обращения к функции:
  Стандартом ECMAScript 6 (ES6) введена возможность передавать несколько значений аргументов функции (или все эти значения) одним единственным значением, в формате:

      Имя функции(...Массив значений)

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

       let Func = function (x,y,z) {let xy = x * y; return xy + z;};

       let Arr = [2,3];

       let Callf = Func(1,...Arr);
  В теле функции возможны вызовы её самой. Такие вызовы называютя рекурсивными.
  В теле - объявленной функции доступны не только переменные созданные в нём, но и внешние переменные из области окружения этой функции.

  Функция конструктор экземпляров объектов.
  В JavaScript формально не существует классов объектов. Сам объект JavaScript и есть инкапсулятор своего условного класса.
  Доступная реализация любого объекта называется экземпляром объекта. Как правило, для получения экземпляра любого встроенного и созданного объекта, предназначается особая функция конструктор.
  Имя функции конструктора экземпляров встроенных объектов, как правило, совпадает с именем соответствующего объекта.
  Функция конструктор (как экземпляр объекта Function) имеет дополнительное свойство prototype.
  Для всех встроенных объектов JavaScript (кроме объекта Math существуют функции конструкторы их экземпляров (как правило в виде одноименных методов объекта Global).

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

  •      this.Имя = Значение;

Где:

  Свойство constructor экземпляра созданного объекта (как, впрочем и встроенного) будет ссылаться на его функцию конструктор.
  Свойство __proto__, по умолчанию, будет указывать на объект Object, что, впрочем, можно изменить.
  Созданные объекты могут участвовать в цепи прототипов, со всеми вытекающими от этого для них последствиями.
  Формат выражения с функцией конструктором, которое будет иметь значением соответствующий экземпляр объекта:

  •      new Имя функции([Значение1[, Значение2[, ...[, ЗначениеN]]]])

Значения формата выражения с функцией конструктором:

  Вообще-то говоря, любая функция может быть использована в качестве конструктора экземпляров объекта, а не только та, в блоке операторов которой, есть выражения с оператором this. До создания соответствующего экземпляра объекта, его свойства и методы можно задать с помощью свойства prototype этой функции.

  Функция генератор.
  Функция генератор предназначена для создания механизма асинхронных выполнений без использования функционала функций обратного вызова.
  Обращение к функции генератору создаёт и возвращает экземпляр объекта Generator, методы которого позволяют выполнять код в блоке операторов функции генератора с указанного места. Эти же методы позволяют обмениваться данными с выполняемым кодом.

Форматы операнда в коде скрипта:

  1. Непосредственная запись функции генератора в коде скрипта.
      Формат непосредственной записи функции генератора в коде скрипта:

         function* ([ Аргумент1[, Аргумент2[, ...[, АргументN]]]])
         {Блок операторов [return [Выражение значения];][yield [Выражение значения];]}


         Значения формата непосредственной записи функции генератора:

    • function* - Ключевое слово для создания функции генератора.
        Вызов функции генератора не приводит к выполнению её блока операторов, а только возвращает экземпляр объекта Generator.
    • ( - Оператор группировки. Ключевое слово в этом формате.
    • Аргумент - Допустимый символьный код, назначенный >аргументом функции генератора, заданный непосредственно.
        Не должен совпадать с зарезервированными именами JavaScript, браузера и подключенных библиотек.
        Аргументы функции генератора доступны в блоке операторов со значениями внешних операндов, подставленных на место аргументов при вызове метода next или throw экземпляра объекта Generator, созданного вызовом функции генератора.
        Функция-генератор может иметь до 255 аргументов.
    • , - Оператор группировки. Ключевое слово в этом формате.
    • ) - Оператор группировки. Ключевое слово в этом формате.
    • { - Оператор группировки. Ключевое слово в этом формате.
    • Блок операторов - Код Javascript, который должен быть выполнен при вызове метода next или throw экземпляра объекта Generator, созданного вызовом функции генератора.
    • return - Ключевое слово - оператор определяющий выражение значения и завершающий выполнение этого вызова функции.
        Может неоднократно использоваться в любом месте блока операторов.
        Любое выполнение оператора return приведёт к завершению выполнения блока операторов в этом месте, и получению конечного значения свойством value объекта возвращаемого методом next.
        В отличие от оператора yield, оператор return завершает, а не останавливает, работу функции генератора.
        То есть соответствующий экземпляра объекта Generator, созданного вызовом функции генератора, перестаёт быть доступным.
    • yield - Ключевое слово - оператор определяющий выражение значения и останавливающий выполнение блока операторов функции генератора, до следующего вызова метода next или throw экземпляра объекта Generator, созданного вызовом функции генератора.
        Может неоднократно использоваться в любом месте блока операторов.
        Любое выполнение оператора yield приведёт к остановке выполнения блока операторов в этом месте, и получению конечного значения свойством value объекта возвращаемого методом next.
        Возобновление работы блока операторов с оператора непосредственно следующего за остановившим этот блок операторов оператором yield, возможно новым обращением к методу next экземпляра объекта Generator, созданного вызовом этой функции генератора.
        Оператор yield, кроме того, что определяет выражение значения для соответствующего свойства value, ещё и может указать в генераторе переменную для получения значения аргумента метода next. Эта переменная получит значение аргумента метода next, который инициировал любой следующий, после текущего yield, шаг генерации. Указать такую переменную можно (почему-то???) с помощью оператора =.
        То есть, к примеру, если в блоке операторов присутствует следующий код -

            var x = 7; x = yield x + 7; yield x + 7;

      то:
      1. В первом обращении к методу next (первом шаге генерации) значение переменной x останется равным 7, поскольку эта переменная для значения аргумента соответствующего метода next еще не определена в генераторе (оператор yield используется впервые). Каким бы не было значение аргумента этого метода next соответствующее свойство value получит значение - 14.
      2. При втором обращении к методу next, уже указанная предыдущим оператором yield переменная x получит значение аргумента этого обращения. Свойство value получит значение - x + 7 уже с учётом переданного его методу next аргумента.


        Честно говоря, довольно мудрёный и совершенно не логичный механизм, который в реализации выглядит довольно шизофренично.
        Во-первых, оператор = в JavaScript всё же является оператором присвоения значения. Но, к примеру, выражение yield x + 7 не имеет никакого конечного значения, поэтому никакого присвоения в выражении x = yield x + 7 не происходит.
        Во-вторых, этот механизм исключает возможность использования аргумента метода next первого шага генерации.
        Конечно, в современном программировании появилась ощутимая тенденция писать программы на основе шизофрении, а не логики. Но вряд-ли этот путь приведёт к чему-либо хорошему.
    • Выражение значения -
        Арифметическое выражение,
          или логическое выражение,
          или выражение присвоения значения,
          или выражение доступа к сущности объекта,
          или выражение обращения к элементу массива,
          или выражение обращения к функции,
          или условное выражение,
          или выражение на основе функционального оператора,

      определяющее конечное значение, которое получит свойство value объекта возвращаемого методом next соответствующего экземпляра объекта Generator.
    • ; - Закрывающий оператор< для оператора return или yield.
    • } - Оператор группировки. Ключевое слово в этом формате.
      Весь код, который находится в скобках { } обычно называют телом функции генератора.
      функция генератор может объявляться и в декларативном виде.
  2. Имя функции - Имя переменной со значением функция генератор.
  3. Условное выражение с конечным значением функция генератор.
  4. Выражение присвоения значения с конечным значением функция генератор.
  5. Выражение обращения к элементу массива, содержащему функция генератор.
  6. Выражение обращения к функции, возвращающей функция генератор.
  7. Выражение доступа к сущности объекта метод, возвращающему функцию генератор.
  8. Выражение доступа к сущности объекта свойство, содержащему функцию генератор.
      Вообще говоря, такое свойство - это метод.
  Формат выражения обращения к функции генератору в коде скрипта:

  1. Имя функции([Значение1[, Значение2[, ...[, ЗначениеN]]]])
  2. Имя функции.apply(Аргументы)
  3. Имя функции.call(Аргументы)

    Значения формата выражения обращения к функции:

  Выражение обращения к функции генератору всегда возвращает экземпляр объекта Generator.
  В теле - объявленной функции генератора доступны не только переменные созданные в нём, но и внешние переменные из области окружения этой функции.
  Очевидно, что то, что можно реализовать с помощью функционала генераторов, может быть реализовано и без него.
  Можно заметить, что логика реализации функционала генераторов далека от совершенной и использование генераторов приводит к уменьшению наглядности кода скрипта.
  Однако функционал генераторов поддерживается почти всеми современными браузерами.
  Пример кода с функционалом генератора:

       let gen = function* (i) {

          let x = [0,0,0];

          x[0] = yield 0;

          while (i < 3) {

            x[i+1] = yield x[i] + 1;

            i++;

          }

          return x;

       }

       let g = gen(0);

       let k = 0;

       while (k < 4) {

         alert (g.next(k).value);

         k++;

       }

       alert (g.next().value);



  object - Экземпляр объекта.

Форматы операнда в коде скрипта:

  1. Непосредственная запись объекта в коде скрипта.
      Формат непосредственной записи экземпляра объекта (конфигуратор объекта):
    {
      Имя свойства1: Значение свойства1,
      Имя свойства2: Значение свойства2,
      .....
      Имя свойстваN: Значение свойстваN,
      Имя метода1: Функция метода1,
      Имя метода2: Функция метода2,
      .....
      Имя методаN: Функция методаN,
    }


        Значения формата записи конфигуратора:

      Такой формат записи создает сразу объект и его экземпляр (его ещё называют литеральным). Однако у такого объекта не будет собственной функции конструктора (а будет конструктор - Object), а значит очень накладно обойдётся изменение его прототипа.
      Однако при всей внешней незамысловатости такой записи создания объекта, это очень удобное средство языка JavaScript, которое создаёт огромные возможности для структурирования данных. Такие структуры удобно использовать для обмена информацией и в качестве аргументов функций. Такие структуры лежат в основе распространённого формата JSON (JavaScript Object Notation — текстовый формат обмена данными JavaScript), который по существу стал уже стандартом для обмена данными в Web-приложениях на разных языках программирования. Такие структуры используются и в базах данных IDB.
  2. Имя переменной со значением экземпляра объекта
      В том числе экземпляра объектов String, Number, Boolean, Array, или Function.
  3. Арифметическое выражение с конечным строковым, числовым, логическим значением, значением массива, или функции ( соответственно экземпляры объектов String, Number, Boolean, Array, или Function).
  4. Логическое выражение (экземпляр объекта Boolean).
  5. Выражение присвоения значения с конечным значением экземпляра объекта.
  6. Выражение на основе оператора new
  7. Выражение обращения к элементу массива, содержащему экземпляр объекта.
      В том числе экземпляр объектов String, Number, Boolean, Array, или Function.
  8. Условное выражение с конечным значением экземпляр объекта.
  9. Выражение обращения к функции (например к функции Object), возвращающей экземпляр объекта.
      В том числе экземпляр объектов String, Number, Boolean, Array, или Function.
  10. Выражение доступа к сущности объекта, которая ссылается, содержит, или возвращает экземпляр объекта
      В том числе экземпляр объектов String, Number, Boolean, Array, или Function.
  Примеры операндов объекта:

          непосредственная (литеральная) запись:

        {Brand: = "Nissan", Model: = "Almera", Volume: = 1.6,}

             пример кода:

       let Auto = {Brand: = "Nissan", Model: = "Almera", Volume: = 1.6,};

          обращение к созданной функции конструктору:

        new Auto("Nissan","Almera",1.6)

             пример кода:

     let Auto = function (x,y,z) {this.Brand = x; this.Model = y; this.Volume = z;};

     let Callf = new Auto("Nissan","Almera",1.6);

          обращение к функции конструктору массивов:

        new Array("Nissan","Almera",1.6)

             пример кода:

       let Auto = new Array("Nissan","Almera",1.6);



  Regular Expression - Экземпляр регулярного выражения (экземпляр объекта RegExp).
  Регулярное выражение - это параметризированная строка символов, конечное значение которой и зависит от этих параметров, заданных прямо в самой строке.
  Кроме того, регулярное выражение позволяет связать, заданную им строку символов с определенными опциями.
  Регулярные выражения обычно используют в качестве образцов для контекстного поиска в строковых значениях.
  Вырожденным случаем регулярного выражения можно считать обычную строку данных.

Форматы операнда в коде скрипта:

  1. Непосредственная запись регулярного выражения в коде скрипта.
      формат непосредственной записи регулярного выражения:

       /Строка/[Опция]

         Значения формата непосредственной записи регулярного выражения:

    • / - Оператор группировки. Ключевое слово в этом формате.
    • Строка - Параметризированная строка значения регулярного выражения, заданная непосредственно как набор символов.
    • / - Оператор группировки. Ключевое слово в этом формате.
    • Опция - Связанная со строкой значения регулярного выражения опция.
        Опция может иметь одно из, заданных непосредственно в коде скрипта, значений, или их логическую комбинацию:
      1. i - Устанавливает идентичность строчных и прописных букв (ignore case), при контекстном поиске образца с указанным регулярным выражением.
      2. g - Устанавливает глобальный поиск (global search) всех вхождений образца, при контекстном поиске образца с указанным регулярным выражением.
      3. m - Устанавливает многострочный поиск (multiline), при контекстном поиске образца с указанным регулярным выражением.
  2. Имя регулярного выражения - Имя переменной со значением - регулярного выражения.
  3. Выражение обращения к элементу массива, содержащему регулярное выражение.
  4. Условное выражение с конечным значением регулярное выражение.
  5. Выражение присвоения значения с конечным значением регулярное выражение.
  6. Выражение обращения к функции, возвращающей регулярное выражениее.
      Например к функции RegExp.
  7. new RegExp(Начальное значение экземпляра объекта RegExp)
  8. Выражение доступа к сущности объекта метод, возвращающему регулярное выражение.
  9. Выражение доступа к сущности объекта свойство, содержащему регулярное выражение.
  Символы параметризации строк регулярных выражений:

  • \ - Изменяет значение следующего символа с буквального на специальное и наоборот.
  • ^ - Устанавливает соответствие началу строки.
  • $ - Устанавливает соответствие концу строки.
  • * - Устанавливает соответствие повторению предшествующего символа нуль или более раз.
  • + - Устанавливает соответствие повторению предшествующего символа один или более раз.
  • ? - Устанавливает соответствие повторению предшествующего символа нуль или один раз.
  • . - Устанавливает соответствие любому символу, кроме символа новой строки.
  • (строка) - Устанавливает запоминание заданной строки при соответствии значения. (строка - строка регулярного выражения).
  • (?:строка) - Устанавливает соответствие заданной строке. (строка - строка регулярного выражения).
  • строка1(?=строка2) - Устанавливает соответствие заданной строке1, если следующий за ней контекст соответствует строке2. (строка - строка регулярного выражения).
  • строка1(?!строка2) - Устанавливает соответствие заданной строке1, если следующий за ней контекст не соответствует строке2. (строка - строка регулярного выражения).
  • строка1|строка2 - Устанавливает соответствие хотя бы одной из строк. (строка - строка регулярного выражения).
  • {n} - Устанавливает соответствие n вхождениям предшествующего символа.
  • {n,} - Устанавливает соответствие n или более вхождениям предшествующего символа.
  • {n,m} - Устанавливает соответствие не менее чем n, и не более чем m вхождениям предшествующего символа.
  • [строка] - Устанавливает соответствие любому символу из заданной строки.
  • [^строка] - Устанавливает соответствие любому символу, кроме символов из заданной строки.
  • [начальный символ-конечный символ] - Устанавливает соответствие любому символу из заданного диапазона.
  • [^начальный символ-конечный символ] - Устанавливает соответствие любому символу, кроме символов из заданного диапазона.
  • \b - Устанавливает соответствие позиции границы слова.
  • \B - Устанавливает соответствие любой позиции, кроме границы слова.
  • \сСимвол - Устанавливает соответствие символу Ctrl+Символ.
  • \d - Устанавливает соответствие любой цифре.
  • \D - Устанавливает соответствие любой не цифре.
  • \f - Устанавливает соответствие символу перевода формата (FF).
  • \n - Устанавливает соответствие символу перевода строки (LF).
  • \r - Устанавливает соответствие символу возврата каретки (CR).
  • \s - Устанавливает соответствие символу пробела.
  • \S - Устанавливает соответствие любому символу, кроме символа пробела.
  • \t - Устанавливает соответствие символу табуляции (HT).
  • \v - Устанавливает соответствие символу вертикальной табуляции (VT).
  • \w - Устанавливает соответствие символам - латинской букве, цифре или подчеркиванию.
  • \W - Устанавливает соответствие любому символу, кроме символов - латинской буквы, цифры или подчеркивания.
  • \n - Устанавливает соответствие n-ной запомненной подстроке (по количеству левых круглых скобок).
  • \0n - Устанавливает соответствие символу с восьмеричным кодом n.
  • \xn - Устанавливает соответствие символу с шестнадцатеричным кодом n.
  • \un - Устанавливает соответствие символу Unicode с шестнадцатеричным кодом n.