Нагадайки-поясняйки

Escape characters
\n — перенос рядка
console.log("1\n2\n3\n4");
\t — табуляція (горизонтальна)
console.log("1\t2\t3\t4");
\ — екранування наступного символа. Екранований символ просто відображається як текст, а не використаний як спеціальна штука з мови програмування. Наприклад:
console.log("ці лапки \"заекрановані\", тому все відобразиться");
console.log("ці лапки не "заекрановані", тому буде помилка");
​
/*
Помилка буде, бо без екрану це перетворюється на 2 окремих рядка 
    "ці лапки не "
та
    ", тому буде помилка"
а між ними - якась незрозуміла для комп'ютера фігня, яка все ламає
*/
Увага:  \n,  \t та інші escape characters треба екранувати разом із їх бекслешем:
console.log("Перенос рядка")
console.log("екранований: a1\\nb");
console.log("не екранований: a\nb");
console.log("\nТабуляція")
console.log("екранована: a\\tb");
console.log("не екранована: b\tb");
// і т.д. і т.п.
Не лякайтесь посилання: крім \n,  \t та екранованих лапок вам на Zero інші escapes не знадобляться :)
p.s. Конкретно лапки можна вставляти в рядки й без екрану, якщо вони різних типів:
console.log("одинарні 'в' подвійних");
console.log('подвійні "в" одинарних');
console.log(`а у бектіках 'взагалі' "що'''" завгодно"''чудить" можна :)`);
// https://ru.wikipedia.org/wiki/%D0%93%D1%80%D0%B0%D0%B2%D0%B8%D1%81
// це та кнопка, де тільда (~), тільки без Shift (у EN або US розкладках)
Про =, == та ===
Різниця між =, == та === в JavaScript (приклади)
Літерали
Літерал — це "голе" значення. Умовно кажучи: те, що можна покласти до змінної. Наприклад:
let n = "222";
n = 100500;
​
console.log(n + ", " + 12345);
n = true;
У цьому прикладі літерали — це:
 "222"
100500
", "
12345
true
Скорочення
Числа
Штуки типу i = i + 2 або i = i + "*"варто скорочувати через +=. 
Довго
Коротко
i = i + 123
i +=  123
i = i + "*"
i += "*"
i = i + ":)"
i += ":)"
i = i + "\n"
i += "\n"
i = i - 15
i -= 15
i = i * -3
i *= -3
i = i / 7.98
i /= 7.98
Це працює і зі змінними, і з літералами. Звісно, змінна може називатись не лише i
Якщо треба додати / відняти саме одиницю, є ще коротші форми: інкремент та декремент.
Дуже довго
Довго
Гарнюня
i = i + 1
i += 1
i++
i = i - 1
i -= 1
i--
Увага: = в інкременті не треба. Треба просто i++ або i--: як є, без нічого. Умовно кажучи, у цих спецсимволах = вже "вшитий під капотом".
Запис типу i = i++ або i = i-- працюватиме, але це неправильно і нівелює саму суть скорочення запису.
Запустіть код та читайте консоль
let n = 2; // замість 2 може бути будь-яке число
console.log("Початкове значення: " + n);
console.log("тип n зараз: " + typeof n)
​
console.put("\n" + n);
n += 27; // те саме, що й n = n + 27
console.log(" += 27 🠖 " + n)
​
console.put("\n" + n);
n -= 8; // n = n - 8
console.log(" -= 8 🠖 " + n);
​
console.put("\n" + n);
n *= 3.14; // n = n * 3.14
console.log(" *= 3.14 🠖 " + n);
​
console.put("\n" + n);
n /= 0.123; // n = n / 0.123
console.log(" /= 0.123 🠖 " + n);
​
​
// до речі, += працює ще й для конкатенації (зклеювання рядків)
console.put("\n" + n);
n += "якийсь рядок";
console.log(" += \"якийсь рядок\" 🠖 " + n);
​
// але після цього, звісно, n сама стане рядком
console.log("\nтип n зараз: " + typeof n)
​
// тобто:
console.put("\n" + n);
n += 100500;
console.log(" += 100500 🠖 " + n + "\n");
​
console.put ("від 0, n++: ");
n = 0;
while (n < 10) {
    console.put(n++ + " ");
}
​
console.put("\nвід 0, ++n: ");
n = 0;
while (n < 10) {
    console.put(++n + " ");
}
boolean
! — логічне заперечення, логічне "не". 
let n;
​
// !n — те саме, що "не n", "щось протилежне n"
n = true; // спробуйте змінити це значення, пограйтесь
console.log("n = " + n);
console.log("!n = " + !n);
​
// !n не змінює вміст змінної
console.log("n все ще = " + n);
// щоб змінити:
n = !n;
console.log("хоба: n = " + n);
​
// у if, циклах та інших умовах, які зводяться до boolean, можна ще так:
​
if (n) {
    console.log("if(n) спрацював, n = " + n + " зараз");
}
​
if (!n) {
    console.log("if(!n) спрацював, n = " + n + " зараз");
}
​
if (n) {
    console.log("а це IF з if-else, n = " + n + " зараз");
} else {
    console.log("а це ELSE з if-else, n = " + n + " зараз");
}
Тернарний оператор
Тернарний оператор — це коротка (та з парою особливих фіч) заміна if else для випадків, коли є лише 2 можливих варіанти розгалуження, а кожна дія може бути записана одним рядком коду.
У звичайного if else структура така:
if(якщо тут true) {
    то виконай цей код
} else {
    інакше, тобто якщо false, виконай цей код
}
А тернарним оператором те ж саме записується так:
якщо тут true ? то виконай цей код : інакше, тобто якщо false, виконай цей код
Тобто, наприклад
let number = 3;
let message;
​
if (number > 3) {
    message = "number більше 3";
} else {
    message = "number менше або дорівнює 3";
}
З тернарником скорочується до
let number = 3;
let message = number > 3 ? "number більше 3" : "number менше або дорівнює 3";
А якщо звернути увагу, що в обох варіантах початок та кінець повторюються, можна ще коротше:
let number = 3;
let message = "number " + (number > 3 ? "більше" : "менше або дорівнює") + " 3";
Тут слід пам'ятати, що тернарник, на відміну від if else — це окрема незалежна сутність (як масив, наприклад). І тому, якщо треба результат передати до функції, не треба викликати її саму в тернарнику двічі поспіль. Можна сам тернарник передати, як аргумент 😉
 
