Собеседование по JavaScript - Опыт выживания

console.log(a); // undefined
console.log(b); // ReferenceError: b is not defined
console.log(c); // ReferenceError: c is not defined
 
var a = 1;
let b = 2;
const c = 3;

var x = 10;
var x = 20; // Полностью легально
 
let y = 10;
let y = 20; // SyntaxError: Identifier 'y' has already been declared
 
const z = 10;
z = 20; // TypeError: Assignment to constant variable

const user = { name: "John" };
user.name = "Mike"; // Полностью работает!
user = {}; // TypeError: Assignment to constant variable

function varTest() {
  var x = 1;
  if (true) {
    var x = 2;  // та же переменная!
    console.log(x);  // 2
  }
  console.log(x);  // 2
}
 
function letTest() {
  let x = 1;
  if (true) {
    let x = 2;  // другая переменная
    console.log(x);  // 2
  }
  console.log(x);  // 1
}

function testTDZ() {
  console.log(letVar); // ReferenceError
  console.log(varVar); // undefined
  
  let letVar = 3;
  var varVar = 2;
}

var globalVar = "I'm global var";
let globalLet = "I'm global let";
 
console.log(window.globalVar); // "I'm global var"
console.log(window.globalLet); // undefined

for (var i = 0; i < 5; i++) {
  setTimeout(function() { console.log(i); }, 100);
}

for (let i = 0; i < 5; i++) {
  setTimeout(function() { console.log(i); }, 100);
}

const user = Object.freeze({
  name: "John",
  age: 30
});
 
user.name = "Mike"; // Не вызовет ошибку, но изменения не произойдет
console.log(user.name); // "John"

(function() {
  var privateVar = "Я недоступна извне";
  console.log(privateVar);
})();
 
console.log(privateVar); // ReferenceError: privateVar is not defined

typeof 42; // "number"
typeof "строка"; // "string"
typeof true; // "boolean"
typeof undefined; // "undefined"
typeof null; // "object" - исторический баг JavaScript!
typeof {}; // "object"
typeof []; // "object" - массивы тоже объекты!
typeof function(){}; // "function"

let test;
console.log(test); // undefined
test = null;
console.log(test); // null

"use strict";
 
x = 10; // ReferenceError: x is not defined

const arr = [1, 2, 3];
console.log(typeof arr); // "object" - не очень полезно!
 
// Правильные способы:
console.log(Array.isArray(arr)); // true
console.log(arr instanceof Array); // true
console.log(Object.prototype.toString.call(arr) === '[object Array]'); // true

console.log(parseInt("строка")); // NaN
 
// Проверка на NaN:
console.log(isNaN(NaN)); // true
console.log(Number.isNaN(NaN)); // true
 
// Но:
console.log(isNaN("строка")); // true - глобальный isNaN сначала конвертирует
console.log(Number.isNaN("строка")); // false - более строгая проверка

{
  var x = 1;
  let y = 2;
  const z = 3;
}
 
console.log(x); // 1
console.log(y); // ReferenceError: y is not defined
console.log(z); // ReferenceError: z is not defined

for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 100);
}
// Выведет: 3, 3, 3
 
for (let j = 0; j < 3; j++) {
  setTimeout(() => console.log(j), 100);
}
// Выведет: 0, 1, 2

for (var i = 0; i < 3; i++) {
  (function(index) {
    setTimeout(() => console.log(index), 100);
  })(i);
}
// Выведет: 0, 1, 2

console.log(hoistedFunction()); // Работает!
console.log(hoistedVar); // undefined
console.log(hoistedLet); // ReferenceError
 
function hoistedFunction() {
  return "Я поднят полностью!";
}
 
var hoistedVar = "Я поднят частично";
let hoistedLet = "А я застрял в TDZ";

sayHi(); // TypeError: sayHi is not a function
var sayHi = function() {
  console.log("Привет!");
};

// Примитивы
let a = 10;
let b = 10;
console.log(a === b); // true
 
// Объекты
let obj1 = { value: 10 };
let obj2 = { value: 10 };
console.log(obj1 === obj2); // false!

let obj3 = obj1;
console.log(obj1 === obj3); // true, обе переменные указывают на один объект

console.log(JSON.stringify(obj1) === JSON.stringify(obj2)); // true

// Явное преобразование - вы сами говорите JS что делать
const num = Number("42");  // 42
const str = String(42);    // "42"
const bool = Boolean(1);   // true
 
// Неявное преобразование - JS решает за вас
const sum = "42" + 10;     // "4210" (строковая конкатенация, а не сложение)
const isTrue = "42" == 42; // true (числовое сравнение)
if ("hello") {             // строка преобразуется в true
  console.log("Эта строка 'истинна'");
}

