Доброе утро всем!
Написал ответ к прошлой задачке поздно ночью, но решил вас не будить, почитайте сейчас и хорошего вам дня)

Ответ к #Задачка2
Можно, конечно, сказать просто:
var объявляет переменные с функциональной областью видимости, а let и const c блочной, при этом const нельзя менять.
И это просто правильный ответ.
А можно ответить более развернуто:
Ключевые слова var, let и const используются для создания переменных.
var означает функциональную область видимости переменной, то есть переменная видна внутри функции и даже до ее объявления, правда до этого объявления она будет равна undefined.
let и const означают блочную область видимости и до объявления не видны, при попытке обращения интерпретатор выдаст ошибку.
Ключевое слово const создает константу, то есть переменную, которую нельзя менять, при попытке ее изменить интерпретатор выбросит исключение.
При этом нужно помнить, что неизменность этих констант касается прежде всего примитивных типов, а в объектных невозможно присвоить новый массив/объект/функцию, а изменить текущий вполне можно, например код:

const o = {};

o.name = 'yura';

будет вполне корректным.
Транспайлеры es2015 преобразовывают и let, и 'const' в обычные var, области видимости разруливают на уровне генерации имен, а проверку константности делают просто статическим анализом кода.

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

Напоминаю, свой вопрос можно присылать мне на @djamah

#Задачка3
Очень клевая проверка, понимает ли человек, что означает 'передать по ссылке' и 'по значению':

var a = {};

(function b ( a ) {
    a.a = 10;
    a = null;
})( a );

console.log(a);

Что мы увидим в консоли? Почему?

Тем временем уже выложили видео моего выступления, на котором большинство из вас узнало об этом канале
https://www.youtube.com/watch?v=ncaWoyLINoI
Когда это видео наберет 1000 лайков, мы сделаем его вторую часть)
В общем, все как обычно, ставим лайк, подписываемся на канал, шарим видео.
Говорят, что тем, кто расшарит это все, будет пожизненно везти на собесах)

Ответ к #Задачка3
Для понимания проблемы важно помнить, что локальная переменная — это не только та, которая создана с ключевым словом var, но и та, которая параметр функции.

Дальше передам слово Диме, который прислал мне ответ с отличной формулировкой:
«В консоль выведется { a: 10 }
В функцию передаётся пустой объект, ссылка на него присваивается внутренней [локальной] переменной a, далее в объект записывается свойство a (по ссылке), далее внутренней переменной присваивается значение null и ссылка на него теряется, а вот у внешней a - остаётся.»

#Задачка4
Вот есть у нас такой код

var obj = {
 a: function(){
  console.log(this.prop);
 },
 prop: 1
};
 
obj.a.prop = 2;
obj.a();
var fn = obj.a;
fn();

Что выведется в консоль? Почему? Какая строка здесь, чтоб вас запутать?

Ответ на #Задачка4, который прислала Марина и он абсолютно верный:

Выполнится 2 консоль лога, выведется сначала 1 а, потом undefined, потому что в первом случае this указывает на объект obj, в котором мы и находим значение свойства prop, а при втором вызове this ссылается на window. У объекта window нет свойства prop, соответственно, в консоли получаем undefined.

Запутать нас пытаются строкой obj.a.prop = 2; — может показаться, что 2 мы присваиваем в obj.prop.
На самом же деле мы создаем свойство prop у obj.a и уже в него присваиваем 2.

Если есть кто-то трезвый, вот вам вместо поздравления)

#Задачка5
Есть два фрагмента кода:
1

function a () {
    return console.log (a)
    var a = 5;
};
a();

2

function a () {
    return console.log (a)
    let a = 5;
};
a();

Что выведется в этих двух случаях?

p.s. С новым годом!

Ответов на #Задачка5 пришло рекордное количество, вот не спалось же вам)

Теперь к сути. Первое, что хотелось бы отметить, это то, что писать return console.log(...); довольно бессмысленно.
Как, кстати, и писать return alert(...). Дело в том, что обе эти функции всегда возвращают undefined.

По поводу самой задачки передаем слово Диме:
В первом варианте функции законсольложится undefined, так как объявление (но не присвоение значения) переменной а поднимется вверх своей области видимости (т.н. hoisting).
Во втором варианте получим ошибку: a is not defined..., так как при объявлении переменной при помощи let hoisting'а не происходит.

