/* LECTURE_01 - типы данных */

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

/* горячие клавиши Notepade++

Alt + 0 - свернуть всё

Alt + Shift + 0 - развернуть всё

Ctrl + Alt + /Shift + F - свернуть/развернуть текущий блок

левая кнопка мыши (ЛКМ) - перетаскивает выделенный код

Ctrl + ЛКМ - копирует выделенный код

Alt + ЛКМ - прямоугольное выделение текста

Ctrl + Shift + Up/Down - перемещать строку вверх/вниз

Ctrl+BackSpace - удалить все слово (влево)

Ctrl+Delete - удалить все слово (вправо)

Ctrl+Shift+BackSpace - удалить с начала строки

Ctrl+Shift+Delete удалить до конца строки

Ctrl+U - конвертация букв в прописные буквы

Ctrl+Shift+U - конвертация букв в ЗАГЛАВНЫЕ БУКВЫ

Ctrl+B - перейти к скобке (только сначала выделите любую скобку)

Ctrl + D - дублировать строку или выделение

(в Notepade++ должен быть включен язык JavaScript)

Ctrl + /Shift/ + K - однострочный комментарий поставить/убрать

Ctrl + /Shift/ + Q - многострочный комментарий поставить/убрать

Автозавершение

функций - Ctrl + пробел

параметр функции - Ctrl + Shift + пробел

слова - Ctrl + Enter

путь - Ctrl + Alt + пробел

View > Always on Top - иногда удобно работать с браузером

F11 - убрать/вернуть меню

F12 - убрать/вернуть во весь экран

Ctrl + Num +/Num- - text zoom

Ctrl + Alt + /Shift + F - свернуть/развернуть текущий блок

*/

/* Способы подключения скриптов:

1. в head

2. в конце файла (чтобы не задерживать загрузку страницы)

3. подключение скрипта

Атрибуты подключения defer и async -

defer - скрипты срабатывают и выполняются последовательно

async - скрипты срабатывают и выполняются по мере загрузки

оба атрибута не стопорят работу html-кода на странице

верблюжьяНотация

переменные и функции - lowerCamelCase

классы - UpperCamelCase

константы - SCREAMING_SNAKE_CASE - змеиный регистр

желательно каждую логическую операцию заканчивать ";"

комментарий используют для отладки

//однострочный комментарий

/* многострочный комментарий */

/* макросы

сниппеты не пробовали ???

*/

/* отладка при помощи:

всплывающего окна

alert("Hello World"); (недостаток - прерывает выполнение кода html-страницы, не умеет выводить объекты (только примитивы))

вывода в консоль console.log("Hello World"); (открывается по нажатию F12)

набирать и выполнять код можно прямо в консоли

меток, которые выставляются в окне Sources (рядом с консолью (Console)) и останавливают выполнение кода в этом месте

debugger;

*/

/* use strict

директива

"use strict"; (к примеру, запрещает объявлять переменные без var)

прописывают в начале файла/в теле функции

*/

/* символы для именования переменных

azAZ09$_

var - локальное объявление переменной

*/

/* типы данных:

примитивы (5 штук):

number, string, boolean, null, undefined

объекты:

объект, массив, функция

*/

/* typeof

оператор typeof передаёт тип переданных данных

var x = 12;

console.log(typeof x);

*/

/* объект

var x = {

key1: "value1";

key2: "value2";

"key3": "value3"; (компрессор сжимает ключи, но всё, что в кавычках, считает строками и не трогает. Таким образом, кавычками можно запретить менять имя ключа, если это нарушает работу программы)

}

console.log(typeof x); // "object"

обращение к элементам объекта либо через точку:

x.key1 = "new value";

либо через квадратные скобки:

x["key2"] = "new value 2";

*/

/* массив

var x = ["element1", "element2", 25, {}, [], null];

console.log(typeof x); // "object"

Array.isArray(x); // true

обращение к элементам массива только через квадратные скобки с числом (номером элемента):

console.log(x[3]); // 25

x[3] = 56;

console.log(x[3]); // 56

добавление свойства объекта:

x.test = 123;

console.log(x.test); // 123

длина массива при добавлении свойства не меняется

*/