console.log(1 + [2, 3]);  // "12,3"

Number("42");     // 42
Number("42px");   // NaN
Number("");       // 0 (а не NaN, как могли бы ожидать!)
Number(null);     // 0 (сюрприз!)
Number(undefined); // NaN
Number(true);     // 1
Number(false);    // 0
Number([]);       // 0 (еще один сюрприз!)
Number([1]);      // 1
Number([1, 2]);   // NaN

Boolean([]);        // true
Boolean({});        // true
Boolean(new Date()); // true

"" == 0;           // true
0 == "0";          // true
null == undefined; // true
[1] == 1;          // true
true == 1;         // true
false == 0;        // true

// Пример 1: Сложение против конкатенации
console.log(1 + 2 + "3");  // "33" (сначала 1+2=3, потом "3"+3="33")
console.log("1" + 2 + 3);  // "123" (сначала "1"+2="12", потом "12"+3="123")
 
// Пример 2: Вычитание и другие математические операции
console.log("5" - 2);      // 3 (строка преобразуется в число)
console.log("5" + 2);      // "52" (число преобразуется в строку)
 
// Пример 3: Сравнение массивов
console.log([] == []);     // false (разные объекты в памяти)
console.log([] == 0);      // true (пустой массив преобразуется в 0)
console.log([0] == 0);     // true (массив с одним элементом преобразуется в "0", затем в 0)
 
// Пример 4: Пустой массив - "истинное" значение
console.log(Boolean([]));  // true
if ([]) {
  console.log("Пустой массив истинный!");  // Это выполнится
}
 
// Пример 5: Но при сравнении...
console.log([] == true);   // false ([] преобразуется в 0, true в 1)
console.log(![] == false); // true (сначала ![] дает false, затем false == false)

// Если один операнд строка, + действует как конкатенация
console.log("5" + 3);     // "53"
console.log(3 + "5");     // "35"
console.log(null + "5");  // "null5"
 
// Если оба операнда числа, + действует как сложение
console.log(3 + 5);       // 8
 
// Но если операнды не строки и не числа, происходит магия
console.log(true + true); // 2 (true преобразуется в 1)
console.log([] + {});     // "[object Object]" (обе стороны преобразуются в строки)
console.log({} + []);     // 0 в некоторых браузерах! {} интерпретируется как пустой блок

console.log([] + []);        // "" (пустая строка)
console.log({} + {});        // "[object Object][object Object]"
console.log([] - {});        // NaN
console.log(true - null);    // 1 (true -> 1, null -> 0)
console.log("2" * "3");      // 6 (строки преобразуются в числа)
console.log("5" - "2");      // 3 (строки преобразуются в числа)

console.log(null == 0);      // false
console.log(null >= 0);      // true
console.log(null > 0);       // false

const sym = Symbol("description");
console.log(String(sym));    // "Symbol(description)"
console.log(sym + "");       // TypeError: Cannot convert a Symbol value to a string
 
const obj = { 
  toString() { return "строка"; },
  valueOf() { return 42; }
};
 
console.log(obj + "");       // "42" - вызывается valueOf
console.log(`${obj}`);       // "строка" - в шаблонных строках вызывается toString

// С явным преобразованием
const count = Number(document.getElementById("counter").value);
if (Boolean(count) && count > Number(localStorage.getItem("threshold"))) {
  // код
}
 
// С неявным преобразованием
const count = document.getElementById("counter").value;
if (count && count > localStorage.getItem("threshold")) {
  // код
}

function createCounter() {
  let count = 0;  // Приватная переменная
  
  return function() {
    return ++count;
  };
}
 
const counter = createCounter();
console.log(counter()); // 1
console.log(counter()); // 2
console.log(counter()); // 3

function heavyClosure() {
  const bigArray = new Array(1000000).fill('memory leak');
  const actuallyUsed = 'small value';
  
  return function() {
    return actuallyUsed; // использует только одну переменную
    // но bigArray всё равно сохраняется в памяти!
  };
}

const counter = (function() {
  let count = 0; // Приватная переменная
  
  return {
    increment: () => ++count,
    value: () => count
  };
})();
 
counter.increment(); // 1
console.log(counter.value()); // 1

function createLogger(prefix) {
  return message => console.log(`${prefix}: ${message}`);
}
 
const debugLog = createLogger("[DEBUG]");
const errorLog = createLogger("[ERROR]");
 
debugLog("Инициализация"); // "[DEBUG]: Инициализация"

