30 дней JavaScript | Литкод | 2704. Быть или не быть

Я решил принять вызов 30 дней JavaScript, предлагаемых Leetcode. Большинство вопросов несложные, однако, на мой взгляд, их стоит выполнить, даже если вы старший разработчик.

Давайте сначала прочитаем вопрос:

«Напишите ожидаемую функцию, которая поможет разработчикам тестировать свой код. Он должен принимать любое значение val и возвращать объект со следующими двумя функциями.

toBe(val) принимает другое значение и возвращает true, если два значения === друг другу. Если они не равны, должно появиться сообщение об ошибке «Не равно».
notToBe(val) принимает другое значение и возвращает true, если два значения !== совпадают друг с другом. Если они равны, должна появиться ошибка «Равно».

Нам были даны разные примеры, чтобы глубже понять вопрос, например:

Input: func = () => expect(5).toBe(5)
Output: {"value": true}
Explanation: 5 === 5 so this expression returns true.

Основываясь на моем опыте работы с Leetcode, наиболее важным аспектом задач такого типа является внимательное прочтение вопросов и полное понимание концепции. Это помогает сэкономить много времени и нервов.

Следующим шагом является разделение его на куски, которые будут решаться шаг за шагом.

Давайте разберемся, что происходит:

В первой части важной информацией является то, что наша функция должна возвращать объект {}. Это то, что немного изменит структуру нашей функции. Мы берем в качестве параметра любое возможное значение, а это значит, что это может быть целое число, строка, логическое значение и так далее.

Наш объект должен состоять из/возвращать две функции: toBe(val) и notToBe(val). На этом этапе мы уже можем написать структуру для нашей функции expect():

var expect = function(val) {
function toBe(){
//..
}
function notToBe(){
//..
}
return [toBe, notToBe]
}

Приведенный выше синтаксис можно изменить для более «чистого» решения, которое может выглядеть так:

var expect = function(val) {
     return {
        toBe: (val2) => {
           //..
        },
        notToBe: (val2) => {
           //..
        }
    }


};

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

Давайте перейдем к другому фрагменту задачи и сосредоточимся на двух функциях:

toBe(val) принимает другое значение и возвращает true, если два значения === друг другу. Если они не равны, должно появиться сообщение об ошибке «Не равно».

toBe() не принимает val в качестве параметра, поэтому мы должны взять что-то еще. Я назвал его val2, но это может быть что угодно: valSecond, valAnother и так далее. Причина, по которой он не принимает один и тот же параметр val, заключается в том, что существует условное событие, которое делает эти два значения сопоставимыми.
В этой ситуации (и любой другой задаче leetcode) может быть очень полезно также посмотреть имена функций, потому что их имена не случайны.

toBe() означает, что условие будет сравнительным. Эта функция вернет true только тогда, когда два значения — val и val2 равны. Так, например, если val=5 и val=5 функция вернет true. Если, например, val=5 и val2=3, то функция должна выдать ошибку со строкой «Не равно».

 var expect = function(val) {
     return {
        toBe: (val2) => {
           if (val === val2){ 
              return true
              }
            else {
                throw new Error("Not Equal")
            }
        },
       }

это также можно записать так:

var expect = function(val) {
     return {
        toBe: (val2) => {
            if (val !== val2) throw new Error("Not Equal");
            else return true;
        }};

В приведенном выше коде мы просто изменили условный вопрос: если два значения не совпадают, то выдается ошибка. Если они верны, просто верните true

Хорошо, а как насчет второй функции?

notToBe(val) принимает другое значение и возвращает true, если два значения !== совпадают друг с другом. Если они равны, должна появиться ошибка «Равно».

Это просто ложная версия функции toBe(). Снова мы сравниваем val с val2, чтобы проверить, не равны ли два значения:

 var expect = function(val) {
     return {
        toBe: (val2) => {
           if (val === val2){ 
              return true
              }
            else {
                throw new Error("Not Equal")
            }
        },
        notToBe: (val2) => {
            if (val !== val2){
                return true
            } else {
                throw new Error("Equal")
            }
        }
        }};

если val и val2 не равны, вернуть true (поскольку истинность функции notToBe() происходит, когда значения не равны). Если значения равны, то выбрасываем ошибку с сообщением. Окончательный код может выглядеть так:

var expect = function(val) {
     return {
        toBe: (val2) => {
            if (val !== val2) throw new Error("Not Equal");
            else return true;
        },
        notToBe: (val2) => {
            if (val === val2) throw new Error("Equal");
            else return true;
        }
    }
};

Вот и все. Суть решения leetcode заключается в том, чтобы прочитать все, что написано в консоли, даже название функции. Вопросы не сложные, и в нашем уме мы можем решить их без посторонней помощи за несколько секунд. Реальность наступает тогда, когда нам приходится переводить свои мысли в код, и дело в том, что он охватывает все случаи за минимальное количество времени. Однако такова истинная природа алгоритмов.

30 дней JavaScript | Литкод | 2704. Быть или не быть

Вопросы по теме