/* функция

var x = function () {};

console.log(typeof x); // "function" (исключение, typeof выдаёт не тип "объект", но тип "функция")

плохая практика - добавление функции свойств объекта:

x.key1 = "test";

console.log(x.key1); // "test"

*/

/* ссылочный тип

var x = ["123"];

console.log(x); // ["123"]

var y = x;

console.log(y); // ["123"]

меняем y:

y[0] = 345;

проверяем изменения в y:

console.log(y); // [345]

проверяем изменения в x:

console.log(x); // [345]

Объекты ссылаются на одно и то же место в памяти, соответственно, любой объект - ссылка на место в памяти.

*/

/* LECTURE_02 - операторы */

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

/* операнд

- то, к чему применяется оператор (число, строка, ..?)

операторы имеют приоритеты выполнения

*/

/* унарные операторы

+ унарный плюс (если поставить перед переменной со строкой, меняет на выводе тип со строки на число, но не меняет саму переменную)

var x = "-5";

console.log(+x); // -5

console.log(x); // "-5"

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

var x = "-5";

console.log(-x); // 5

console.log(x); // "-5"

Чтобы изменить саму переменную, присваиваем ей +x:

x = +x;

console.log("typeof x =", typeof x); // number

*/

/* операторы сравнения

за исключением некоторых случаев, стараются привести всё к числу, поскольку числа легко сравнить

операторы сравнения всегда возвращают булево значение

console.log(null == undefined); // true

console.log(null === undefined); // false

*** сравнение строк

сравнение идёт по коду символа посимвольно (первый символ с первым, второй со вторым, сравнение идёт до тех пор, пока не найдётся один символ, который больше/меньше другого):

console.log(x > y); // false (кто позже по алфавиту, тот и больше по коду символа)

console.log(x > Y); // true (код строчных символов больше кода ЗАГЛАВНЫХ, маленькие буквы больше больших)

console.log("tesa" > "tes"); // true, при равных частях, у левой части на один символ больше, значит, левая часть больше

console.log("1" > "2"); // false

console.log("12" > "2"); // false (1 < 2, дальше сравнение останавливается)

console.log(+"12" > +"2"); // true, унарный плюс приводит строку к числу

*** сравнение разных типов

console.log("2" > 1); true

console.log("1.0" == 1); true

console.log(true == 1); true (true приводится к 1, false приводится к 0)

console.log(false == ""); true

console.log(false == 0); true

*** сравнение null и undefined

null и undefined равны только друг другу

console.log(null == undefined); true

console.log(null > 0); false

console.log(null == 0); false

console.log(null >=0); true

console.log(null <=0); true

*/

/* логические операторы

логические операторы && и || не преобразуют возвращаемое значение к булевому виду. Из операторов можно строить цепочки.

&& - логическое и - останавливается на первом (левом или правом) ложном значении и возвращает его. Если в левой части true, то оно в любом случае возвращает правую часть оператора

|| - логическое или - останавливается на первом (левом или правом) истинном значении и возвращает его. Если в левой части false, то оно в любом случае возвращает правую часть оператора

! - логическое не - преобразует возвращаемое значение к булевому виду:

console.log(!4); // false

!! - двойное логическое "не" используется для приведения значения к булевому виду:

console.log(!!4); // true

0, "", false, null, undefined, NaN, ![], !{}, !function()== false;

!0, "some text", !false, !null, !undefined, !NaN, [], {}, function() == true;

5, -5, "asd" - дают true

*/

/* бинарные операторы

+

-

*

/

% - деление по модулю

*/

/* запятая, скобки, NaN

запятая имеет самый низкий приоритет (0)

var x = 10, y = 5, z = x + y; // 10 5 15

присвоение идёт слева направо

var z = x + y, x = 10, y = 5; // 10 5 NaN

Когда JS не может выполнить математическую операцию, он возвращает "не число" - "Not a Number" - "NaN"

NaN не равно ничему, даже самому себе.

if(NaN != NaN) {console.log("NaN != NaN");} // "NaN != NaN"

console.log(typeof NaN); // number

скобки имеют самый высокий приоритет (19)

var x = 5,6; // Uncaught SyntaxError: Unexpected number

var x = (5,6); // 6

*/