function getData(url) {
  let cache = null;
  
  return async function() {
    if (cache) return cache;
    cache = await fetch(url).then(r => r.json());
    return cache;
  }
}

(function() {
  const privateVar = "Не видна снаружи";
  console.log(privateVar); // Доступно внутри
})();
 
console.log(privateVar); // ReferenceError

const myModule = (function() {
  const privateVar = "Секретные данные";
  
  function privateFunction() {
    return privateVar;
  }
  
  return {
    publicMethod: function() {
      return privateFunction() + " доступны через интерфейс";
    }
  };
})();
 
myModule.publicMethod(); // "Секретные данные доступны через интерфейс"
myModule.privateVar; // undefined

getUserData(userId, function(userData) {
  getFriendsList(userData.id, function(friends) {
    getPhotos(friends[0].id, function(photos) {
      savePhoto(photos[0], function(result) {
        // и так далее... вглубь кроличьей норы
      });
    });
  });
});

const myPromise = new Promise((resolve, reject) => {
  // Здесь асинхронная работа
  if (всеОк) {
    resolve('Данные');
  } else {
    reject(new Error('Что-то пошло не так'));
  }
});

console.log('Начало');
 
Promise.resolve().then(() => console.log('Промис 1'));
 
setTimeout(() => console.log('Таймер 1'), 0);
 
Promise.resolve().then(() => console.log('Промис 2'));
 
console.log('Конец');

Начало
Конец
Промис 1
Промис 2
Таймер 1

fetchUser(userId)
  .then(user => fetchUserPosts(user.id))
  .then(posts => filterImportantPosts(posts))
  .then(importantPosts => console.log(importantPosts))
  .catch(error => console.error('Что-то пошло не так:', error));

fetchData()
  .then(data => {
    const processedData = processData(data); // Может выбросить исключение!
    return processedData;
  })
  .catch(error => console.error(error));

// Ждем выполнения всех промисов
Promise.all([fetchUsers(), fetchPosts(), fetchComments()])
  .then(([users, posts, comments]) => {
    // Все данные получены
  })
  .catch(error => {
    // Если хотя бы один промис отклонен
  });
 
// Ждем первый выполненный промис
Promise.race([fetchFromServer1(), fetchFromServer2()])
  .then(fastestResult => {
    // Получен результат от самого быстрого сервера
  });
 
// Ждем завершения всех промисов, независимо от результата
Promise.allSettled([riskyOperation1(), riskyOperation2()])
  .then(results => {
    // results - массив объектов со статусом и значением
  });

async function getUserData() {
  try {
    const user = await fetchUser(userId);
    const posts = await fetchUserPosts(user.id);
    const comments = await fetchPostComments(posts[0].id);
    return { user, posts, comments };
  } catch (error) {
    console.error('Ошибка:', error);
  }
}

// Неэффективный код - операции выполняются последовательно
async function fetchAllData() {
  const users = await fetchUsers();
  const posts = await fetchPosts();
  const comments = await fetchComments();
  return { users, posts, comments };
}

async function fetchAllData() {
  const usersPromise = fetchUsers();
  const postsPromise = fetchPosts();
  const commentsPromise = fetchComments();
  
  const users = await usersPromise;
  const posts = await postsPromise;
  const comments = await commentsPromise;
  
  return { users, posts, comments };
}
 
// Или еще короче
async function fetchAllData() {
  const [users, posts, comments] = await Promise.all([
    fetchUsers(),
    fetchPosts(),
    fetchComments()
  ]);
  
  return { users, posts, comments };
}

function getData() {
  const data = await fetchData(); // Синтаксическая ошибка!
  return data;
}

async function processData() {
  try {
    const rawData = await fetchData();
    // Следующая строка может выбросить исключение,
    // и оно будет поймано в этом же блоке try/catch
    const processedData = JSON.parse(rawData);
    return processedData;
  } catch (error) {
    console.error("Ошибка:", error);
  }
}

async function processItems(items) {
  items.forEach(async item => {
    const result = await processItem(item);
    console.log(result);
  });
  console.log('Все обработано!');
}

async function processItems(items) {
  for (const item of items) {
    const result = await processItem(item);
    console.log(result);
  }
  console.log('Теперь действительно все обработано!');
}
 
// Или для параллельной обработки:
async function processItems(items) {
  await Promise.all(items.map(async item => {
    const result = await processItem(item);
    console.log(result);
  }));
  console.log('Все обработано параллельно!');
}

async function giveMeNumber() {
  return 42; // на самом деле вернется Promise.resolve(42)
}
 
giveMeNumber().then(num => console.log(num)); // 42

