Собеседование на должность JavaScript разработчика



    Недавно прочитал неплохой пост на тему поиска работы QA и подумал, что похожий пост был бы полезен для JavaScript разработчиков. В конечном счёте, веб движется вперед семимильными шагами, и соискателей на позицию JavaScript программиста хоть отбавляй (разумеется, хороших всегда меньше).

    Я очень хочу уйти от бессмысленной демагогии на тему «это обязательно знать, а это нет», поэтому свою статью я построю вокруг самых популярных вопросов-ответов (по опыту собственных собеседований, и собеседований, в которых я выступал собеседующей стороной), который случались за время моей профессиональной практики.

    Вопросы, относящиеся к общим знаниям в области JavaScript


    ООП в JavaScript. Один из самых популярных вопросов, на мой взгляд. Время от времени можно услышать вариации а-ля «Что такое прототипное наследование», «Инкапсуляция в JavaScript». Информацию можно найти тут или тут.

    Утечки памяти в JS. Огромная тема, можно минут 10 рассказывать, мне кажется. Самым лаконичным примером я считаю var a = {}; a.a = a;. Такой код создаст утечку в IE <= 7 версии, т.к. осёл до 8 версии не умеет чистить циклические зависимости. Должно хватить для простой демонстрации понимания механизма работы с утечками. Далее будут вопросы а-ля «Как создать утечку, используя фреймворк N». В деталях можно прочитать тут.

    Замыкания в JS. Нет, ну правда, какое собеседование без вопроса о замыканиях? Вопрос отчасти относится к предыдущему («Инкапсуляция в JavaScript»), но чаще всего рассматривается отдельно.

    Самовызывающиеся функции. Тоже весьма частый вопрос на собеседованиях. Ещё иногда подходят к этому со стороны jQuery: «Почему все плагины обособлены в конструкцию (function() {})();?».

    Область видимости переменных. Ключевое слово «this». Да и, честно говоря, всё, что связано с баблингом переменных и функций. Мол, чем отличается запись var a = function() {}; от записи function a() {};. Рассказать про this.

    Как поменять контекст функции. Частичное применение функции. Ну, тут можно оставить без комментариев, всё упирается в знание разницы между .call, .apply и .bind и некоторых стандартных решений на уровне языка. Обо всём этом можно прочитать в одной замечательной статье.

    Разница между операторами == и ===. За ответом сюда

    Напишите регулярное выражение для проверки строк соответствующих формату даты dd.mm.yyyy. Ну, тут и без комментариев всё понятно.

    Каков будет результат выполнения следующего кода:
    for (var i = 0; i < 10; i++) { 
      setTimeout(function () { 
        console.log(i); 
      }, 0); 
    }
    

    В дополнение к вопросу хочу сказать, что обычно вторым вопросом идет «Как сделать так, чтобы выводило цифры по порядку?»

    Что вернет выражение +new Date()? Чем отличается от Date.now(). Отличный вопрос. Ответ в том, что +new Date(); создаст экземпляр объекта Date и благодаря + переведет его в числовой формат. Во втором случае вызовется статический метод конструктора, который является более приоритетным, т.к. во-первых он не требует создания экземпляра, а во-вторых является более понятным.

    Напишите функцию принимающую строку с именем файла и возвращающую расширение (фрагмент после последней точки). Я просто оставлю ссылку на ответ.

    Производительность циклов. Иногда (но далеко не всегда) такой вопрос имеет место. Лично мне он нравится. По крайней мере, человек должен знать, почему for быстрее, чем Array.prototype.forEach. Но желательно ознакомиться с информацией из этой статьи.

    На этом, как правило, стандартные вопросы заканчиваются. Дальше идут вопросы, касательно специфики вакансии. Я имею ввиду, более «профильные» для компании. Например, если требуется JS разработчик со знанием Backbone/Marionette(Chaplin), то следующий блок вопросов будет про jQuery, underscore/lodash и прочие связанные технологии, как бы очевидно это не звучало. Вопросов по данным тематикам море, но парочку любимых я всё-таки приведу:

    Вопросы, относящиеся к jQuery


    Почему перед исходным кодом jQuery стоит восклицательный знак?

    Расскажите про $.Deferred. Могу посоветовать одно: кроме знания $.Deferred, было бы неплохо упомянуть о нативных Promise'ах

    Как создать утечку памяти с помощью jQuery.
    Я люблю простые примеры, поэтому обычно привожу следующее:

    var jqSelector = $("#selector"),
        nativeSelector = document.getElementById("selector");
    
    // Удаляем элемент "нативным" способом
    nativeSelector.parentNode.removeChild(nativeSelector);
    
    // Выводим закешированное значение селектора jQuery
    console.log(jqSelector); // Привет, jQuery.cache!
    

    А вообще, в части вопросов о нативном JS уже было похожее, и там же приведена ссылка на примеры с использованием jQuery.

    jQuery.extend. Рассказать всё про функцию, возможно попросят написать аналог. Кстати, возможно будет полезно прочитать статью про примеси в JS.

    Составьте AJAX-запрос на сервер, используя jQuery. Не особо популярный вопрос, но если спрашивать нечего, спросят что-то вроде него. Разумеется, вы должны знать, как использовать функции $.ajax, $.get, $.post и устанавливать настройки в $.ajaxSettings. Всё это уже давно есть на хабре.

    Остальные вопросы скорее «для массовки», я считаю, что о jQuery больше нечего спрашивать. Конечно, будут ещё вопросы типа «Как добавить класс к объекту, используя jQuery», но я думаю, это не будет неожиданностью и не вызовет проблем.

    Вопросы, относящиеся к Underscore/Lodash


    Такие встречаются, честно говоря, очень редко. Но всё же, приведу краткий список того, что я могу вспомнить:

    Чем _.throttle отличается от _.debounce. Опять же, ответ есть на хабре.

    Как работает функция _.extend. Аналог вопроса про jQuery.extend, ссылка на доку выше.

    Расскажите о шаблонизаторе Underscore. Кстати, не исключено, что это только начало, и вас будут спрашивать про шаблонизатор jQuery и все остальные. Я бы советовал хоть одним глазом прочитать эту статью.

    Lodash vs Underscore. Вопрос для разведения холивара на собеседованиях

    Что дальше?


    А дальше специальные вопросы, касательно фреймворков и библиотек, которые использует компания в своих проектах. Обычно, больше всего ценятся ответы на вопросы из категории «нативного» JS, да ведь оно и не мудрено: технологии появляются и исчезают, и совсем не удивительно, если программист о чём-то не слышал, но ответы на эту категорию вопросов показывают, как быстро человек может изучить и понять, как работает та или иная библиотека/фреймворк.

    Разумеется, если вам есть, что добавить к этой статье — пишите в лс, я обязательно дополню её вашей информацией.

    Спасибо f0rk за интересные вопросы.
    Поделиться публикацией
    Похожие публикации
    Реклама помогает поддерживать и развивать наши сервисы

    Подробнее
    Реклама
    Комментарии 313
    • 0
      спасибо, очень лаконично и со смыслом
      • +1
        Скопирую сюда некоторые вопросы, которые задаю на собеседовании

        1. Напишите функцию inArray проверяющую вхождение элемента в массив и возвращающую значение типа Boolean.
        2. Что вернет выражение +new Date()? Чем отличается от Date.now()?
        3. Напишите функцию принимающую строку с именем файла и возвращающую расширение (фрагмент после последней точки).
        4. Каков будет результат выполнения следующего кода:
        for (var i = 0; i < 10; i++) { 
          setTimeout(function () { 
            console.log(i); 
          }, 0); 
        }
        

        5. Напишите регулярное выражение для проверки строк соответствующих формату даты dd.mm.yyyy.
        6. Опишите разницу между операторами == и ===. Когда имеет смысл использовать каждый из вариантов?

        Иногда прошу реализовать bind или new ручками. Но если честно, люди, которых имеет смысл об этом просить встречаются не часто, к сожалению…
        • +2
          3 вопрос заинтриговал :)
          function getExt(filename){
           return filename.indexOf('.')!=-1?('.' + filename.split('.').pop()):'';
          }
          
          • –14
            так короче:
            return filename.split(".")[1];
            
            • +6
              Упс..image
              • 0
                Проще тогда так:

                var a = filename.split(".");
                return a[a.length-1];
                • 0
                  Одной строкой:
                  return text.match(/\.([a-zA-Z0-9]+)$/)[1];
                  • 0
                    P.S. сорри, уже заметил похожий вариант ниже. И _ забыл ).
              • 0
                ну, как минимум файлы бывают без расширений, да и никто не запрещает использовать точки в названиях :)

                например, в стандартном проекте есть файл:
                jquery.validate.unobtrusive.min.js

                ну и в windows, есть файлик «hosts», совсем без расширения.

                так что такой код — не круто :)
                • 0
                  а еще есть .tar.gz
                  • 0
                    это несколько расширений.
                • 0
                  del
                  • 0
                    del
                    • +1
                      Так не сработает, если имя файла будет содержать несколько точек. Можно так:

                      function getExtension(filename) {
                          var fragments = filename.split(".");
                          return fragments[fragments.length - 1];
                      }
                      
                      • 0
                        Забыли проверку на наличие точек
                        • +4
                          'sdaasddasasdasd.asdasdasdasd.sadasdsdasda.das'.split('.').pop();
                          'sdaasdsad'.split('.').pop()
                          ''.split('.').pop()
                          
                        • +1
                          ок, проспал… летс гоу эгейн:
                          (function(a){ return a[a.length-1]; })(filename.split("."))
                          
                          • 0
                            ".htaccess"
                            
                            "some.dir/else.dir/file-name-without-extension"
                            
                        • +6
                          'some.class.js'.substring('some.class.js'.lastIndexOf('.') + 1)
                          • 0
                            не знаю, почему-то жутко не люблю операция с позициями в строках, их надо всегда жутко внимательно проверять, появляются всякие +1, знаки больше/меньше и т. п.
                            • 0
                              Приведите пример. Я не докапываюсь, просто мне правда интересно, так как я возможно опрометчиво не боюсь подобных операций.
                              • +2
                                Вы не поверите, полазил по своему коду, не встретил ни одного вызова substring (больше 20 000 строк, последний проект), видимо страх где-то глубоко :)

                                А суть простая, например, взглянув на мой код, сразу понятно, с точкой я возвращаю или без. А вот смотря на
                                substring('some.class.js'.lastIndexOf('.') + 1)
                                

                                Надо напрягать мозги: вспоминать, что возвращает функция; рассчитывать количество символов; да и просто напрягаться, а почему + 1, а не просто вызов.

                                Хотя, если Вы каждый день пишите парсеры и т. п. То полагаю у Вас этот код не вызовет трудностей.
                                • –4
                                  Я думаю, что если у вас есть страх по поводу операций с позициями в строках, то у вас точно есть PHP-прошлое.
                                  А что касательно кода вашего и того, что выше — то я бы для себя может сделал как у вас, а на собеседовании бы докопались до того, что создается ненужный массив и всякое такое. Хотя вот недавно меня попросили что-то подобное решать двумя разными способами.
                                  • 0
                                    :) не, бог избавил от php, хотя пару страниц может и написал на нём.

                                    да, докопаться можно до чего угодно, хотя javascript, это не C++ и не Assembler, поэтому не вижу смысла оптимизировать такие простые функции, до того момента, пока профайлер не покажет на них. :)
                                    • 0
                                      Меня в Рамблер не взяли с такой формулировкой:
                                      В Вашем решении на Asp.net слишком мало Asp.net!


                                      Хотя я читал в вакансии, что знание xslt приветствуется, поэтому и «выпендрился» решив задание при помощи xml->xslt. :)
                                • 0
                                  Все от задачи, имхо. Если речь идет о получении расширения файла, то чего тут бояться.
                                • 0
                                  Решил так же, но сам к себе придрался, из-за lastIndexOf
                                  • +6
                                    Кстати, если сплясать от варианта devian (которого слишком уж, имхо, заминусовали), и поперчить его вариантом DenisNikolayev:

                                    'some.class.js'.split(".").pop();
                                    
                                    • +1
                                      Выдаст неверный ответ, если в имени файла вообще нет точки.
                                      • 0
                                        .join('')
                                  • +2
                                    Я однажды встречал где-то вот такой интересный способ.
                                    function getExt(filename)
                                    {
                                       return filename.substr((~-filename.lastIndexOf(".") >>> 0) + 2);
                                    }
                                    

                                    Работает почти корректно. Работает даже когда нету точек, или их больше одной. Не работает, если пустое имя файла (.htaccess) :-)
                                    • +1
                                      Не почти, а корректно. У .htaccess не пустое имя файла, это скрытый файл без расширения.
                                      • 0
                                        Это смотря с какой ОС посмотреть)
                                        • +1
                                          С точки зрения Win, это и вовсе некорректное имя файла. Во всяком случае создать такой файл с ходу она не позволяла. Про версию ОС, к сожалению, не уточню. Спасало либо наличие уже существующего файла с таким именем, либо командная строка. Поэтому давайте смотреть на задачи только с тех ОС, которые для них приспособлены? (=
                                          • +1
                                            Вы хотите сказать «с точки зрения приложения Explorer (проводник)», потому как например из командной строки или в FAR'е можно создавать такие файлы без проблем.
                                            • 0
                                              Да-да, именно об этом я и говорил.
                                        • –1
                                          Корректно или нет, зависит от задачи — например, нужно разрешить загрузку файлов только с определенными расширениями, в т.ч. и .htaccess, тогда нужно чтобы эта функция возвращала «htaccess».
                                          • +1
                                            Но обсуждаемая функция пропустит и somefile.htaccess. А если вам нужно загружать файл .htaccess, то вам, скорее всего, нужен исключительно .htaccess, и никаких somefile.htaccess. Это совсем другая задача, и проверять здесь нужно имя целиком.
                                        • 0
                                          Не совсем точно говорить, что это скрытый файл, в unix-архитектуре такого понятия нет. Зато есть ленивый программист, посадивший баг, последствиями которого мы пользуемся до сих пор: habrahabr.ru/post/221105/
                                          • 0
                                            Да, эта история мне известна. Но важно не то, как зародилось явление, а чем оно является на данный момент.
                                      • 0
                                        А мне нравятся regexp'ы. Вот это должно работать, вроде:
                                        function getExt(file_path) {
                                            return (/\.([^./]*$)/.exec(file_path) || [,null])[1];
                                        }


                                        Хотя, мне кажется, что оно будет возвращать undefined вместо null в старых IE (там, кажись, при несовпадении пустой массив возвращался, а не null, если мне не изменяет память). Железнобетонно можно так:
                                        Скрытый текст
                                        function getExt(file_path) {
                                            var ext = (/\.([^./]*$)/.exec(file_path) || [])[1];
                                            // ext может быть undefined или пустой строкой. Следующая строка это разруливает:
                                            // пустая строка (для file_path == 'empty ext.') сохраняется, а undefined (для file_path == 'without ext'), заменяется на более логичный null.
                                            return ext == null ? null : ext;
                                        }
                                        
                                        • 0
                                          Ну если любите регулярки, то у нас вот такое используется:
                                          ( /(?:\.)([^.]+$)/.exec('jquery.validate.unobtrusive.min.js') || [] )[1]
                                          • 0
                                            ( /(?:\.)([^.]+$)/.exec('justfile') || [] )[1]
                                            вернёт undefined. Имхо, функция должна возвращать null в таком случае. А ещё, если расширение — пустая строка (имя заканчивается точкой), то что возвращать? Понятно, что это крайние и бредовые случаи, но всё же…
                                            • 0
                                              Ну, мне кажется об этом думать необязательно. Это же собеседование, в конце концов, а не production-решения :)
                                        • 0
                                          Эээх, люблю я чейнинг. Код сделан с учетом всех замечаний про .htaccess и так далее.

                                          return filename
                                            .replace(/^\./, '')
                                            .split('.')
                                            .slice(-2)
                                            [1] || ''
                                          

                                          • 0
                                            Все чуть проще вроде как. Поправьте меня, пожалуйста
                                            function ext(filename){
                                              return filename.split(".").pop();
                                            }
                                            ext('js.ert.txt.gz') //"gz"
                                            
                                            • 0
                                              Извиняюсь, не обновлял комментарии 2 часа… Увидел уже такой вариант.
                                            • 0
                                              'some.class.js'.replace(/.*\./, '');
                                              
                                              • 0
                                                Может я чего не понял, но почему нельзя сделать так:
                                                'filename.min.js'.match(/[^.]+$/)
                                                • 0
                                                  Вернёт имя файла на имени без точки.
                                                  • –1
                                                    EZ :)

                                                    ('filename.min.js'.match(/[^.\s]\.([^.]+)$/)||[])[1] === «js»

                                                    ('.htaccess'.match(/[^.\s]\.([^.]+)$/)||[])[1] === undefined

                                                    ('.hidden.ext'.match(/[^.\s]\.([^.]+)$/)||[])[1] === «ext»

                                                    PS: не смотря на то то регулярные выражения не самая быстрая вещь на свете — они идеально подходят для решения данной задачи… ибо нам нужно найти… «регулярное выражение» :D
                                                    • 0
                                                      эмм, но согласитесь, что в условии четко написано «написать ф-ию, в которую передается имя файла». Если делать в каждом месте проверки на криворукость использующих функционал, то я даже не знаю… т.е. если ты в ф-ию передаешь 'filename', хотя в описании прописано что ф-ия делает, то ты кривой)))
                                                      • 0
                                                        эмм… а где у вас была функция? я лишь дополнил ваш RegExp. Вот вам функция.

                                                        function getExt(fn) { return (fn.match(/[^.\s]\.([^.]+)$/)||[])[1] }

                                                        Работает правильней любых других примеров и занимает меньше символом. Учитесь.
                                                        • 0
                                                          Подкол про наличие ф-ии засчитан :) Ф-ию писать не было нужны, т.к. основная часть заключается в регулярке…
                                                          регулярку можно тогда и покороче написать:

                                                          (fn.match(/[^.\s]\.([^.]+)$/)||[])[1]
                                                          (fn.match(/\.([^.]+)$/)||[])[1]
                                                          

                                                          ЗЫ а вот про «учитесь» это вы не по адресу =)
                                                          • 0
                                                            У вас там регулярка при каждом вызове создаётся.
                                                            • 0
                                                              На самом деле браузер кеширует такие регулярки и по факту они создаются только один раз.
                                                              • 0
                                                                Тоже верно. Ну тогда остаётся лишь заменить str.match(rgx) на rgx.exec(str) — одной буквой меньше :)
                                                        • 0
                                                          ЗЫ тем более, что из match совпадение мы получаем 2 элементом массива, в случае передачи названия без точки, мы получим undefined, так что все ок. Не знаю зачем такие длиные решения тут пишут =/
                                                      • –2
                                                        (function(name){return name.substr((name.lastIndexOf(".")+1)||name.length, name.length);})("txt.tar.gz");
                                                        

                                                        «txt.tar.gz» -> «gz»
                                                        «hosts» -> ""
                                                        • 0
                                                          что ж вы не обосновали ваш минус?
                                                        • –1
                                                          Возможно, оптимальнее было бы так, поскольку файлы чаще имеют расширения, чем нет…

                                                          function getExt(filename){
                                                           var parts = filename.split('.');
                                                           return (filename.length>1)?('.' + filename.pop()):'';
                                                          }
                                                        • –2
                                                          Добавил все, кроме 1. Слишком уж очевидно. Или я ошибаюсь?

                                                          function inArray(arr, item) {
                                                              return !!~arr.indexOf(item);
                                                          }
                                                          
                                                          • +7
                                                            Аж мурашки побежали от "!!~". Ну, почему бы просто не написать != -1?
                                                            Ну и плюс, полагаю, нужна поддержка большинства «любимых» браузеров семейства ie :)
                                                            • 0
                                                              Ну, все пишут, как им привычнее. В конечном счёте, это не production-код, а простое собеседование. Можно и != -1, конечно.
                                                              Вы мне только скажите, при чём тут IE?!!! — двойное логическое отрицание, а ~ — побитовое отрицание, почему они не должны работать в IE?
                                                              • 0
                                                                Не, я про indexOf у Array, он в старых IE не поддерживается.
                                                                • 0
                                                                  Так-то даже Яндекс уже поддерживает ИЕ лишь с 8-й версии и пилит полифиллы.
                                                                  Так что кажется такие пометки о неподдерживаемости стоит уже пропускать.
                                                          • 0
                                                            Каков будет результат выполнения следующего кода:
                                                            for (var i = 0; i < 10; i++) { 
                                                              setTimeout(function () { 
                                                                console.log(i); 
                                                              }, 0); 
                                                            }
                                                            


                                                            В дополнение к вопросу хочу сказать, что обычно вторым вопросом идет «Как сделать так, чтобы выводило цифры по порядку?»


                                                            Я ещё предлагаю написать 5 разных способов сделать чтобы цифры выводило по порядку. Совсем как бонус, показывает на сколько человек заинтересован темой и отличная ступенька для дальнейшего обсуждения на собеседовании.
                                                            • 0
                                                              А не поделитесь всеми пятью? Можно без кода, на словах. Интересно, насколько они разными будут и насколько отходить от исходного.
                                                              • +1
                                                                Способы довольно разные. Очень разные конструкции языка. С дом-элементами есть ещё шестой способ) Подсказки дам, давайте предположения в комментах в спойлерах:
                                                                Скрытый текст
                                                                1. Стандартный способ
                                                                2. Deprecated-способ
                                                                3. Deprecated-нуб-способ
                                                                4. Ecma5
                                                                5. Ecma6


                                                                Самые интересные, на моё мнение, второй и четвёртый.
                                                                • +2
                                                                  В принципе моего мышления есть одна проблема — неумение решать задачи типа «Сделайте n способами». Если нашелся один способ, который устраивает и подходит, разум отказывается даже думать в других направлениях. Другое дело, если найденный способ имеет недостатки. Там уже можно рассматривать поиск нового решения, отвечающего требованиям.

                                                                  Поэтому сходу могу предложить лишь один способ, и он, полагаю, как раз идет первым пунктом в вашем списке.
                                                                • +5
                                                                  Ох уж этот TheShock. Придумал только 3.

                                                                  Скрытый текст
                                                                  for (var i = 0; i < 10; i++) { 
                                                                    (function (i) {
                                                                      setTimeout(function () {
                                                                        console.log(i);
                                                                      }, 0);
                                                                    })(i)
                                                                  }
                                                                  
                                                                  for (var i = 0; i < 10; i++) { 
                                                                    setTimeout(function (i) {
                                                                      console.log(i)
                                                                    }.bind(undefined, i), 0)
                                                                  }
                                                                  
                                                                  for (var i = 0; i < 10; i++) { 
                                                                    setTimeout(function (i) {
                                                                      console.log(i)
                                                                    }, 0, i)
                                                                  }
                                                                  

                                                                  • +8
                                                                    Ой, я и забыл про то, что аргументы можно в setTimeout передать. Даже проверил на всякий случай. Так что это шестой способ.

                                                                    Вот ответы:

                                                                    Скрытый текст
                                                                    1. Стандартный способ — IIEF
                                                                    for (var i = 0; i < 10; i++) { 
                                                                      (function (i) {
                                                                        setTimeout(function () {
                                                                          console.log(i);
                                                                        }, 0);
                                                                      })(i)
                                                                    }
                                                                    


                                                                    2. Deprecated-способ. Довольно интересный, как на меня. Про него практически никто не знает, хотя это тот же let из Ecma6 который работает везде

                                                                    for (var i = 0; i < 10; i++) with({ i: i }) {
                                                                      setTimeout(function () {
                                                                        console.log(i);
                                                                      }, 0);
                                                                    }
                                                                    


                                                                    3. Deprecated-нуб-способ. Главное — не блевануть.
                                                                    for (var i = 0; i < 10; i++) { 
                                                                      setTimeout('console.log('+i+')', 0);
                                                                    }
                                                                    


                                                                    4. Ecma5 — способ, который я предпочитаю на практике. Для более сложного случая подойдёт тот вариант с bind, что написали вы)
                                                                    for (var i = 0; i < 10; i++) { 
                                                                      setTimeout(console.log.bind(console, i), 0);
                                                                    }
                                                                    


                                                                    5. Ecma6
                                                                    for (var i = 0; i < 10; i++) {
                                                                      let k = i;
                                                                      setTimeout(function () {
                                                                        console.log(k);
                                                                      }, 0);
                                                                    }
                                                                    


                                                                    6. Параметры
                                                                    for (var i = 0; i < 10; i++) { 
                                                                      setTimeout(function (i) {
                                                                        console.log(i)
                                                                      }, 0, i)
                                                                    }
                                                                    


                                                                    Ещё есть способы в случае с примером с dom-элементом и click (использовать data и event.target).

                                                                    7. Вот ещё способ додумал. Не очень интересный:
                                                                    var k = 0;
                                                                    for (var i = 0; i < 10; i++) {
                                                                      setTimeout(function () {
                                                                        console.log(k++);
                                                                      }, 0);
                                                                    }
                                                                    


                                                                    • +3
                                                                      Остается только повторить самого себя, ох уж этот TheShock.
                                                                      • 0
                                                                        Ну вы тоже молодец. Все три способа годны)
                                                                        Как мои способы? Разнообразны?
                                                                        • 0
                                                                          Еще как. Про with и eval я уже просто забыл, да и что там говорить, когда я пришел в js-тусовку так делать уже давно было порицаемо, так что просто ни разу не использовал.
                                                                        • +1
                                                                          7. Ну и чисто посмеяться добавочка:
                                                                          Скрытый текст
                                                                          new Array(10).join().split(',').forEach(function (item, index) {
                                                                            console.log(index)
                                                                          });
                                                                          

                                                                          • 0
                                                                            8. Еще

                                                                            Скрытый текст
                                                                            Добавляем перед for
                                                                            setTimeout = function(f){f()};
                                                                            • 0
                                                                              Ещё вариант, без join & split:

                                                                              Скрытый текст
                                                                              Array.apply(null, Array(10)).forEach(function (_, i) { console.log(i); });
                                                                              
                                                                          • 0
                                                                            Let достаточно умный:

                                                                            5. Ecma6
                                                                            for (let i = 0; i < 10; i++) {
                                                                              setTimeout(function () {
                                                                                console.log(k);
                                                                              }, 0);
                                                                            }
                                                                            
                                                                            • +1
                                                                              Я в консоли Фокса проверил — недостаточно умный(
                                                                              • 0
                                                                                К сожалению это Фокс недостаточно умный, как впрочем и node: оба пока не поддерживают let на 100% (https://developer.mozilla.org/en-
                                                                                US/docs/Web/JavaScript/ECMAScript_6_support_in_Mozilla)

                                                                                В спеке прописано поведение описанное выше, когда let создает замыкание для каждой итерации цикла.

                                                                                Правильное поведение выдает, например traceur (хоть и по-уродски)

                                                                                • 0
                                                                                  Правильное поведение выдает, например traceur (хоть и по-уродски)

                                                                                  А онлайн не генерит((
                                                                                  • 0
                                                                                    Вот тут открыть Options, поставить флаг experimental.

                                                                                    Результат смотреть в консоли браузера
                                                                            • 0
                                                                              Наконец-то я узнал, зачем вообще кто-то использует setTimeout со строковым параметром…

                                                                              Я думал, что передать функцию всегда проще, чем строку, а значит, строку передают только незнающие о том, как передать функцию. Оказывается, дело в незнании замыканий…
                                                                    • +1
                                                                      Тут вам уже поотвечали, но самого простого варианта для третьего задания пока ещё нет:
                                                                      function (s) {
                                                                          return s.replace(/.*\./, '')
                                                                      }
                                                                      
                                                                      Подразумевается, то параметр всегда строка и расширение у файла есть.
                                                                      • 0
                                                                        Oй, не обратил внимание, что вы уже это написали.
                                                                      • 0
                                                                        Капитанское решение:

                                                                        function getExt(filename){
                                                                          var res = false;
                                                                          if (filename) {
                                                                            var arr = filename.split('.');
                                                                            res = arr.length > 1 ? arr[arr.length - 1] : false;
                                                                          } 
                                                                          return res;
                                                                        }
                                                                        

                                                                        • 0
                                                                          Во-первых не нужна проверка if (filename) — вызывая функцию вы уже гарантируете, что передают имя файла,
                                                                          во-вторых если в имени файла нет расширения, то вы имеете все шансы вернуть почти полный путь к файлу (например файл /mydir/dir.2/home/myfile),
                                                                          в-третьих в случае отсутствия результата семантичнее возвращать null, а не false, который сигнализирует о пустом результате, а не отрицательном,
                                                                          в-четвертых для выражений с единой структурой по ряду причин лучше использовать регулярные выражения, а не split (например расширение не может содержать символ "/").
                                                                          Ну и если уж до конца идти, то проверка на существование значения лучше выглядит так: if (filename != null), ввиду отсутствия привидения типов.
                                                                          А объявления переменных, например arr лучше выносить вверх скоупа.
                                                                          Я бы немного поругался на такой код. :)
                                                                          • 0
                                                                            А объявления переменных, например arr лучше выносить вверх скоупа.


                                                                            Вот этого я не понимаю. Зачем? Как будто вернулся в школьные времена, к родному Паскалю. Да, есть variable hoisting, но это проблема только в очень больших функциях с кучей мелких переменных.
                                                                            • 0
                                                                              1) Составитель задания это не гарантирует. Скорее всего будут случаи, когда аргумент функции не определен или содержит null
                                                                              2) В задании есть фраза «фрагмент после последней точки», не вижу противоречий, про отделение имени файла от остальной части пути нас не просили.
                                                                              3) как бы да, но в таком случае есть опасность, что напишут нечто вроде
                                                                              if (getExt(fn) == null) {
                                                                              
                                                                              а это приведет к плачевным результатам
                                                                              4) Для такой пустяковой задачи рациональнее использовать сплит
                                                                              идти до конца нет смысла, но проверку на существование аргумента можно улучшить написав так
                                                                              if (filename + "") {
                                                                              

                                                                              С объявление переменных в начале скоупа соглашусь.
                                                                              С удовольствием взглянул бы на ваш вариант этой функции.
                                                                              • 0
                                                                                Обязательно напишу, но чуть позже — время уже позднее. Еще один кейс, который неожиданно вспомнился мне это скрытые файлы в unix системах. Например имя файла ".htaccess" не имеет расширения.
                                                                                Строго говоря по заданию «фрагмент после последней точки» у вас всё здорово и ни в коем случае на собеседовании не предъявил подобных претензий.
                                                                                В маленький локальный проект такой код можно поместить, но не в библиотеку.
                                                                                P.S.: Скорее всего даже не смогу с первого раза правильно написать регулярку, т.к. не помню ограничений различных файловых систем по наименованию. В *nix системах вроде только "/" нельзя использовать в названии файла, но могу ошибаться. :)
                                                                                P.P.S.: В целом на большинстве кейсов у вас хороший код, но реально в программировании всякое бывает, вспомнить только статью Заблуждения программистов относительно времени чего стоит.
                                                                        • +20
                                                                          Спасибо, сбегал, устроился.
                                                                            • +6
                                                                              Я тут собеседовался в одну топовую российскую контору, и мне всего-то навсего задали вопросы про замыканий, this, контекст и еще мелочи, в общем обычные вопросы, со слегка хитроумными формулировками(чтобы понять на сколько я хорошо понимаю синтаксис и особенности).

                                                                              Так что работодателям я бы посоветовал не переусердствовать с вопросами, а соискателям посоветовал бы приложить к резюме какой-нибудь рабочий код прямо в архиве и с демонстрацией, ну или профиль на гитхабе, если есть что показать.
                                                                              • +2
                                                                                Про архитектуру нужны вопросы, про модульность, про паттерны, а то многие конструкции писать научились, а воедино это свести не могут. Пишут вермишель, превышают все сроки и не знают, что можно по-другому.
                                                                                • НЛО прилетело и опубликовало эту надпись здесь
                                                                                  • +6
                                                                                    Я тоже разорился.
                                                                                    • 0
                                                                                      Сильно извиняюсь, не обратил внимания. Пережал, теперь 140Кб
                                                                                  • 0
                                                                                    после отпуска пригодится )
                                                                                    • +14
                                                                                      Никогда не понимал, почему спрашивают всякую фигню, которую то и знать не обязательно для успешного программирования… людям надо давать задания решить ту или иную задачу, и не спрашивать всякий бред
                                                                                      • +1
                                                                                        Это будет выглядеть как обезьяна с гранатой. Необходимость теоретических знаний обусловлена тем, что код надо не только «писать в ящик», но и поддерживать. Если человек не знает языка, то велика вероятность большого количества костылей, которые придется переписывать, чтобы на код можно было смотреть без слёз. Это не говоря уже об оптимизации узких мест и т.п.
                                                                                        • +2
                                                                                          Вот и посмотрите на код, который на следующий день напишет вам притендующий на должность… а приличные фирмы еще и обучают сотрудников, показывая почему такой то вариант не годится.
                                                                                          • 0
                                                                                            К сожалению, у меня был опыт работы с одним таким человеком, и он ещё раз подтверждает мои слова.
                                                                                            А по поводу фирм — вы правы, если мы рассуждаем о больших компаниях, то обучение персонала является важной составляющей. Однако, если мы говорим о каком-нибудь стартапе или небольшой компании, это становится непозволительной роскошью.
                                                                                            • –2
                                                                                              «если мы говорим о каком-нибудь стартапе или небольшой компании, это становится непозволительной роскошью»

                                                                                              Мотайте на ус господа программисты — там где вас мучают ничего не значащими тестами — это фирмы однодневки, в которых вас хотя просто «подоить» :)
                                                                                      • –10
                                                                                        А про ООП в JavaScript — надо отвечать — нет ООП в JavaScript. А потом уточнять недореализация. Если вопрошающий не соглашается — вставать и уходить — с такими людьми не сработаетесь.
                                                                                        • +3
                                                                                          По этому вопросу можно столько жарких споров учинить.

                                                                                          Например, Никлаус Вирт, категорически против того, чтобы выделять ОПП, как парадигму. Типа, взяли record, добавили сахарку с вызовом функций func(obj) на obj.func() и «внезапно», это стало новой крутой парадигмой :) У него в языке Оберон, например, так и использует обычные записи с сахаром в вызове методов. Плюс первая реализация ООП, была совсем иной, да и есть куча разношерстных реализаций (с посылкой сообщений, с множественным наследованием, интерфейсами с реализацией, с прототипированием и т. п.)

                                                                                          Так что, если не хотите на эту работу, можно спросить: «А что Вы понимаете под аббревиатурой ООП?» :)
                                                                                          • –8
                                                                                            Если есть желание, можем поговорить, но думаю вначале стоит прочитать

                                                                                            Существуют только структурная и объектная парадигмы программирования.
                                                                                            • –5
                                                                                              «добавили сахарку с вызовом функций func(obj) на obj.func()»

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

                                                                                                Э-э, што?
                                                                                                в случае
                                                                                                var obj = Class();

                                                                                                в obj будет объект, а не массив, более того, массив в JS — это тоже объект:
                                                                                                var a = [];
                                                                                                toString.apply(a);
                                                                                                

                                                                                                выведет:
                                                                                                [object Array]

                                                                                                Это тоже важно, так как показывает, что мы вызываем функцию конкретного объекта, а не передаем не понятно чьей функции (т.е. функции в глобальной куче)
                                                                                                да, не передаём, но это синтаксис. Функции как бы всё равно с каким this она работает.
                                                                                                ведь при наследовании она работает с не объектом класса, где она была определена, а с объектом дочернего класса.

                                                                                                В C#, например, можно делать функции, которые будут добавляться как методы во встроенные классы, String, например.
                                                                                                В Перле тоже можно сделать внешнюю функцию, которую с помощью специальной команды bless можно прицепить к какому-нибудь классу (хотя в Перле пакеты, а не классы, но для простоты назовём класс).
                                                                                                • +1
                                                                                                  var obj = Class();
                                                                                                  

                                                                                                  ---->
                                                                                                  var obj = new Class();
                                                                                                  

                                                                                                  • 0
                                                                                                    Ого, привет с кадабры.
                                                                                                    В последнее время стало модным пихать во все конструкторы проверку this instanceof Class, толпы JS-ников привыкли и напрочь забыли оператор new. Так что и такая запись сгодится для понимания =)
                                                                                              • 0
                                                                                                Конечно же обычно вызов метода реализуется как функция с нулевым аргументом-this, но всё же func(obj) != obj.func(), так как существуют виртуальные функции, полиморфизм. Я категорически против того, чтобы выделять Никлауса Вирта в отдельную парадигму.
                                                                                                • 0
                                                                                                  Есть структурный полиморфизм (утиная типизация)! :)

                                                                                                  Да, с виртуальными функция сложнее, но сейчас многие рекомендуют не создавать больших иерархий объектов, не больше двух уровней (интерфейс и реализация). А вместо наследования реализовывать ассоциацию. Причем достаточно много классов в C# помечены атрибутом sealed, запрещающим наследование.

                                                                                                  Читал множество критики наследования, всяких уток от птиц и т. п. Так что похоже можно жить без него :)

                                                                                                  • 0
                                                                                                    Полиморфизм можно реализовать не только через виртуальные методы на обьектах. Есть же мультиметоды, протоколи (clojure).
                                                                                                • +8
                                                                                                  ммм, не хочу вас расстраивать, но JS соответствует парадигме ООП
                                                                                                  • –21
                                                                                                    Нет.
                                                                                                    • +7
                                                                                                      Могу я услышать ваши аргументы на этот счёт?
                                                                                                      • –16
                                                                                                        Я бы хотел услышать как в JS описать класс :)
                                                                                                        • +7
                                                                                                          Вместо класса — объект-прототип. Если интересно, можете прочитать про прототипное программирование, которое входит в понятие ООП.
                                                                                                          • –16
                                                                                                            Давайте не кидаться ссылками. Мне не надо про это читать. А вот утверждения вида " прототипное программирование, которое входит в понятие ООП" нужно обосновывать. Я утверждение надуманное, ничего там и близкого нет с ООП.
                                                                                                            • +3
                                                                                                              Давайте не кидаться ссылками, но вы не верите мне на слово, я и подкрепляю свои слова достоверными источниками. Есть вполне себе ясная трактовка парадигмы ООП и её составляющих.

                                                                                                              А вот утверждения вида " прототипное программирование, которое входит в понятие ООП" нужно обосновывать

                                                                                                              Оно обосновано ссылкой, которую я привел выше.

                                                                                                              Я утверждение надуманное, ничего там и близкого нет с ООП.

                                                                                                              А вот это было бы неплохо обосновать.
                                                                                                              • –14
                                                                                                                Ссылка на Википедию :)
                                                                                                                • +3
                                                                                                                  Если вы считаете википедию сомнительным источником, вы можете привести свой, более надёжный и достоверный источник. Однако, я до сих пор не увидел ни одного подтверждения вашей позиции. Было бы здорово, если бы вы начали свой ответ с этого.
                                                                                                                • –6
                                                                                                                  Но я вам дам определение Г. Буча — думаю сомнений в его компетенции не возникает?

                                                                                                                  1. ООП использует в качестве базовых элементов объекты, а не алгоритмы
                                                                                                                  2. Каждый объект является экземпляром какого-либо определенного класса
                                                                                                                  3. Классы организованны иерархически

                                                                                                                  Программа будет объектно-ориентированной только при соблюдении всех трех указанных требований


                                                                                                                  Поэтому мы можем порассуждать, что такое и насколько хорошо прототипное программирование, только связи с ООП тут нуль целых.
                                                                                                                  • –5
                                                                                                                    И в частности Буч продолжает:

                                                                                                                    В частности, программирование, не основанное на иерархических отношениях, не относится к ООП, а называется программированием на основе абстрактных типов данных.


                                                                                                                    Продолжая же его мысль, можно сказать что программирование без классов, т.е. без абстрактных типов данных — тем более не является ООП, и может называться прототипным программированием. Хотя концепция этого программирования достаточно смешна по сравнению с ООП — и это можно обсудить детальнее если будет интерес. Но вначале совершенно не провомочно делать вид, что прототипное программирование как то относится к ООП.
                                                                                                                    • +5
                                                                                                                      Объект-прототип является таким же абстрактным типом данных, что и класс, поэтому никакой ошибки здесь нет. С помощью прототипного наследования можно реализовать иерархические отношения между объектами.
                                                                                                                      • 0
                                                                                                                        Ниже пример и вопрос: как мне узнать что объект принадлежит типу ClassExample?
                                                                                                                  • 0
                                                                                                                    Вы знаете, что ссылаетесь на книгу «Object Oriented Analysis and Design» 91/94 года выпуска?
                                                                                                                    Я ни капельки не сомневаюсь, что в те года это было абсолютно правильно. Но разумеется, многое изменилось за 20 лет, и парадигма ООП существенно расширилась за это время.
                                                                                                                    • 0
                                                                                                                      :) парадигмы не меняются… возникают новые, а то что некоторые хотят к ней примазаться — это скорее плохо, т.к. дискридитируют саму парадигму. ООП — это не все что можно придумать :)

                                                                                                                      Да и потом Вы пока не сослались не на что
                                                                                                                      • +1
                                                                                                                        Ну, я бы не называл всемирную интернет-энциклопедию «ничем». По моему скромному мнению, на данный момент это самый полный и достоверный источник знаний.

                                                                                                                        Если они не меняются, то должна быть отправная точка — своеобразная спецификация, формулировка, которая является «единственно правильной». Вы можете её привести? Можете считать это доказательством от обратного. Найдете — ваша правда, не найдете — моя. И пожалуйста, пусть это будет формулировка из этого тысячелетия.
                                                                                                                        • –9
                                                                                                                          Уж поверьте мне — я прекрасно знаю как пишется этот «достоверный источник». Все зависит от автора. Ну и потом Википедия сама говорит, что он не является достоверным источником :)

                                                                                                                          И вот такие люди принимают собеседование :) — остаюсь при своем мнении — вставать и уходить, не вам оценивать знания других :)
                                                                                                                          • +9
                                                                                                                            Ну, в свою очередь, могу сказать, что рад, что не работаю с такими людьми.
                                                                                                                            • 0
                                                                                                                              Он же сразу и честно написал: «Не сработаемся» (:
                                                                                                                              Встал и ушёл — и хорошо, пусть к вам придёт другой человек, а он придёт к другим людям.
                                                                                                                              • 0
                                                                                                                                Весной собеседовал одного кандидата с аналогичной позицией. Жаль это было по скайпу…
                                                                                                                              • 0
                                                                                                                                del
                                                                                                                          • +6
                                                                                                                            Прототипное программирование является более «объектным», чем классовое, так как в языках с иерархией классов существуют объекты нескольких типов — объекты классы и объекты экземпляры, и смысл их разный, а в прототипном все объекты унифицированы. И всё это изменилось не с 1994, а было известно и проверено ещё в 70-e во времена возникновения Smalltalk и Self. Не нужно полагать, что история началась с C++ ;-)
                                                                                                                          • +2
                                                                                                                            1. ООП использует в качестве базовых элементов объекты, а не алгоритмы
                                                                                                                            2. Каждый объект является экземпляром какого-либо определенного класса
                                                                                                                            3. Классы организованны иерархически

                                                                                                                            Программа будет объектно-ориентированной только при соблюдении вех трех указанных требований

                                                                                                                            1. создавай объект в JS, и будут тебе объект
                                                                                                                            2. невероятно, но это так! даже пустой литеральный объект — это экземпляр класса Object (правда в JS класс — это тоже объект)
                                                                                                                            3. невероятно, но по цепочке прототипов в JS есть иерархия до верхнего класса Object

                                                                                                                            • 0
                                                                                                                              Ну вы же сами понимаете, что инстанс Object в JS это не объект в понимании классического ООП. Это ближе к Hash в руби или Map какой-нибудь там в джаве. Просто назвали так.

                                                                                                                              Да и не все в жс объекты. 4 instanceof Object === false. Да даже 4 instanceof Number === false.

                                                                                                                              Давайте я скажу вам факт, после которого ООПсрач можно закрыть будет? Если нет желания срача ради срача.
                                                                                                                              ООП в жс есть. Но оно канонично использовалось для механизмов работы DOM, глубоко интегрированных в реализации языка, сам подход в ЖС всегда был преимущественно функциональным, то, что создаются методы — это необходимый сахар из-за невозможности делать оверлоад функций.
                                                                                                                              Без ООП пришлось бы для каждого типа ноды назначать свои методы, потому что не было бы цепочки HTMLAudioElement -> HTMLMediaElement -> HTMLElement -> Node -> EventEmitter -> Object (могу путать точный порядок).
                                                                                                                              • 0
                                                                                                                                Ну вы же сами понимаете, что инстанс Object в JS это не объект в понимании классического ООП

                                                                                                                                Чем он отличается, и что в вашем понимании «классическое ООП»

                                                                                                                                Да и не все в жс объекты. 4 instanceof Object === false. Да даже 4 instanceof Number === false.

                                                                                                                                Разумеется. Ещё есть примитивы, которые не являются объектами, но это никак не противоречит парадигме ООП.

                                                                                                                                ООП в жс есть

                                                                                                                                Есть. И оно подходит без всяких «натяжек» под каноны ООП. С историей становления JS вы абсолютно правы, но перед ним и не стояло тех задач, которые стоят сейчас. Разумеется, язык развивается вместе с требованиями к нему.

                                                                                                                                Я поддерживаю идею не разводить срач.
                                                                                                                                • –5
                                                                                                                                  > И оно подходит без всяких «натяжек» под каноны ООП.

                                                                                                                                  Просто фиерическое утверждение :)

                                                                                                                                  Помимо уже обсужденных натяжек… опишите мне как переопределить функцию в классе наследнике?
                                                                                                                                  • –2
                                                                                                                                    т.е. аналог

                                                                                                                                    	public class A
                                                                                                                                    	{
                                                                                                                                    		public virtual void M1()
                                                                                                                                    		{ }
                                                                                                                                    	}
                                                                                                                                    
                                                                                                                                    	public class B : A
                                                                                                                                    	{
                                                                                                                                    		public override void M1()
                                                                                                                                    		{
                                                                                                                                    			base.M1();
                                                                                                                                    			...
                                                                                                                                    		}
                                                                                                                                    	}
                                                                                                                                    
                                                                                                                                    

                                                                                                                                    • 0
                                                                                                                                      del
                                                                                                                                      • 0
                                                                                                                                        см. комментарий ниже — вы реализовали нечто другое :) и назвали не правильно :)

                                                                                                                                        А если вдруг озоботитесь ответом на вопрос чем наследование отличается от агрегирования, может на шаг вперед продвинетесь в изучении ООП.
                                                                                                                                        • 0
                                                                                                                                          Ну, вы несколько путаете: использование/переопределение методов родительского класса и использование их в перегружаемом методе — разные вещи. При чём последнее никак не описывается в требованиях к языку, соответствующему парадигме ООП.

                                                                                                                                          А то, что вы хотите подменить понятия, не характеризует вас как хорошего собеседника.
                                                                                                                                          • 0
                                                                                                                                            Что-то я не понял, это какие такие я понятия подменяю? Хороший собеседник с вас получился бы если бы вы признали, что в JS не реализованно наследование, о чем я вам убедительно продемонстрировал. Если же вы этого не признаете — это вы подменяете понятия — наследование для вас тоже самое, что агрегация… ну что же — жаль…
                                                                                                                                      • –1
                                                                                                                                        function A() {
                                                                                                                                          this.M1 = function() {
                                                                                                                                            console.log("m1 from A");
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        
                                                                                                                                        var instanceA = new A();
                                                                                                                                        
                                                                                                                                        function B() {
                                                                                                                                          this.M1 = function() {
                                                                                                                                            instanceA.M1();
                                                                                                                                            console.log("m1 from B");
                                                                                                                                          }
                                                                                                                                        }
                                                                                                                                        
                                                                                                                                        B.prototype = instanceA;
                                                                                                                                        
                                                                                                                                        var instanceB = new B();
                                                                                                                                        instanceB.M1();
                                                                                                                                        


                                                                                                                                        Если я вас правильно понял.
                                                                                                                                    • 0
                                                                                                                                      something.prototype.someFunction = function(a1, a2, a3)
                                                                                                                                      {
                                                                                                                                      somethingVeryParent.prototype.someFunction.call(this, a1, a2, a3);
                                                                                                                                      }
                                                                                                                                      
                                                                                                                                      

                                                                                                                                      если мне не изменяет память.
                                                                                                                                      • 0
                                                                                                                                        А вот у меня устойчивое впечатление, что на JS (хоть вы и не показали весь код) Вы реализовали совсем другую концепцию, а не переопределение функции в наследнике. По сути JS подменяет это решением вида:

                                                                                                                                        	public class O
                                                                                                                                        	{
                                                                                                                                        		public object prototype;
                                                                                                                                        	}
                                                                                                                                        
                                                                                                                                        	public class A : O
                                                                                                                                        	{
                                                                                                                                        		public void M1()
                                                                                                                                        		{ }
                                                                                                                                        	}
                                                                                                                                        
                                                                                                                                        	public class B : O
                                                                                                                                        	{
                                                                                                                                        		public void M1()
                                                                                                                                        		{
                                                                                                                                        			A a = prototype as A;
                                                                                                                                        			if (a != null)
                                                                                                                                        			{
                                                                                                                                        				a.M1();
                                                                                                                                        			}
                                                                                                                                        		}
                                                                                                                                        	}
                                                                                                                                        
                                                                                                                                        


                                                                                                                                        Причем присвоение прототипа мне почему то надо делать за рамками класса. (в коде это не показано)

                                                                                                                                        А я хочу, чтобы я мог создать конструкцию именно наследования и переопределения.
                                                                                                                                  • 0
                                                                                                                                    4..valueOf(); // 4
                                                                                                                                    

                                                                                                                                    Даже у примитивов есть свойства

                                                                                                                                    • НЛО прилетело и опубликовало эту надпись здесь
                                                                                                                                • –1
                                                                                                                                  Буч идет лесом. Для ООП важно понятие интерфейса (или контракта), понятие класса нафиг не нужно.
                                                                                                                            • –1
                                                                                                                              Теперь про класс. Как по вашему для чего в языках ООП присутствует класс и его эксземпляры объекты?