/* экранирование

обратный слэш экранирует символы в строке:

console.log('\" \! \\ \' ');

использование разных кавычек:

console.log('rest "test" qwest'); // rest "test" qwest

*/

/* побитовые операторы

практически не рассматривали

~ - побитовое "не" (тильда)

*/

/* операторы инкремента и декремента

в отличие от унарных, действительно меняют переменную и работают только с переменными (которые содержат числа)

префиксная форма и постфиксная

var x = 4;

console.log(++x); // 5

console.log(x); // 5

var y = 6;

console.log(y++); // 6

console.log(y); // 7

*/

/* условный оператор if, if else

использует нестрогое сравнение, типы могут приводиться

оператор не возвращает никакого значения

if(true) {

console.log("action");

}

Форма записи без фигурных скобок - действие записывается только в одну строку:

if(true)

console.log("action"); // нечитабельно, не рекомендуется записывать без фигурных скобок

*** if else

Если if выполняется, else пропускается.

else выполняется всегда, если не віполняется if

*** if() {}

else if() {}

else if() {}

else if() {}

else {}

*/

/* тернарный оператор

использует нестрогое сравнение, типы могут приводиться,

похож на if else, но в отличие от if обязательно возвращает значение

Если условие выполняется - возвращает "then" ("test"),

иначе возвращает "else" ("rest") */

// var x = /* if */ 10 > 5 ? /* then */ "test" : /* else */ "rest";

/* switch case

при сравнении использует строгое сравнение (===)

var x = "text";

switch (x) {

case "text":

console.log("Action 1");

break;

case "lost":

console.log("Action 2");

break;

case true:

console.log("Action 3");

default:

console.log("default action");

}

Использовать default не обязательно.

case's могут иметь общее действие:

var x = "text";

switch (x) {

case "text":

console.log("Action 1");

break;

case "lost":

case true:

console.log("Action 3");

default:

console.log("default action");

}

в case'ах могут стоять условия:

var dataType = null;

switch (true) {

case typeof dataType == "string":

console.log("Action 1");

break;

case typeof dataType == "number":

console.log("Action 2");

default:

console.log("default action");

}

*/

/* LECTURE_03 - циклы */

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

/* while

*/

/* do while

*/

/* for

for(var i = 0; i < 10; i++) {

console.log(i);

}

или

i = 10;

for (;i > 5;) {

i--;

console.log(i);

}

*/

/* директивы break и continue

Для прерывания цикла используют директивы break (останавливает цикл полностью) и continue (переходит на следующий шаг) - это работает для всех циклов.

var i = 0;

while (true) {

console.log(i);

i++;

if(i > 10) {

break;

}

}

var i = 0;

do {

console.log(i);

i++;

if(i > 10) {

break;

}

} while (i < 100);

for(var i = 0; i < 100; i++) {

console.log(i);

if(i > 10) {

break;

}

}

var i = o;

while(i < 10) {

i++;

if (i > 5 && i < 8) {

continue;

}

console.log(i);

}

do {

i++;

if (i > 5 && i < 8) {

continue;

}

console.log(i);

} while (i < 10);

for(var i = 0; i < 10; i++) {

if(i > 5 && i < 8) {

continue;

}

console.log(i);

}

Директивы break и continue нельзя использовать в тернарном операторе, т.к. он обязательно что-то возвращает, а директивы прерывают работу оператора - будет ошибка.

*/

/* Прерывание цикла по ключу.

Из дочерних циклов можно прерывать родительский (сам цикл (не родительский) тоже прервётся).

var i = 0;

outerFor: while (true) {

console.log("outer i=", i);

while (true) {

i++;

console.log("inner i =", i);

if(i > 10) {

break outerFor;

}

}

}

var i = 0;

outerFor: while (true) {

console.log("outer i=", i);

while (true) {

i++;

console.log("inner i =", i);

if(i > 10) {

break outerFor;

}

}

}

var i = 0;

outerFor: while (true) {

console.log("outer i=", i);

while (true) {

i++;

console.log("inner i =", i);

if(i > 10) {

break outerFor;

}

}

}

var i = 0;

outerFor: do {

console.log("outer i=", i);

do {

i++;

console.log("inner i =", i);

if(i > 10) {

break outerFor;

}

} while (true);

} while (true);

outerFor: for(var i = 9; ;) {

console.log("outer i =", i);

for(;;) {

i++;

console.log("inner i =", i);

if (i > 10) {

break outerFor;

}

}

}

outer: for(var i = 0; i < 100 ;) {

console.log("outer i =", i);

for(;;) {

i++;

console.log("inner i =", i);

if (i > 10) {

continue outer;

}

}

}

var i = 0;

outer: while(i < 30) {

console.log("outer i =", i);

while (true) {

console.log("inner i =", i);

i++;

if (i > 10) {

continue outer;

}

}

}

var i = 0;

outer: do {

console.log("outer i =", i);

do {

console.log("inner i =", i);

i++;

if (i > 10) {

continue outer;

}

} while (true);

} while(i < 30);

*/