async function chainExample() {
  return Promise.resolve(1)
    .then(x => x + 1)
    .then(x => Promise.resolve(x + 1))
    .then(x => x + 1);
}
 
chainExample().then(console.log); // Что будет выведено?

console.log('Официант принимает заказ');  // Синхронный код
 
setTimeout(() => {
  console.log('Макрозадача: заказ обычного клиента');
}, 0);
 
Promise.resolve().then(() => {
  console.log('Микрозадача: заказ VIP-клиента');
});
 
console.log('Официант уходит на кухню');  // Синхронный код

Официант принимает заказ
Официант уходит на кухню
Микрозадача: заказ VIP-клиента
Макрозадача: заказ обычного клиента

setTimeout(() => {
  console.log('Таймер 1');
  Promise.resolve().then(() => console.log('Промис внутри таймера'));
}, 0);
 
Promise.resolve().then(() => {
  console.log('Промис 1');
  setTimeout(() => console.log('Таймер внутри промиса'), 0);
});

Промис 1
Таймер 1
Промис внутри таймера
Таймер внутри промиса

// Подход 1: try/catch с async/await
async function fetchDataWithTryCatch() {
  try {
    const response = await fetch('https://api.example.com/data');
    const data = await response.json();
    return data;
  } catch (error) {
    console.error('Произошла ошибка:', error);
    return null;
  }
}
 
// Подход 2: промисы с .catch()
function fetchDataWithPromiseCatch() {
  return fetch('https://api.example.com/data')
    .then(response => response.json())
    .catch(error => {
      console.error('Произошла ошибка:', error);
      return null;
    });
}

async function problemDemo1() {
  try {
    const response = await fetch('https://api.example.com/data');
    const data = await response.json();
    return processData(data); // Может выбросить исключение!
  } catch (error) {
    console.error('Перехвачена ошибка:', error);
    return null;
  }
}
 
function problemDemo2() {
  return fetch('https://api.example.com/data')
    .then(response => response.json())
    .then(data => {
      return processData(data); // Может выбросить исключение!
    })
    .catch(error => {
      console.error('Перехвачена ошибка:', error);
      return null;
    });
}

function problematicErrorHandling() {
  try {
    fetchData().then(data => {
      console.log(data.nonExistentProperty.something); // Потенциальная ошибка
    });
  } catch (error) {
    console.error('Эта ошибка никогда не будет перехвачена!', error);
  }
}

function correctErrorHandling() {
  fetchData()
    .then(data => {
      console.log(data.nonExistentProperty.something);
    })
    .catch(error => {
      console.error('Теперь ошибка будет перехвачена', error);
    });
}
 
// Или с async/await
async function anotherCorrectApproach() {
  try {
    const data = await fetchData();
    console.log(data.nonExistentProperty.something);
  } catch (error) {
    console.error('И здесь ошибка будет перехвачена', error);
  }
}

// Потенциальная проблема
const promise = fetchData();
// Забыли добавить .catch() или обработать ошибку
 
// Решение - всегда добавляйте обработку ошибок
fetchData().catch(error => console.error(error));

process.on('unhandledRejection', (reason, promise) => {
  console.error('Непойманное отклонение промиса:', reason);
  // Для отладки
  console.error('Проблемный промис:', promise);
});

async function tooGenericErrorHandling() {
  try {
    await authenticateUser();
    await fetchUserProfile();
    await updateUserSettings();
    return "Успех!";
  } catch (error) {
    // Какая операция вызвала ошибку? Трудно понять!
    console.error("Что-то пошло не так:", error);
    return "Ошибка";
  }
}

async function detailedErrorHandling() {
  try {
    await authenticateUser();
  } catch (error) {
    console.error("Ошибка аутентификации:", error);
    throw new AuthError("Не удалось авторизоваться", { cause: error });
  }
  
  try {
    await fetchUserProfile();
  } catch (error) {
    console.error("Ошибка загрузки профиля:", error);
    throw new ProfileError("Не удалось загрузить профиль", { cause: error });
  }
  
  try {
    await updateUserSettings();
  } catch (error) {
    console.error("Ошибка обновления настроек:", error);
    throw new SettingsError("Не удалось обновить настройки", { cause: error });
  }
  
  return "Успех!";
}

async function fetchWithRetry(url, options = {}, retries = 3, backoff = 300) {
  try {
    return await fetch(url, options);
  } catch (error) {
    if (retries <= 0) {
      throw error;
    }
    
    await new Promise(resolve => setTimeout(resolve, backoff));
    return fetchWithRetry(url, options, retries - 1, backoff * 2);
  }
}

let userData = null;
 