Тобто, краще не писати так:
let number = 3;
number > 3 ? console.log("number більше 3") : console.log("number менше або дорівнює 3");
А замість того писати так:
let number = 3;
console.log("number " + (number > 3 ? "більше" :" менше або дорівнює") + " 3");
Вкладені тернарники
Як if else можуть вкладатись одне в одного, так і тернарники можуть бути вкладеними в інші тернарники.
let number = 3;
console.log("number " + (number > 3 ? "більше" : number < 3 ? "менше" : "дорівнює") + " 3");
Кількість рівнів вкладеності необмежена.
У цій кракозябрі легко заплутатись, але тернарник у більшості випадків нормально розуміє перенос рядків, тому можна записати якось так:
let number = 3;
console.log("number " +
    (number > 3 ? "більше"
        : number < 3 ? "менше"
            : "дорівнює")
    + " 3");
    
// або взагалі так, щоб максимально схоже на if else
console.log("number " +
    (number > 3 
        ? "більше"
        : number < 3 
            ? "менше"
            : "дорівнює")
    + " 3");
Це теж далеко не зразок читабельності. Але вже набагато більше схоже на знайомі if else. Та одночасно непогано демонструє вкладені один у одного тернарники.
Проте, якщо доводиться щось таке писати, то тернарник майже 100% буде не найкращим рішенням. Тому що він про скорочення, а тут не дуже й коротко; ну а без переносів це не дуже читабельно.
Тож дійте за обставинами, керуйтесь здоровим глуздом і не туліть всюди тернарники замість if else без необхідності, а просто тому, що це якась прикольна штука 😉
 