/* for in, перебор свойств объекта

Цикл for in работает точно так же, но используется для перебора свойств объекта.

var object = {

key1: "value 1",

key2: "value 2",

key3: "value 3",

anyKeyName: "any data",

isObject: {

test: "test"

},

isArray: [1, 2, null]

}

Есть два способа обратиться к свойству объекта.

Через точку:

console.log(object.key1); // в key1 не может быть переменной

Или через квадратные скобки и ключ в виде строки:

console.log(object["key2"]); // в key2 может быть переменная

Именно это свойство (обращение через квадратные скобки) и используется в цикле for in:

for (var key in object) {

console.log(key);

console.log(object[key]);

}

Цикл не перебирает дочерние объекты или массивы - только то, что мы непостедственно передали в условии.

*/

/* for in, перебор свойств массива (не рекомендуется)

не рекомендуется перебирать свойства массива циклом for in, потому что, если у массива было какое-то свойство, то оно переберётся тоже:

var array = [1, 2, 4, "string", null];

// свойство:

// array.someKey = "some value"; // dicrease speed of work with array

for(var index in array) {

console.log(index);

console.log(array[index]);

}

*/

/* массивы

// arrays definition

var arr = [];

var arr = [1, "string", null];

var arr = new Array(); // []; (метод new конструктора Array)

var arr = new Array(1, "string", null); //[1, "string", null]

var arr = new Array(2); // [undefined, undefined];

console.log(arr.length);

console.log(arr[0]);

console.log(arr);

*/

/* недостаток работы с консолью

var arr = new Array(2); // [undefined, undefined];

console.log(arr.length);

console.log(arr[0]);

console.log(arr);

arr[0] = "test";

console.log(arr[0]);

arr[0] = "rest";

// arr[0] уже присвоено "rest", но консоль показывает console.log(arr[0]) - test, хотя, если раскрыть массив, то внутри будет верное значение. Чтобы не ошибаться, надо выводить в консоли свойства на уровне примитивов (а не объектов) или дебажить с брейкпоинтом.

*/

/* обращение к элементам массива

совершается по индексу:

array[1];

*/

/* array.lenth

есть у каждого массива, оно возвращает длину массива:

array.length;

с помощью array.length можно быстро очистить массив:

var array = [1, 2, "test"];

array.length = 0;

console.log(array); // пустой массив

так же, с помощью array.length можно быстро увеличить массив:

var array = [1, 2, "test"];

array.length = 10;

console.log(array); // массив на 10 элементов [1, 2, "test", undefined * 7]

*/

/* array.push

для добавления элемента в конец массива используется метод push, который возвращает новую длину массива?????????????или индекс??????????

var arr = [1, 2, 3];

console.log(arr.length); // 3

console.log(arr.push(10)); // 4

console.log(arr.length); // 4

arr.push("test") > 4 && console.log("We have a big array!");

// или

var newLength = arr.push("rest");

console.log(newLength);

*/

/* Array.isArray

проверяет, что элемент является именно массивом, возвращает true или false

var arr = [1, 2, 3];

console.log(Array.isArray(arr));

*/

/* LECTURE_04 - функции */

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