fetch('/api/user')
  .then(response => response.json())
  .then(data => userData = data);
 
fetch('/api/settings')
  .then(response => response.json())
  .then(settings => {
    // Используем userData, но уверены ли мы, что он уже загружен?
    console.log(userData?.name, settings);
  });

Promise.all([
  fetch('/api/user').then(response => response.json()),
  fetch('/api/settings').then(response => response.json())
])
.then(([userData, settings]) => {
  // Теперь мы точно знаем, что оба запроса завершились
  console.log(userData.name, settings);
})
.catch(error => {
  console.error('Что-то пошло не так:', error);
});

async function incrementCounter() {
  // Получаем текущее значение
  const { count } = await fetch('/api/counter').then(r => r.json());
  
  // Увеличиваем на 1
  return fetch('/api/counter', {
    method: 'POST',
    body: JSON.stringify({ count: count + 1 }),
    headers: { 'Content-Type': 'application/json' }
  });
}
 
// Что если эти функции выполняются параллельно?
incrementCounter();
incrementCounter();

async function incrementCounter() {
  return fetch('/api/counter/increment', { method: 'POST' });
}

// Последовательное выполнение
async function sequentialExecution() {
  const result1 = await operation1();
  const result2 = await operation2(result1); // Зависит от result1
  const result3 = await operation3(result2); // Зависит от result2
  return result3;
}
 
// Параллельное выполнение (когда операции независимы)
async function parallelExecution() {
  const [result1, result2, result3] = await Promise.all([
    operation1(),
    operation2(),
    operation3()
  ]);
  return combineResults(result1, result2, result3);
}

async function processInOrder(urls) {
  // Запускаем все запросы параллельно, но не ждем их завершения
  const promises = urls.map(url => fetch(url).then(r => r.json()));
  
  // Обрабатываем результаты в нужном порядке
  for (let i = 0; i < promises.length; i++) {
    const data = await promises[i];
    console.log(`Обработка данных из ${urls[i]}`);
    processData(data);
  }
}

// Высокая производительность, но риск race condition
async function riskyApproach() {
  const [users, permissions] = await Promise.all([
    fetchUsers(),
    fetchPermissions()
  ]);
  
  return users.map(user => ({
    ...user,
    permissions: permissions[user.id]
  }));
}
 
// Безопаснее, но менее эффективно
async function saferApproach() {
  const users = await fetchUsers();
  
  // Последовательная обработка каждого пользователя
  const enrichedUsers = [];
  for (const user of users) {
    const userPermissions = await fetchUserPermissions(user.id);
    enrichedUsers.push({
      ...user,
      permissions: userPermissions
    });
  }
  
  return enrichedUsers;
}

const controller = new AbortController();
const signal = controller.signal;
 
fetch('https://api.example.com/data', { signal })
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => {
    if (error.name === 'AbortError') {
      console.log('Запрос был отменен!');
    } else {
      console.error('Произошла ошибка:', error);
    }
  });
 
// Где-то в другом месте кода, например, по нажатию кнопки "Отмена"
controller.abort();

function fetchWithTimeout(url, options = {}, timeout = 5000) {
  const controller = new AbortController();
  const { signal } = controller;
  
  // Создаем таймер, который отменит запрос через указанное время
  const timeoutId = setTimeout(() => controller.abort(), timeout);
  
  return fetch(url, { ...options, signal })
    .then(response => {
      clearTimeout(timeoutId); // Очищаем таймер, если запрос успешен
      return response;
    })
    .catch(error => {
      clearTimeout(timeoutId); // Очищаем таймер в случае ошибки
      if (error.name === 'AbortError') {
        throw new Error(`Запрос превысил таймаут в ${timeout}мс`);
      }
      throw error;
    });
}
 
// Использование
fetchWithTimeout('https://api.example.com/data', {}, 3000)
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error(error.message));

let searchController = new AbortController();
 
async function search(query) {
  // Отменяем предыдущий поисковый запрос, если он еще выполняется
  searchController.abort();
  
  // Создаем новый контроллер для текущего запроса
  searchController = new AbortController();
  const { signal } = searchController;
  
  try {
    const response = await fetch(`/api/search?q=${query}`, { signal });
    const results = await response.json();
    displayResults(results);
  } catch (error) {
    if (error.name !== 'AbortError') {
      console.error('Ошибка поиска:', error);
    }
    // Мы просто игнорируем AbortError, так как это ожидаемое поведение
  }
}
 
// Привязываем к полю ввода
searchInput.addEventListener('input', () => {
  search(searchInput.value);
});

