Учимся!

1. Переменные .js

// Переменная - Variable (вериабл)

// 1.1. Переменная - это "коробка", в которой может храниться что угодно. 
// Буквально всё.

let // - это команда для объявления переменной в коде. Чтобы она появилась.

// Цифры в переменных
let a = 5
let b = 5.55
let c = 0.123423532

// Текст в переменных
let d = "Привет"
let e = "Люблю Россию, как свою любовь"

// Булеан (boolean: true / false)
let f = true
let g = false



// 1.2.
// С переменными можно проводить множество операций!

// Замена значения
let f = 5
f = 6 // теперь в f хранится 6, а не 5

// Cложение, умножение, деление и любые другие математические операции
let a = 5
let b = 10
let c = a + b // тут теперь хранится 15

2. Типы данных .js

// Тип - Type (тайп)

// 2.1. В любом языке программирования есть типы данных (типизация).
// Тип данных - это то, чем являются данные.

// 2.2. Строки (звать String)
let a = "привет";
let a1 = 'илья, ' + "привет"; // -> илья, привет

// 2.3. Целые числа (звать Integer)
let b = 5;
let b1 = -11;

// 2.4. Числа с плавающей (floating) точкой (звать Float или Decimal)
let c = 0.3423;
let c1 = 1/2;

// 2.5 Объект (звать Object)
let human_ivan = {
    name: "Иван",
    lastname: "Иванов"
}
// Объект очень полезен, чтобы хранить информацию "в пакете"
// Не будем же мы разбрасывать информацию о человеке в миллионах переменных.
// Информацию хранят в таких пакетах. Структурировано.
// Её можно достать так:
human_ivan.name // -> "Иван"

// 2.6 Массив (звать Array)
// В них можно хранить любую дичь: 
// числа, текст, объекты и даже массивы, и даже массивы с объектами, в нутри которых есть массивы!
let array = [1,2,3,4];
let array1 = ["глеб", 'никита', 'демур', 'женя'];
let array2 = [6, 3, "привет", 2.75, 6/2]; // -> [6, 3, "привет", 2.75, 3];
let array3 = [
    {name: "иван", lastname: "иванов", friends: ["илья", "глеб"]},
    {name: "петр", lastname: "петрович", friends: ["максим", "славик"]}
];
let array4 = [
    [4, 5, 6, 7],
    [8, 9, 1, 2]
];

3. Сложение .js

// 3.1 Сложение
// Складывать можно по-разному! 
// Главное, чтобы не подавиться своим же хуем от своей крутости
let a = 1;
a++; // -> 2
a+=1; // -> 3
a=a+1; // -> 4
a-=-1; // -> 5
a-=1; // -> 4

a = "привет"; // переменная 'a' теперь носит "привет", а не 4
a += ", илья"; // -> привет, илья
a = a+"!"; // -> привет, илья!


// 3.2 Сложение разных типов
// В сложении переменных одинаковых типов всё понятно:
let a = 5
let b = 5
let c = a + b // -> 10

// Но что делать, если одна переменная - цифра, а другая текст?
let a = "5"
let b = 5
let c = a + b // -> ???
// В этом случае JS переводит b в ТЕКСТ и получается:
c = "5" + "5" // -> "55"
// Это порадило огромное количество мемов, где JS шеймили за "1"+1 = "11"
// Однако все логично и правильно:
// - Данные с разными типами нельзя складывать, а если это и происходит, то JS просто помогает их прировнять к одному типу.
// - Разработчик может сам установить правильный тип:
let a = "5"
let b = 5
let c = Number(a) + b // -> 10
// В этом случае Number(a) превратило и вернуло переменную внутри себя (a) в виде числа.
// Корочи просто преобразовало текст в число.

4. Условия .js

// Условие - Condition (кондишн)
// Если - If (иф)
// Иначе - Else (элс)

// 4.1 Условия
let a = 5;
let b = 6;

// 4.2. просто условие
if(a > b){
    // идёт сюда, если: a больше b
}

// 4.3. условие с "иначе"
if(a == b){
    // идёт сюда, если: а равно b
}else{
    // идёт сюда, если: a НЕ равно b
}

// 4.4. условие с несколькими условиями
if(a == 4){
    // идёт сюда, если: a равно 4
}else if(a==5){
    // идёт сюда, если: a равно 5 
}else if(a == 6){
    // идёт сюда, если: a равно 6
}

5. Работа с массивами .js

// Массив - Array (эрей)
// Длина - Length (ленгф)

// Массивы - это очень круто!
// Без них код 20 лет назад выглядил очень плохо.
// Представим ситуацию, что нам нужно где-то хранить 5 чисел.
// Раньше было так:
let num1 = 5
let num2 = 3
let num3 = 7
let num4 = 33
let num5 = 2

// А теперь так:
let nums = [5,3,7,33,2];


// Важно знать!
// Массивы нумеруются с 0!
// То есть первый элемент - это "нулевой элемент". 
// Но люди в речи все-равно используют "первый", потому что так легче для слуха.


// 5.1 Получаем значение
// Чтобы получить первое значение массива:
nums[0] // -> 5
nums[1] // -> 3

// пример использования:
let c = nums[0] + nums[1] // => 5 + 3 => 8


// 5.2 Узнать длину массива (сколько элементов внутри)
nums.length // -> 5


// 5.3 Добавить что-то в массив
nums.push(44)
// выводим nums
nums // -> [5,3,7,33,2,44] 
nums.length // -> 6