Кстати, что во втором случае выбросит ошибку, внимательные читатели могли знать не только вбив это в консоль, но и просто внимательно прочитав разбор к #Задачка2

Пора начинать разговаривать про прототипы)
Тема важная, но начнем мы с абсолютно ламерского вопроса (#Задачка6)

var person = {
  name: 'Yura',
  born: 1990
}

person.__proto__ = {
  age: function() {
    return 2018 - this.born;
  }
}

person.age = function() {
  return 2018 - this.born + ' лет';
}

console.log( person.age() );

Что выведется в консоль?

Ответы можно не присылать, но если у вас возникли сложности, то йоу, пора учить js)

Ответ к #Задачка6 хорошо сформулировал Василий:
Вернется "28 лет", так как у person есть [собственный] метод age, в прототип никто даже не полезет)

Эта задачка проверяет знание очень простой вещи: прототипная связь и все эти цепочки начинают работать, когда мы обращаемся к свойству объекта, а этого свойства у объекта нет.
Нет никакой разницы между методами и просто свойствами, потому что метод — это самое обычное свойство объекта, свойство, в которое записана функция.

#Задачка7
Сегодня будет задачка похардкорнее, хоть и не на прототипы)
Ее вариацию когда-то дали моему знакомому на собеседовании в Яндекс. Серега, привет :)

Нужно написать реализацию функции f таким образом, чтобы корректно работал следующий код:

function f() {
  ...
}

console.log( f()()() === 3 ); // true
console.log( f()()() === 6 ); // true
console.log( f()()() === 9 ); // true

Дописывать можно не только внутри функции, но и вокруг.

По присылаемым ответам вижу, что не очень понятно условие, ок, уточняю

Дополнение к #Задачка7
Решение должно быть в общем виде и учитывать окружающую реальность)
То есть код должен быть таким, чтобы это сработало и так:

console.log( f()() === 2 ); // true
console.log( f()() === 4 ); // true
console.log( f()() === 6 ); // true

и так:

console.log( f() === 1 ); // true
console.log( f()() === 3 ); // true
console.log( f()()() === 6 ); // true

Пока я собираюсь с духом опубликовать ответ к прошлой задаче, получите еще одну:

#Задачка8

var obj = {
    a: 5,
    b: {
        c: 10
    }
};

obj.__proto__ = {
    a: 10,
    b: {
        c: 20
    }
};

delete obj.a;
console.log(obj.a);

delete obj.a;
console.log(obj.a);

delete obj.b;
console.log(obj.b.c);

delete obj.b.c;
console.log(obj.b.c);

Что выведет каждый из консоль логов? Почему?

p. s. Это задачка из моего доклада, видео которого я публиковал чуть выше, но судя по тому, как много здесь собралось людей в последнее время, большинство его не смотрело)

Ах да, совсем забыл, ответы и свои вопросы присылайте мне на @djamah
И помните, для этого канала нет плохих вопросов, а есть плохие разборы (хотя, плохих разборов тоже нет).
Пишите!)

#Задачка7 висела без разбора дольше остальных, но и ответов на нее пришло больше всего.
Многие из них были правильными, а некоторые даже пытались соответствовать условию))

Первым правильный ответ прислал Евгений, а заметил ошибку в условии — Дима, но обо всем по порядку.

Основная проблема #Задачка7 в том, что функция должна быть одновременно и функцией, ведь в любой момент можно приписать пару скобок, и числом.
Вернуть из функции саму себя и посчитать количество таких вызовов — дело нехитрое:

var count = 0;
function f() {
  count++;

  return f;
}

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

var count = 0;
function f() {
  count++;

  return f;
}

f.valueOf = function() {
  return count;
}

Код вроде такого является правильным решением задачи.
Некоторые из вас воскликнут: НО ТАМ ЖЕ БЫЛО ===!!1, а при строгом сравнении это работать не будет!
Ну что вам сказать? Да, в консоль логах должно было быть двойное равно, а я лоханулся. Но вы это, не стесняйтесь уточнять)

p.s. Использовать toString вместо valueOf тоже ок.

Пока я пишу ответ к прошлой задаче, Михаил прислал кое-что из классики:

#Задачка9

const a = {};
const b = {key: 'b'};
const c = {key: 'c'};

a[b] = 12;
a[c] = 42;