async function fetchData(url, signal) {
  try {
    const response = await fetch(url, { signal });
    const data = await response.json();
    return data;
  } catch (error) {
    if (error.name === 'AbortError') {
      console.log('Запрос был отменен');
      // Не забудьте обработать этот случай!
      // Некоторые разработчики ошибочно просто выбрасывают исключение дальше
      // throw error; // Это может привести к необработанным исключениям
      
      // Лучше вернуть специальное значение или null
      return { aborted: true };
    }
    throw error; // Прокидываем другие ошибки дальше
  }
}

const animal = {
  eats: true,
  walk() {
    console.log('Животное идет');
  }
};
 
const rabbit = {
  jumps: true,
  __proto__: animal // устанавливаем animal как прототип для rabbit
};
 
rabbit.walk(); // "Животное идет" - метод взят из прототипа
console.log(rabbit.eats); // true - свойство взято из прототипа

function User(name) {
  this.name = name;
}
 
User.prototype.sayHi = function() {
  console.log(`Привет, ${this.name}!`);
};
 
const john = new User('John');
john.sayHi(); // "Привет, John!"

function Animal(name) {
  this.name = name;
}
 
Animal.prototype.eat = function() {
  console.log(`${this.name} ест.`);
};
 
function Rabbit(name) {
  Animal.call(this, name); // вызываем конструктор родителя
  this.jumps = true;
}
 
// Создаем новый объект с прототипом Animal.prototype
Rabbit.prototype = Object.create(Animal.prototype);
Rabbit.prototype.constructor = Rabbit; // восстанавливаем свойство constructor
 
Rabbit.prototype.jump = function() {
  console.log(`${this.name} прыгает!`);
};
 
const peter = new Rabbit('Питер');
peter.eat(); // "Питер ест."
peter.jump(); // "Питер прыгает!"

Rabbit.prototype = Animal.prototype; // НЕПРАВИЛЬНО!

class Animal {
  constructor(name) {
    this.name = name;
  }
  
  eat() {
    console.log(`${this.name} ест.`);
  }
}
 
class Rabbit extends Animal {
  constructor(name) {
    super(name);
    this.jumps = true;
  }
  
  jump() {
    console.log(`${this.name} прыгает!`);
  }
}
 
const peter = new Rabbit('Питер');
peter.eat(); // "Питер ест."
peter.jump(); // "Питер прыгает!"

console.log(peter instanceof Rabbit); // true
console.log(peter instanceof Animal); // true
console.log(peter instanceof Object); // true
 
console.log(Object.getPrototypeOf(peter) === Rabbit.prototype); // true
console.log(Rabbit.prototype.isPrototypeOf(peter)); // true

function User(name) {
  this.name = name;
}
 
const john = new User('John');
 
// Позже в коде...
User.prototype.sayHi = function() {
  console.log(`Привет, ${this.name}!`);
};
 
john.sayHi(); // "Привет, John!" - работает, хотя метод был добавлен после создания объекта!

// Никогда не делайте так в продакшн-коде!
Array.prototype.shuffle = function() {
  return this.sort(() => Math.random() - 0.5);
};
 
[1, 2, 3].shuffle(); // [3, 1, 2] или другой случайный порядок

const swimMixin = {
  swim() {
    console.log(`${this.name} плавает.`);
  }
};
 
const flyMixin = {
  fly() {
    console.log(`${this.name} летает.`);
  }
};
 
class Duck {
  constructor(name) {
    this.name = name;
  }
}
 
// Копируем методы из миксинов в прототип Duck
Object.assign(Duck.prototype, swimMixin, flyMixin);
 
const donald = new Duck('Дональд');
donald.swim(); // "Дональд плавает."
donald.fly(); // "Дональд летает."

const animal = {
  name: "Животное",
  eat() {
    console.log(`${this.name} ест.`);
  }
};
 
const rabbit = {
  name: "Кролик",
  __proto__: animal
};
 
rabbit.eat(); // "Кролик ест." - а не "Животное ест."!

const animal = {
  eats: true
};
 
const rabbit = {
  jumps: true,
  __proto__: animal
};
 
// Перебирает только собственные свойства
for (let prop in rabbit) {
  if (rabbit.hasOwnProperty(prop)) {
    console.log(prop); // только "jumps"
  }
}
 
// Перебирает ВСЕ свойства, включая унаследованные
for (let prop in rabbit) {
  console.log(prop); // "jumps", затем "eats"
}

// Способ 1: через F.prototype и new
function Animal() {}
Animal.prototype.eats = true;
const rabbit1 = new Animal();
 
// Способ 2: через Object.create()
const animalProto = { eats: true };
const rabbit2 = Object.create(animalProto);