/* Функция

всегда возвращает какое-то значение (либо то, что прописано в return, либо undefined)

Если функция является свойством какого-либо объекта, лна называется метод.

Функции, объявленные как Function Declaration, создаются интерпретатором до выполнения кода.

В то же время, Function Declaration при use strict видны только внутри блока, в котором объявлены. Поэтому, если мы не хотим получить ошибку, то Function Declaration нужно осуществлять вне блоков кода (if, for, etc...), "снаружи".

А Function Expression создаются в процессе выполнении выражения, в котором созданы, поэтому могут быть заданы в любом месте кода.

Функциональное выражение, которое не записывается в переменную, называют анонимной функцией.

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

Существует ещё один способ создания функции, который используется очень редко, но упомянем и его для полноты картины - при помощи new Function.

Он позволяет создавать функцию полностью «на лету» из строки, вот так:

var sum = new Function('a,b', ' return a+b; ');

var result = sum(1, 2);

console.log(result);

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

// It's function // functional declaration

function fn () {}

var object = {};

// It's method

object.method = function () {};

// It's functional expression

var functionX = function () {};

// Именованное функциональное выражение

var functionX = function fnName() {};

// рекурсия

var functionX = function fnName() {

if(true) {

fnName();

}

};

// объявление функции через конструктор new Function:

var newFnName = new Function("x", "return x");

console.log(newFnName(256));

*/

/* анонимная самовызывающаяся функция (будет сразу вызвана)

Для того, чтобы вызвать функцию, мы оборачиваем её в скобки. Всё, что в скобках - выражение, а выражение обязательно выполняется. Кстати, если в качестве возвращаемого значения в тернарный оператор записать функцию, то она сработает без оборачивающих скобок, потому что тернарный оператор и так является выражением. Так же без скобок сработает функция и в операции сравнения, главное, не забывать указывать скобки после функции, иначе такой вызов вернёт тело функции.

(function() {

console.log("test 1");

}) ();

(function() {

console.log("test 1");

}());

*/

/* именованная самовызывающаяся функция

(function privatName(x) { //(x)==(var x = x)

console.log(x);

if (x < 1) {

privatName(x + 1); // рекурсия

}

}) (0);

(functionprivatName() {

console.log(x);

if (x < 1) {

privatName(x + 1); // рекурсия

}(0));

var test = (function privatName(x) {

if (x < 10) {

return privatName(x + 1);

}

return x;

}) (0);

console.log(test);

*/

/* функции в объектах

в следующем примере - это лишь элементы массива:

var arrayWithFunctions = [

function () {return 0;},

function () {return 1;},

function () {return 2;}

];

// а вот ниже - это уже метод:

arrayWithFunctions.methodOfArray = function () {return "I'm a method"};

console.log(arrayWithFunctions[1]());

console.log(arrayWithFunctions.methodOfArray());

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

function fnName() {

return "I'm a function";

}

fnName.methodOfFunction = function() {

return "I'm a method";

}

console.log(fnName); // без скобок мы увидим тело функции

console.log(fnName()); // I'm a function

console.log(fnName.methodOfFunction()); // I'm a method

console.log(fnName["methodOfFunction"]()); // I'm a method

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

function fnName() {

return "I'm a function";

}

var newFunction = fnName;

// newFunction - это новая ссылка на старую функцию, которая может работать точно так же в том же коде

console.log(newFunction()); // I'm a function

console.log(newFunction.methodOfFunction()); // I'm a method

// и даже если написать в эту переменную другое значение,

newFunction = null;

// то ИСХОДНАЯ функция от этого никак не изменится и не пострадает:

console.log(fnName()); // I'm a function

console.log(fnName.methodOfFunction()); // I'm a method

*/

/* локальная переменная arguments

в каждой функции есть псевдо-массив arguments -

это массив тех значений (аргументов), которые передали в функцию.

Функция может и вовсе не ожидать ни одного аргумента, но при этом получить их и работать с ними:

function test () {

console.log(arguments);

var x = Array.apply(null, arguments); // методы apply и call первым параметром передают контекст, а нам контекст не нужен, поэтому мы и указали null

console.log("argumentsToX", x); // получили полноценный массив x с копией элементов из псевдо-массива arguments

}

console.log(test(1, 2, [], {}, null, undefined));

*/