// 5.4 Достать последний элемент из массива
nums[ nums.length - 1 ] 
// Объясняю:
// nums.length - длина массива, ща она равна 6
// если из 6 вычесть 1, получится 5
// 5 - это последний индекс в массиве (массивы нумеруются от 0)
// получится nums[ 5 ]
// -> 44

6. Циклы .js

// Цикл - Loop (луп)

// 6.1. Циклы - это "повторяторы" лол.
// Они нужны, если нужно что-то повторить несколько раз.

// Приведу пример
// Тебе нужно 2 умножить 5 раз на 3.
let a = 2;
a = a * 3;
a = a * 3;
a = a * 3;
a = a * 3;
a = a * 3;
a // -> 486
// Выглядит плохо и есть ощущение, что можно сделать более красиво...

let a = 2
for(let i=0; i<5; i++) { // не ссы, читай дальше
  a = a * 3;
}
a // -> 486

// Представь себе, что задача меняется, и теперь нужно это проделать 100 раз.
let a = 2
for(let i=0; i<100; i++) {
  a = a * 3;
}
a // -> 1.0307550414640226e+48 (огромное число с 48 нулями)

// Заметь, что я потратил столько же сил, а задача повторилась 100 раз!


// 6.2 Запись цикла.
// Циклов есть несколько видов, мы расмотрим цикл "for".

for( ПЕРЕМЕННАЯ_НАЧАЛА; УСЛОВИЕ; ДЕЙСТВИЕ_С_ПЕРЕМЕННОЙ ) {
  // А ЗДЕСЬ КОД КОТОРЫЙ МЫ БУДЕМ ПОВТОРЯТЬ
}

// посмотрим шаг за шагом:
for(let i=0; i<3; i++) {}
// мы внутри цикла сделали переменную i, которая в начале равна 0
// мы указали, что цикл должен работать, пока i меньше 3
// и мы указали, что делать с i, каждую иттерацию (каждый раз)

// попробуем посмотреть как будет он работать на словах:
// i=0 ; i<3 (true), прибавляем единицу: i = i+1
// i=1 ; i<3 (true), прибавляем единицу: i = i+1
// i=2 ; i<3 (true), прибавляем единицу: i = i+1
// i=3 ; i<3 (false) - не выполняем!

for(let i=0; i<3; i++) {
  i
}
// -> 0
// -> 1
// -> 2
 

// 6.3 Пример с массивом!
// Я хочу получить сумму из цифр массива:
let a = [1,2,3];
let sum = 0;

for(let i=0; i<a.length; i++){
  // в i будут перебираться числа от 0 до a.length
  sum = sum + a[i];
}

// выводим
sum // -> 6

// И приколись, этот маленький алгоритм будет работать даже с массивом из миллиона элементов! Любого размера!


// 6.4 Последний прикол с предыдущей задачей 
// for можно записать в 1 строчку, без {}

let a = [1,2,3];
let sum = 0;
for(let i=0; i<a.length; i++) sum = sum + a[i];

// Круто, красиво  и удобно!

7. Удобные циклы .js

// А что если я скажу, что может быть удобнее вот этого?
let a = [1,2,3];
let sum = 0;
for(let i=0; i<a.length; i++) sum = sum + a[i];

// Например вот это:
let a = [1,2,3];
let sum = 0;
for(let n of a) sum = sum + n;
// Ебать проще пишется и на взгляд стало легче!

for(let ПЕРЕБИРАЕМОЕ_ЗНАЧЕНИЕ of МАССИВ) {
  // А ЗДЕСЬ КОД КОТОРЫЙ МЫ БУДЕМ ПОВТОРЯТЬ
}

// Корочи, фишка в том, что можно перебирать не просто от 0 до 3, как мы делали раньше, а просто попросить JS перебирать каждый элемент и давать тебе сразу его значение, а не порядковый номер!

// буквально:
for(let n of a){
  // тут действия С N - перебираемым ЗНАЧЕНИЕ
}
// то есть JS сам перебирает i от 0 до a.length и возвращает тебе a[i] как n 

let a = [55,33,22];
for(let n of a){
  n
}
// -> 55
// -> 33
// -> 22

8. Функции .js

// Функция - Function (фанкшен)
// Возврат - Return (ретёрн)

// 8.1 Помнишь алгебру?
// x + 5 = 6
// чем является x?
// Правильно, 1.

// Давай представим, что мы хотим написать функцию (метод, микро-программу), которой мы бы давали x, а она возвращала бы x+5, как в уравнении выше.
// Если по детски:
Моя_функция = принимает x, отдаёт x + 5
Моя_функция(держи x = 1) // возвращает -> 6

// если по-настоящему:
let kek = function(x){
  return x + 5
}
kek(1) // -> 6
kek(12) // -> 17
// И это по-настоящему работающий код!

// Но чаще всего мы объявляем функции не так:
let kek = function(){}
// а так:
function kek(){}

// То есть так даже более человечнее:
function kek(x){
  return x + 5;
}
// Человечнее, потому что можно просто "читать" её:

   function  kek                             (x) {
// функция   kek, принимает в себя переменную x
     return     x + 5
//   возвращает x + 5
   }


// 8.2 Аргументы функции
function kek(x) // x - это аргумент функции
// ты можешь в аргумент передавать ВСЕ ЧТО ХОЧЕШЬ: переменную, функцию, массив, число, душу

// Так же ты можешь передавать много аргументов через запятую:
function summa(x, y){
  return x + y
}
summa(5, 6) // -> 11

let a = 10
let b = 20
summa(a, b) // -> 30

// Вот так тоже можно!
let a = 10
let b = 20
let c = summa(a, b) + 100
c // -> 30 + 100 = 100