// Еще одно преимущество Object.create() - второй параметр
const rabbit3 = Object.create(animalProto, {
  jumps: { 
    value: true,
    enumerable: true,
    writable: true,
    configurable: true
  }
});

const cleanObject = Object.create(null);
console.log(cleanObject.__proto__); // undefined
console.log(Object.getPrototypeOf(cleanObject)); // null
 
// Такой объект не имеет вообще никаких методов!
// cleanObject.toString(); // TypeError: cleanObject.toString is not a function

// Наследуемся от Array
function MyArray(...args) {
  // Вызываем родительский конструктор с текущим this
  Array.apply(this, args);
  // Но это НЕ работает как ожидается!
}
 
MyArray.prototype = Object.create(Array.prototype);
MyArray.prototype.constructor = MyArray;
 
const arr = new MyArray(1, 2, 3);
console.log(arr.length); // 0 - что-то пошло не так!

class MyBetterArray extends Array {
  first() {
    return this[0];
  }
  
  last() {
    return this[this.length - 1];
  }
}
 
const arr2 = new MyBetterArray(1, 2, 3);
console.log(arr2.length); // 3 - работает!
console.log(arr2.first()); // 1
console.log(arr2.last()); // 3

// Метод в прототипе - создается один раз
function User(name) {
  this.name = name;
}
 
User.prototype.sayHi = function() {
  console.log(`Привет, ${this.name}!`);
};
 
const user1 = new User("Алиса");
const user2 = new User("Боб");
// user1.sayHi и user2.sayHi указывают на один и тот же метод в памяти!
 
// Метод в конструкторе - создается для каждого экземпляра
function BadUser(name) {
  this.name = name;
  this.sayHi = function() {
    console.log(`Привет, ${this.name}!`);
  };
}
// Здесь каждый экземпляр получает свою копию метода - неэффективно!

function User(name, age) {
  this.name = name;
  this.age = age;
  this.isAdult = age >= 18;
  this.sayHello = function() {
    console.log(`Привет! Меня зовут ${this.name}`);
  };
}
 
const user1 = new User('Алексей', 30);
const user2 = new User('Мария', 25);
 
user1.sayHello(); // "Привет! Меня зовут Алексей"

function User(name, age) {
  this.name = name;
  this.age = age;
  this.isAdult = age >= 18;
}
 
User.prototype.sayHello = function() {
  console.log(`Привет! Меня зовут ${this.name}`);
};
 
const user1 = new User('Алексей', 30);
const user2 = new User('Мария', 25);

// Создаем объект-прототип с методами
const userMethods = {
  sayHello() {
    console.log(`Привет! Меня зовут ${this.name}`);
  },
  isAdult() {
    return this.age >= 18;
  }
};
 
// Фабричная функция вместо конструктора
function createUser(name, age) {
  // Создаем объект с userMethods в качестве прототипа
  const user = Object.create(userMethods);
  
  // Инициализируем собственные свойства
  user.name = name;
  user.age = age;
  
  return user;
}
 
const user1 = createUser('Алексей', 30);
user1.sayHello(); // "Привет! Меня зовут Алексей"

function createUserWithConfig(name, age) {
  return Object.create(userMethods, {
    name: {
      value: name,
      writable: true,
      enumerable: true,
      configurable: true
    },
    age: {
      value: age,
      writable: true,
      enumerable: true,
      configurable: true
    },
    createdAt: {
      value: new Date(),
      writable: false, // Нельзя изменить
      enumerable: false, // Не перечисляется в циклах
      configurable: false // Нельзя удалить
    }
  });
}
 
const user = createUserWithConfig('Иван', 35);
console.log(user.name); // "Иван"
console.log(user.createdAt); // [текущая дата]
 
// Попытка изменить неизменяемое свойство
user.createdAt = new Date(2020, 0, 1);
console.log(user.createdAt); // все равно [исходная дата]
 
// createdAt не появится при перечислении
for (let key in user) {
  console.log(key); // только "name" и "age"
}

// Создаем "шаблонный" объект со всеми необходимыми свойствами
const userTemplate = {
  name: null,
  age: null,
  posts: [],
  comments: [],
  // ... другие общие свойства
};
 
// Фабричная функция
function createUserFast(name, age) {
  // Клонируем шаблон через Object.create
  const user = Object.create(
    Object.getPrototypeOf(userTemplate), 
    Object.getOwnPropertyDescriptors(userTemplate)
  );
  
  // Устанавливаем только те свойства, которые отличаются от шаблона
  user.name = name;
  user.age = age;
  
  return user;
}