/* область видимости

с областью видимости в JS всё логично.

по окончании работы функции, все переменные, которые были заданы внутри функции, удаляются (за одним исключением - тема отдельной лекции), этот механизм называется "garbage collection" :)

throw - это оператор, который "бросает" в консоль ошибку и останавливает выполнение кода

function getAllNulls (array) {

if (!Array.isArray (array)) {

throw ("Attribute array is not array");

console.log("eryjy"); // строка не выводится, работа функции остановлена в строке выше

}

var nullsArray = [];

for (var i = 0; i < array.length; i++) {

if (array[i] === null) {

nullsArray.push (array[i]);

}

}

return nullsArray;

}

console.log(getAllNulls([1, 23, "asd", null, undefined, [1, 2, null], {"null": null}, null]));

console.log(getAllNulls("fuhuygty"));

*/

/* LECTURE_05 */

/* LECTURE_06 */

/* LECTURE_07 - объекты, массивы */

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

/* создание объекта

// через фигурные скобки

var obj = {};

// через конструктор класса

var obj = new Object();

// сразу задавать свойства (два способа ниже идентичные и не имеет значения, сразу мы добавляем значения, или постепенно)

// 1

var obj = {

key1: "value1",

key: null,

"user": {

"firstname": "Vasya",

lastname: "Sidorov"

}

};

// 2

var object = {};

object.key1 = "value1";

object.key2 = null;

object["user"] = {

"firstname": "Vasya",

lastname: "Sidorov"

};

// свойством объекта может быть любая сущность, в т.ч. и другой объект, функция (которая в таком случае называется методом объекта), массив, массив с другими объектами, JS не накладывает ограничений

*/

/* удаление объекта

var obj = {

key1: "value1",

key: null,

"user": {

"firstname": "Vasya",

lastname: "Sidorov"

}

};

console.log(object.key1);

delete object.key1;

console.log(object.key1);

*/

/* два способа проверить, есть ли в объекте СВОЙСТВО или нет

var obj = {

key1: "value1",

key: null,

"user": {

"firstname": "Vasya",

lastname: "Sidorov"

}

};

// delete object.key1;

object.key1 = undefined;

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

object.key1 = undefined;

// способ 1 проверяем на undefined

if (object.key1 !== undefined) {

console.log("No result"); // "нет вывода"

// при простом сравнении, наличие такого свойства будет неотличимо от его отсутствия.

}

// способ 2 используем оператор in

if ("key1" in object) {

console.log("Has result"); // "Has result"

}

// во втором случае видим, что свойство находится, несмотря на удаленное свойство. Почему? Потому что даже если значение свойства равно undefined, оператор in даёт true. Оператор in гарантирует правильный результат

*/

/* перебор свойств объекта (2 основных способа)

// цикл for in выдаёт на каждой итерации ИМЯ свойства объекта

for (var key in object) {

console.log(object[key]);

}

// свойства выводятся в том порядке, в котором они были записаны в объект (null, Object, undefined), новые свойства добавляются в конец. Но есть исключение: положительные числовые свойства (строки) выводятся первыми и в порядке возрастания

var object = {

"10": "value3",

"1": "value1",

"25": "value2",

"test1": "value4",

"asd": "value5",

"15": "value6"

};

for (var key in object) {

console.log(object[key]);

} // value1,value3,value6,value2,value4,value5

// или выведем сами ключи для наглядности:

for (var key in object) {

console.log(key);

} // 1,10,15,25,test1,asd

*/

/* перебор свойств объекта методом Object.keys() с получением массива ключей. Для этого у базового класса Object есть метод keys, он принимает в себя объект и возвращает массив его ключей

var obj = {

"10": "value3",

"1": "value1",

"25": "value2",

"test1": "value4",

"asd": "value5",

"15": "value6",

"+11": "value7"

};

var keysArr = Object.keys(obj);

console.log(keysArr);

// Object.keys() выводит только собственные свойства массива

*/

/* выводим свойства объекта [ пары ключ/значение ]

var obj = {

"10": "value3",

"1": "value1",

"25": "value2",

"test1": "value4",

"asd": "value5",

"15": "value6",

"+11": "value7"

};

var keysArr = Object.keys(obj);

for (var i = 0; i < keysArr.length; i++) {

console.log( keysArr[i], obj[keysArr[i]] ); // keysArr[i] - ключ, obj[keysArr[i]] - значение

}

// цикл for() выводит не только собственные свойства массива, но и наследуемые (свойства прототипа)

*/