Остача від ділення націло (%)
Якщо ви гуглили, що воно таке, то, скоріш за все, натикались на статтю з Вікіпедії. Якщо зрозуміли - круто. Але якщо той математичний канцелярит не зайшов, є простіше пояснення.
Є a % b . Беремо найбільше число, кратне b, яке менше або дорівнює a . Віднімаємо від a це число. Отримана різниця - і є результат. На прикладі 10 % 3: найближче до 10, яке можна націло розділити на 3 (тобто кратне 3) - це 9. 10 - 9 = 1. Тобто10 % 3 буде 1.   
Ось демо-код. Повводьте туди різні числа, в т.ч. від'ємні та не цілі (6.21 і т.п.). І дивіться, що буде.
let number, divider, operatorResult, loopResult;
​
number = +prompt("Введіть число");
while (typeof number !== "number" || isNaN(number)) {
    number = +prompt("Некоректне число, введіть нормальне");
}
​
divider = +prompt(`${number} % `);
while (typeof divider !== "number" || isNaN(divider) || divider === 0) {
    divider = +prompt("На це не можна ділити. Спробуйте знову\n" + number + "%");
}
​
operatorResult = number % divider;
console.log(`${number} % ${divider} => ${operatorResult}\n`);
​
console.log("Чому так:");
loopResult = Math.abs(number);
​
if (divider < 0 || number < 0) {
    console.log("Увага! Від'ємні беремо по модулю\n");
    divider = Math.abs(divider);
}
​
while (divider > 0 && loopResult >= divider) {
    console.log(`${loopResult} - ${divider} = ${loopResult - divider}`);
    loopResult -= divider;
}
​
console.log(`\nОстача (${loopResult}) менша за дільник (${divider}).`);
​
if (number < 0) {
    loopResult = -loopResult;
}
​
console.log(`От вона і є результат: ${loopResult}`);
if (number < 0 && loopResult !== 0) {
    console.log("(вже не по модулю, звісно)");
}
Яке у цього практичне застосування? Та дуже просте. Якщо остача a % b === 0, то a ділиться без остачі на b. Тобто a кратне b. Так, наприклад, можна перевірити число на парність/непарність,  визначивши, чи кратне воно двійці. Або можна дізнатись, скільки мінімум автобусів потрібно для перевозки групи a туристів, якщо в кожному автобусі - максимум b місць. Або ще щось таке, придумайте самі :)
Складання у змінну
Інколи (навіть часто), коли в циклах щось виводимо на консоль, замість 100500 разів просто виводити щось на кожній ітерації, корисніше та зручніше — складати значення до змінної (додавати до неї, конкатенувати з нею) а потім один раз виводити саме цю змінну.
Тобто замість
for(let i = 0; i < 10; i++) {
    console.put(i);
}
якось типу так
let buffer = "";
for(let i = 0; i < 10; i++) {
    buffer += i;
}
console.log(buffer);
Приведення типів
Найчастіші процедури на Zero
let n;
​
console.log()
n = "123"; // рядок
n = +n; // число
n = +"123" // так теж можна
​
// ЧИСЛО В РЯДОК
n = 123; // це число
n += ""; // будь-що складаємо з рядком — отримуємо рядок
Таблиця конвертацій
Табличка звідси​
Значення
Перетворене на число
Перетворене на рядок
Перетворене на boolean
false
0
"false"
false
true
1
"true"
true
0
0
"0"
false
1
1
"1"
true
"0"
0
"0"
true
"000"
0
"000"
true
"1"
1
"1"
true
"20"
20
"20"
true
""
0
""
false
"twenty"
NaN
"twenty"
true
NaN
NaN
"NaN"
false
Infinity
Infinity
"Infinity"
true
-Infinity
-Infinity
"-Infinity"
true
null
0
"null"
false
undefined
NaN
"undefined"
false
[ ]
0
""
true
[20]
20
"20"
true
[10,20]
NaN
"10,20"
true
Скоуп 
Скоуп (область видимості) — це шматок кода всередині{ }
for(1) {
    for(2) {
        while(3) {
​
        }
    }
    for(4) {
        
    }
}
Цикли 2, 3 та 4 входять до скоупу 1.
3 входить до скоупів 1 та 2.
4 входить до скоупу 1.
І є ще глобальний скоуп, куди входять вони всі разом. Це "нульовий" рівень, тобто ВЕСЬ код в редакторі. Можете уявити, що весь код в IDE загорнутий у верховні невидимі { }.
{ // це типу умовна "невидима верховна дужка" початку глобального скоупу
for(1) {
    for(2) {
        while(3) {
​
        }
    }
    for(4) {
        
    }
}
} // а це — верховна дужка кінця. теж умовна і невидима
Змінні зі внутрішнього скоупу "бачать" зовнішні. Але із зовнішнього скоупу не видно внутрішні.
let n = 100500;
for (let i = 0; i < 10; i++) {
    n++; // так можна, бо ми звертаємось "назовні"
    console.log(i); // так можна, бо i оголошена в цьому ж скоупі
    for(let j = 0; j < 10; j++) {
        console.log(i); // можна, бо теж ідемо в зовнішній скоуп
        console.log(j); // можна
    }
    console.log(j); // а так не можна, буде помилка, бо в цьому скоупі вже нема j
}
Тобто правило просте: назовні — бачимо, всередину — ні.
Цикли
Тіло цикла — все, що знаходиться всередині цикла { тут }
for() {
    тіло цикла
}
​
while() {
    тіло цикла
}
​
do {
    тіло цикла
} while();
Структура циклів
Якщо треба повторити дії конкретну кількість разів, то юзаємо for.
Якщо вказати кількість повторів заздалегідь неможливо: while.
Якщо треба зробити щось незалежно від обставин як мінімум 1 раз, а далі — по ситуації: do while
​
for
for(1; 2; 3)
1: місце для створення однієї або кількох змінних (якщо кілька — через кому)
2: вираз або змінна, який цикл конвертує в boolean (див. табличку вище).  Доки 2 буде true, цикл повторюватиметься. Якщо стане false — цикл перерветься.
3: дії, які виконаються в кінці кожної ітерації
for (let i = 0, j = 10, k = true; i < 25; i++, j--, k = !k) {
    console.log(`i=${i}\tj=${j}\tk=${k}`)
    if (i > 0 && i % 5 == 0) {
        console.log(":)\n")
    }
}
У цьому прикладі:
1: let i = 0, j = 10, k = true
2: i < 25
3: i++, j--, k = !k
Увага: 1, 2 та 3 входять в скоуп цикла, в якому вони створені.
while
Те саме, що for, але має лише блок 2. 1 Треба руками записувати перед циклом десь ззовні, а 3 — в тілі циклу (дляповної тотожності — в самому кінці перед }.
let i = 0, j = 10, k = true;
while (i < 25) {
    console.log(`i=${i}\tj=${j}\tk=${k}`)
    if (i > 0 && i % 5 == 0) {
        console.log(":)\n")
    }
    i++;
    j--;
    k = !k;
}
do while
do {
    X
} while (Y);
Що б там не було, бодай 1 раз виконати все, що в X. Потім перевірити, чи Y == true. Якщо так — повторювати X доти, доки Y == true
let i = 0, j = 10, k = true;
do {
    console.log(`i=${i}\tj=${j}\tk=${k}`)
    if (i > 0 && i % 5 == 0) {
        console.log(":)\n")
    }
    i++;
    j--;
    k = !k;
} while (i < 25);
continue та break
continue: "ігнорувати весь код в наступних рядках та перейти до наступної ітерації цикла"
break: "завершити цикл" (точно так же, як якщо б в блоку 2 стало false)
​
Увага: continue та break впливають лише на свій скоуп і не чіпають зовнішній. Умовно:
for(let i = 0; i < 10; i++) {
    for(let j = 0; j < 10; j++) {
        if (щось) {
            break; // тут перерветься лише j-цикл. А i-цикл продовжиться
        }
        if (ще щось) {
            continue; // перейде до наступної ітерації j, а на i не вплине
        }
    }
}
Брейкати зовнішні скоупи можливо, але це не знадобиться на Zero.
А взагалі варто уникати continue та break. В тому сенсі, що, якщо можливо без них — робіть без них. Вони не про "коли завершити" а "якщо щось трапилось — завершити".
Повну різницю між ними зрозумієте на курсі P2P CS. 
Ну типу, навіщо робити якось так:
let i = 0;
while (true) {
    console.log(i);
    if (i == 10) {
        break;
    }
    i++;
}
​
// або взагалі
for (let i = 0; ; i++) {
    console.log(i);
    if (i == 10) {
        break;
    }
}
коли сама структура циклів підштовхує робити так:
let i = 0;
while (i <= 10) {
    console.log(i);
    i++;
}
​
//ну і відповідно
for (let i = 0; i <= 10; i++) {
    console.log(i);
}
break / continue доречні, коли треба зреагувати на щось, що виникає внаслідок роботи самого циклу. Наприклад:
let inputText;
let counterA = 0;
let counterB = 0;
while (true) {
    counterA++;
    inputText = prompt("Введи щось");
​
    if (inputText == "пропусти") {
        alert("Ок, на цій ітерації counterB не збільшуємо");
        continue;
    }
​
    if (inputText == "зупинись") {
        break;
    }
​
    counterB++;
}
​
console.log("counterA = " + counterA + "\ncounterB = " + counterB);
Коротше кажучи, у більшості випадків, якщо цикл переривається через break, а не через умову переривання в голові цикла — з алгоритмом щось не так, і його варто оптимізувати.
Довго	Коротко
`i = i + 123`	`i += 123`
`i = i + "*"`	`i += "*"`
`i = i + ":)"`	`i += ":)"`
`i = i + "\n"`	`i += "\n"`
`i = i - 15`	`i -= 15`
`i = i * -3`	*`i = -3`**
`i = i / 7.98`	`i /= 7.98`
Дуже довго	Довго	Гарнюня
`i = i + 1`	`i += 1`	`i++`
`i = i - 1`	`i -= 1`	`i--`
Last modified 6mo ago
Значення	Перетворене на число	Перетворене на рядок	Перетворене на boolean
false	0	"false"	false
true	1	"true"	true
0	0	"0"	false
1	1	"1"	true
"0"	0	"0"	true
"000"	0	"000"	true
"1"	1	"1"	true
"20"	20	"20"	true
""	0	""	false
"twenty"	NaN	"twenty"	true
NaN	NaN	"NaN"	false
Infinity	Infinity	"Infinity"	true
-Infinity	-Infinity	"-Infinity"	true
null	0	"null"	false
undefined	NaN	"undefined"	false
[ ]	0	""	true
[20]	20	"20"	true
[10,20]	NaN	"10,20"	true