// Набор поведений как отдельные объекты
const hasName = (name) => ({
  getName: () => name,
  setName: (newName) => name = newName
});
 
const hasAge = (age) => ({
  getAge: () => age,
  setAge: (newAge) => age = newAge,
  isAdult: () => age >= 18
});
 
const canSpeak = () => ({
  sayHello: function() {
    console.log(`Привет! Меня зовут ${this.getName()}`);
  }
});
 
// Создаем пользователя путем композиции
function createComplexUser(name, age) {
  return Object.assign(
    {},
    hasName(name),
    hasAge(age),
    canSpeak()
  );
}
 
const user = createComplexUser('Александр', 28);
user.sayHello(); // "Привет! Меня зовут Александр"
console.log(user.isAdult()); // true

function SecureUser(name, password) {
  // Приватные данные, недоступные извне
  const _password = password;
  const _token = generateToken();
  
  // Публичный интерфейс
  this.name = name;
  
  this.authenticate = function(inputPassword) {
    return inputPassword === _password;
  };
  
  this.getToken = function() {
    return _token;
  };
  
  // Приватная функция
  function generateToken() {
    return Math.random().toString(36).substr(2);
  }
}
 
const user = new SecureUser('Админ', 'супер-секрет');
console.log(user.name); // "Админ"
console.log(user.authenticate('супер-секрет')); // true
console.log(user.authenticate('неверный-пароль')); // false
console.log(user._password); // undefined - приватная переменная!

// Общие методы в прототипе
SecureUser.prototype.getName = function() {
  return this.name;
};
 
// Фабричная функция для создания экземпляров
function createSecureUser(name, password) {
  // Приватные данные через замыкание
  const privateData = {
    password: password,
    token: Math.random().toString(36).substr(2)
  };
  
  // Создаем объект с прототипом SecureUser.prototype
  const user = Object.create(SecureUser.prototype);
  
  // Публичные свойства
  user.name = name;
  
  // Методы с доступом к приватным данным
  user.authenticate = function(inputPassword) {
    return inputPassword === privateData.password;
  };
  
  user.getToken = function() {
    return privateData.token;
  };
  
  return user;
}

function User(name) {
  this.name = name;
}
 
const user1 = new User('Алиса');
console.log(user1 instanceof User); // true
 
// А теперь фабричный метод
function createUser(name) {
  return { name };
}
 
const user2 = createUser('Боб');
console.log(user2 instanceof User); // false - неожиданно?

function createUserWithCorrectPrototype(name) {
  // Создаем объект с правильным прототипом
  const user = Object.create(User.prototype);
  user.name = name;
  return user;
}
 
const user3 = createUserWithCorrectPrototype('Чарли');
console.log(user3 instanceof User); // true

function Animal(name) {
  this.name = name;
}
 
Animal.prototype.makeSound = function() {
  console.log(`${this.name} издает звук`);
};
 
const cat = new Animal('Мурзик');
 
console.log(cat.__proto__ === Animal.prototype); // true
console.log(cat.prototype); // undefined
console.log(Animal.__proto__ === Function.prototype); // true

const parent = {
  value: 42
};
 
const child = Object.create(parent);
 
console.log(child.__proto__ === parent); // true
console.log(child.prototype); // undefined - у обычных объектов нет prototype!

function Grandparent() {}
function Parent() {}
function Child() {}
 
Parent.prototype = Object.create(Grandparent.prototype);
Child.prototype = Object.create(Parent.prototype);
 
const child = new Child();
 
console.log(
  child.__proto__ === Child.prototype, // true
  Child.prototype.__proto__ === Parent.prototype, // true
  Parent.prototype.__proto__ === Grandparent.prototype // true
);

Parent.prototype.constructor = Parent;
Child.prototype.constructor = Child;

function Dog(name) {
  this.name = name;
}
 
const dog1 = new Dog('Бобик');
 
// Меняем prototype ПОСЛЕ создания объекта
Dog.prototype = {
  bark() {
    console.log('Гав!');
  }
};
 
const dog2 = new Dog('Шарик');
 
dog2.bark(); // "Гав!"
dog1.bark(); // TypeError - метод не найден!

function User(name) {
  this.name = name;
}
 
const user = new User('Алекс');
 
// Это работает - добавляем в существующий прототип
User.prototype.sayHi = function() {
  console.log(`Привет, я ${this.name}`);
};
 
user.sayHi(); // "Привет, я Алекс"
 
// А это не сработает - заменяем весь прототип
User.prototype = {
  sayBye() {
    console.log(`Пока, ${this.name}`);
  }
};
 
user.sayBye(); // TypeError!