/* примитивы копируются по значению, а объекты копируются по ссылке

*/

/* атрибуты свойств

Основной метод для управления свойствами – Object.defineProperty.

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

Синтаксис:

Object.defineProperty(obj, "propName", {

enumerable: true,

writable: false

})

Аргументы:

obj

Объект, в котором объявляется свойство.

propName

Имя свойства, которое нужно объявить или модифицировать.

descriptor

Дескриптор – объект, который описывает поведение свойства.

В нём могут быть следующие поля:

value – значение свойства, по умолчанию undefined

writable – значение свойства можно менять, если true. По умолчанию false.

configurable – если true, то свойство можно удалять, а также менять его в дальнейшем при помощи новых вызовов defineProperty. По умолчанию false.

enumerable – если true, то свойство просматривается в цикле for..in и методе Object.keys(). По умолчанию false.

get – функция, которая возвращает значение свойства. По умолчанию undefined.

set – функция, которая записывает значение свойства. По умолчанию undefined.

Чтобы избежать конфликта, запрещено одновременно указывать значение value и функции get/set. Либо значение, либо функции для его чтения-записи, одно из двух. Также запрещено и не имеет смысла указывать writable при наличии get/set-функций.

*/

/* зададим свойство

два таких вызова работают одинаково:

var user = {};

// 1. простое присваивание

user.name = "Вася";

// 2. указание значения через дескриптор

Object.defineProperty(user, "name", { value: "Вася", configurable: true, writable: true, enumerable: true });

*/

/* свойство-константа

// Для того, чтобы сделать свойство неизменяемым, изменим его флаги writable и configurable:

"use strict";

var user = {};

Object.defineProperty(user, "name", {

value: "Вася",

writable: false, // запретить присвоение "user.name="

configurable: false // запретить удаление "delete user.name"

});

// Теперь попытаемся изменить это свойство.

// в strict mode присвоение "user.name=" вызовет ошибку

user.name = "Петя";

// Заметим, что без use strict операция записи «промолчит» но не сработает. Лишь если установлен режим use strict, то дополнительно сгенерируется ошибка.

*/

/* атрибут: принимаемые_значения - коментарий

value: number/string/object etc. - значение свойства

configurable: true/false - добавление и удаление свойств

writable: true/false - редактирование свойств

enumerable: true/false - доступность свойства при переборе в for...in

*/

/* функции-перехватчики get: и set:

GET (перед выдачей, отдаёт значение в функцию)

get: function() {} - cвойство-функция, связывает свойство объекта с функцией, которая будет вызываться при обращении к этому свойству.

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

Синтаксис:

геттер может иметь идентификатор, который является либо числом, либо строкой;

он должен иметь только нулевые параметры;

он не должен появляться в объектном литерале вместе с другим get или через ввод данных для того же свойства:

ЗАПРЕЩЕНЫ

{ get x() { }, get x() { } }

{ x: ..., get x() { } }

Геттер можно удалить при помощи оператора delete.

примеры:

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

var log = ['test', 'fest'];

var obj = {

get latest () {

if (log.length == 0) return undefined;

return log[log.length - 1];

}

}

console.log (obj.latest); // вернет "fest"

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

delete obj.latest;

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

var obj = { a:0 }

Object.defineProperty(obj, "b", { get: function () { return this.a + 1; } });

console.log(obj.b) // Runs the getter, which yields a + 1 (which is 1)

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

SET (перехватывает присылаемое значение в функцию перед его установкой)

set: {set prop(val) { . . . }}

{set [expression](val) { . . . }}

cвязывает свойство объекта c функцией, которая будет вызвана при попытке установить это свойство.

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

Синтаксис:

Он может иметь идентификатор, который является либо числом, либо строкой;

Он должен иметь ровно один параметр;

Он не должен появляться в виде литерала объекта с другим набором или с вводом данных для того же свойства:

ЗАПРЕЩЕНЫ

{ set x(v) { }, set x(v) { } }

{ x: ..., set x(v) { } }

Сеттер можно удалить при помощи оператора delete.

примеры:

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

var language = {

set current (name) {

this.log.push(name);

},

log: []

}