console.log(a[b]);

Что выведется в консоль? Почему?

Всем привет, а я про вас не забыл, просто у нас тут в Африке как-то хуже с интернетом, чем у вас в Европах)

Долгожданный ответ к #Задачка8
Ну первое, что нельзя не прокомментировать - это задание прототипа через свойство __proto__, в 2k18 это не очень правильно. Ну, это никогда не было правильно, просто раньше это еще и не работало, а теперь работает, но есть более нормальные способы задать прототип.
Впрочем, очевидно, что к заданию это не относится. И мы были бы не мы, если бы не поумничали, и снисходительно не заметили, что это, конечно, на суть задания не влияет, но в пул реквесте реального проекта мимо проходить нельзя.

Теперь, что там у нас дальше? А дальше происходит удаление свойств из объекта и важно не забыть, как это там работает с прототипами.
Работает очень просто, как и всегда с прототипами нужно помнить: на запись — только собственные свойства, а на чтение — можно и из родителя.
Удаление свойства — это считается как запись.

С первыми тремя консоль логами все просто:

delete obj.a;
console.log(obj.a);

Здесь удаляется собственное свойство a: 5, поэтому в консоль выведется значение из прототипа — 10

Потом следует повторение этих двух строк и так как на запись (в нашем случае — удаление) доступны только собственные свойства, то он попыпается удалить то чего уже нет, а в прототип не полезет, потому что нельзя ему, и в консоли мы увидим снова 10.

Со строчками

delete obj.b;
console.log(obj.b.c);

тоже все ясно, удаляется ссылка на объект {c: 10} и при обращении obj.b.c — идем в прототип и оттуда считываем 20.

Ну и самое интересное в этой задачке — последняя пара строк:

delete obj.b.c;
console.log(obj.b.c);

В консоль выведется undefined, и получается, что таки можно залезть в прототип и что-то там поменять.
Этот эффект объясняется очень просто: в обращении obj.b.c та часть, которая обращается к прототипу obj.b делает это на чтение, и мы получаем прямую ссылку на объект и уже из него удаляем собственное свойство с.
Когда я разбирал эту задачку в докладе, я написал эквивалентный код:

var temp = obj.b;
delete temp.c;
console.log(obj.b.c);

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

#Задачка9 хороший повод поговорить про объекты.
Объекты в js — это такие ассоциативные пары ключей и значений.
Важно помнить, что в общем(!) случае ключом может быть практически любая строка. В этом же общем случае мы обращаемся к свойствам через квадратные скобки, например, obj['практически любая строка'].
То, что мы привыкли обращаться к свойствам через точку, — это частный случай, синтаксический сахар для случаев, когда ключом является строка без взяких специальных символов и пробелов.

Зная все это, а также то, что для приведения к строке используется метод toString и что для объектов он возвращает [object Object], указать правильный вариант довольно легко.
Первым с этим справился Дима (не тот, что в прошлые разы), а хорошо сформулировал Андрей:
Выведет в консоль 42, потому что в пустом объекте a создается свойство [object Object] из-за того, что в качестве ключа мы указываем объект и этому свойству присваивается последнее значение 42.

Давид подкинул отличную идею для задачи:

#Задачка10
А давайте придумаем свою реализацию функции isNaN, вот будто изначально ее нет.

К #Задачка10 почти все прислали примерно такой вариант:

function isNaN(n) {
  return n !== n;
}

ведь NaN это единственное значение, которое не равно самому себе.
И это правильный ответ, но на другую задачку) Описанным образом работает Number.isNaN, который появился только в ES6, а оригинальный isNaN сначала приводит аргумент к числу, а уже потом проверяет, что он неравен самому себе.
Правильный ответ что-то вроде:

function isNaN(n) {
  n = +n; // ну или как вы там любите приводить что-то к числу

  return n !== n;
}

Очень точно резюмировал Игорь:
"поэтому isNaN({}) или isNaN('строка') выдаст true, но новый Number.isNaN сработает только на явно переданный NaN."

P.S. И пожалуйста, не забывайте, что NaN — это всего лишь специальное значение типа число. А то каждый второй, кто правильно перечисляет типы в js, на запутывающий вопрос: 'а разве NaN не отдельный тип?' — начинает сомневаться и добавляет что-то типа: "А, ну да, забыл, NaN также является отдельным типом", а это не так.