{"draftJsState":{"blocks":[{"data":{"image":{"id":"63e2a50813be593486b320bf"}},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"atomic:image","key":"a0ud9"},{"data":{},"depth":0,"entityRanges":[{"key":0,"length":22,"offset":10}],"inlineStyleRanges":[],"text":"Источник: Nuances of Programming","type":"unstyled","key":"8p1n0"},{"data":{},"depth":0,"entityRanges":[{"key":1,"length":89,"offset":0}],"inlineStyleRanges":[{"length":39,"offset":0,"style":"BOLD"}],"text":"Курс SkillFactory Frontend-разработчик. Получите перспективную творческую профессию в IT.","type":"unstyled","key":"ffb1h"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"ля любого разработчика рекурсия — это заклятый враг, с которым по силе могут сравниться лишь ее друзья — регулярные выражения.","type":"unstyled","key":"brgu9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Сложность в понимании рекурсии объясняется двумя причинами. Во-первых, приходится уложить в голове принцип вызова функцией самой себя. Во-вторых, нужно понять разницу между базовым случаем и рекурсивным, иначе вы застрянете в бесконечном цикле, пока не возникнет переполнение стека.","type":"unstyled","key":"241tp"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Если же вы справитесь с освоением этих 2 принципов, то рекурсия покажется не столь сложной, как можно подумать. Рекурсивный код зачастую короче писать, а иногда даже проще читать.","type":"unstyled","key":"e6mji"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Дальше мы разберем пять примеров кода. Каждую задачу мы будем решать сначала с помощью циклов, а затем с помощью рекурсии. Какой подход окажется лучше? Это уже решать вам.","type":"unstyled","key":"8j3na"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Пример #1: факториал","type":"header-three","key":"tfau"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Напишем функцию, которая позволяет вычислять факториал для положительных целых чисел. Записываются факториалы так: 5!, а формула для них выглядит так:","type":"unstyled","key":"bs7mu"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"n! = n * (n - 1) * (n - 2) * ... * 1","type":"blockquote","key":"8fmj8"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Тогда 5! будет равно:","type":"unstyled","key":"bogq9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"5! = 5 * 4 * 3 * 2 * 1 = 120","type":"blockquote","key":"9in17"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Как написать для этого функцию? Один из вариантов предполагает использование цикла while. Можно создать переменную для result, а затем умножить ее на x в цикле, каждый раз декрементируя x на 1. Вот соответствующий код:","type":"unstyled","key":"c97jp"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"export const factorial = (x) => {\n if (x < 0) {\n throw new Error('x must be greater than or equal to 0');\n }\n\n if (x <= 1) {\n return 1;\n }\n\n let result = 1;\n\n while (x > 0) {\n result *= x;\n x--;\n }\n\n return result;\n};","type":"blockquote","key":"4n0vk"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Заметьте, что мы также обработали неверные входные значения меньше 0 и упростили случаи с 0 и 1, поскольку и 0!, и 1! равны 1.","type":"unstyled","key":"2ncj9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Итак, это решение с помощью цикла. А что, если мы захотим написать эту функцию рекурсивно? Рекурсивное решение может выглядеть так:","type":"unstyled","key":"17v8q"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"export const factorial = (x) => {\n if (x < 0) {\n throw new Error('x must be greater than or equal to 0');\n }\n\n if (x <= 1) {\n return 1;\n }\n\n return x * factorial(x - 1);\n};","type":"blockquote","key":"b8tnr"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Гораздо короче. Заметьте, что в последней строке мы возвращаем x, умноженную на результат повторного вызова той же функции factorial с аргументом x-1. Это и есть рекурсивный случай.","type":"unstyled","key":"7l16b"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Если просто вызывать функцию рекурсивно, то получится бесконечный цикл, значит нужен способ его разорвать. Именно поэтому у нас есть условие, которое срабатывает, когда x <= 1. При достижении этой точки мы перестаем рекурсивно вызывать функцию factorial — это базовый случай.","type":"unstyled","key":"be9si"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Готовы к очередному примеру?","type":"unstyled","key":"d9h4u"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Пример #2: возведение в степень","type":"header-three","key":"25spm"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Разберем похожий случай. На этот раз мы реализуем функцию возведения в степень. Например, 2^3 — это 2, возведенное в 3-ю степень, то есть 2 * 2 * 2, что равно 3.","type":"unstyled","key":"3loj9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В JavaScript есть 2 нативных способа возведения чисел в степени. В нашем случае это либо вызов Math.pow(2, 3), либо использование степенного синтаксиса вроде 2 ** 3. Сейчас же представим, что этих возможностей не существует. Как тогда можно написать подобную функциональность самим?","type":"unstyled","key":"3bab6"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Используя цикл while, можно создать функцию вроде такой:","type":"unstyled","key":"98i7h"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"export const power = (x, y) => {\n if (y < 0) {\n throw new Error(\n 'exponent must be greater than or equal to 0 (for the purposes of this example)'\n );\n }\n\n if (y === 0) {\n return 1;\n }\n\n let result = 1;\n\n while (y > 0) {\n result *= x;\n y--;\n }\n\n return result;\n};","type":"blockquote","key":"5k51r"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Заметьте, что в этом примере мы будем игнорировать отрицательные степени, хотя в реальности они вполне допустимы. Кроме того, мы будем обрабатывать случай, в котором степень равна 0, поскольку любое число в степени 0 всегда равно 1 (2^0 = 1).","type":"unstyled","key":"27rah"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"По аналогии с примером факториала мы начали с result равного 1, после чего стали циклически умножать result на x, пошагово уменьшая y до момента достижения 0.","type":"unstyled","key":"2bf4a"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"А вот как будет выглядеть рекурсивное решение:","type":"unstyled","key":"e10rp"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"export const power = (x, y) => {\n if (y < 0) {\n throw new Error(\n 'exponent must be greater than or equal to 0 (for the purposes of this example)'\n );\n }\n\n if (y === 0) {\n return 1;\n }\n\n return x * power(x, y - 1);\n};","type":"blockquote","key":"1v4fn"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"И снова это решение оказалось короче! В последней строке у нас рекурсивный случай, когда мы умножаем x на результат вызова функции power с x и декрементируемым аргументом y-1.","type":"unstyled","key":"4fvll"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Помимо этого, у нас есть базовый случай, в котором при y равном 0 мы возвращаем 1. Таким образом мы исключаем возможность бесконечного вызова функции power.","type":"unstyled","key":"5f532"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Интересный нюанс здесь в том, что в обоих рекурсивных решениях не нужно отслеживать переменную result — это делает за нас стек вызовов.","type":"unstyled","key":"7u0e8"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Продолжаем.","type":"unstyled","key":"ds8np"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Пример #3: сумма чисел в массиве","type":"header-three","key":"33fkb"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Теперь мы напишем функцию, суммирующую все числа в массиве. В JavaScript есть метод reduce, который предоставляет простой инструмент для сведения массива в сумму его элементов:","type":"unstyled","key":"fmq9q"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"numbers.reduce((number, sum) => number + sum, 0);","type":"blockquote","key":"36d3h"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Сейчас же мы снова представим, что reduce не существует. Как тогда написать собственную функцию? Один из вариантов — это использовать цикл for для перебора всех элементов массива и их сложения. Код получится таким:","type":"unstyled","key":"62mi5"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"export const sumNumbersArray = (numbers) => {\n let sum = 0;\n\n for (let i = 0; i < numbers.length; i++) {\n sum += numbers[i];\n }\n\n return sum;\n};","type":"blockquote","key":"9047p"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Коротко и просто. А что, если мы захотим сделать это рекурсивным способом? Тогда есть такой вариант:","type":"unstyled","key":"e0p00"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"export const sumNumbersArray = (numbers) => {\n if (numbers.length === 0) {\n return 0;\n }\n\n return numbers[0] + sumNumbersArray(numbers.slice(1));\n};","type":"blockquote","key":"9ne8"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Здесь мы каждый раз прибавляем первое число к результату вызова функции sumNumberArray для оставшейся части массива за исключением этого самого первого числа.","type":"unstyled","key":"63itb"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"А будет ли такое решение оптимальнее использования цикла for? Это субъективный вопрос, но я считаю, что использование здесь рекурсии выглядит менее естественным. А что думаете вы?","type":"unstyled","key":"1h1r0"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Пока вы думаете, нас ждет очередной пример.","type":"unstyled","key":"eck9f"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Пример #4: поиск наибольшего числа в массиве","type":"header-three","key":"4csep"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В этом примере мы напишем функцию, получающую массив чисел и возвращающую наибольшее из них. В JavaScript для этого можно использовать вспомогательную функцию Math.max:","type":"unstyled","key":"7cbv"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Math.max(...numbers);","type":"unstyled","key":"7ae3e"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Но в целях эксперимента снова нужно представить, что такой функциональности нет. Как тогда написать ее самим? При использовании цикла for решение получится таким:","type":"unstyled","key":"92rqb"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"export const maxNumberArray = (numbers) => {\n let max = numbers[0];\n\n for (let i = 1; i < numbers.length; i++) {\n if (numbers[i] > max) {\n max = numbers[i];\n }\n }\n\n return max;\n};","type":"blockquote","key":"3454t"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Здесь мы изначально предполагаем, что первое число в массиве является наибольшим, после чего начинаем этот массив перебирать, начиная со второго элемента и сравнивая текущий элемент с найденным максимальным. Если текущий элемент оказывается больше последнего максимального, мы обновляем это максимальное значение. По завершению перебора всего списка у нас остается наибольшее число.","type":"unstyled","key":"vgcb"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Вроде все просто. А теперь посмотрим на рекурсивный вариант решения:","type":"unstyled","key":"5bp1o"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"export const maxNumberArray = (numbers) => {\n if (numbers.length <= 1) {\n return numbers[0];\n }\n\n const numberA = numbers[0];\n const numberB = maxNumberArray(numbers.slice(1));\n\n return numberA > numberB ? numberA : numberB;\n};","type":"blockquote","key":"6fes6"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Не кажется ли он вам несколько более сложным для понимания? Давайте его разберем.","type":"unstyled","key":"2n3mo"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Если в массиве находится 0 или 1 элемент, то мы просто возвращаем 1-ый (undefined в случае пустого массива). Это базовый случай.","type":"unstyled","key":"5dqsi"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Для массивов, содержащих 2 и более элементов, мы будем выполнять сравнение — брать 1-ый элемент и сравнивать его с результатом рекурсивного вызова maxNumberArray для оставшейся части массива, в завершении возвращая наибольшее число.","type":"unstyled","key":"cp71r"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Не особо понятно? Мне тоже.","type":"unstyled","key":"f02h"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Рассмотрим пример вызова maxNumberArray и поэтапно его разберем. Представьте, что мы вызываем эту функцию с такими аргументами:","type":"unstyled","key":"9vkka"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"maxNumberArray([1, 9, 5, 7, 3, 8, 2, 4])","type":"blockquote","key":"6h1ah"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Поскольку она рекурсивно вызывает саму себя, неразрешенные функции передаются в стек вызовов. Как только мы достигаем базового случая массива со всего 1 элементом, функция начинает разрешаться. В результате наши операции сравнения выглядят так:","type":"unstyled","key":"2omtn"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"2 больше 4? максимальное число 4.\n8 больше 4? максимальное число 8.\n3 больше 8? максимальное число 8.\n7 больше 8? максимальное число 8.\n5 больше 8? максимальное число 8.\n9 больше 8? максимальное число 9.\n1 больше 9? максимальное число 9.","type":"blockquote","key":"ceq5f"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Итак, по сути, мы проходим по массиву в обратном порядке, начиная с 2 последних чисел. Мы сравниваем эти 2 числа и оставляем наибольшее. Затем мы смещаемся на 1 элемент влево и сравниваем его с текущим максимальным числом.","type":"unstyled","key":"8iu22"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Таким образом мы продолжаем смещаться влево, пока не достигаем начала массива. В этот момент мы уже сравнили все числа, и у нас осталось наибольшее.","type":"unstyled","key":"5k51s"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Будет ли такой рекурсивный вариант лучше варианта с циклом? Опять же, вопрос субъективный. Но я думаю, что нет. Когнитивная сложность понимания работы этой рекурсивной функции выше, чем усилия, необходимые для понимания реализации этой функции с помощью цикла.","type":"unstyled","key":"bnp2q"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В данном случае рекурсивный вариант больше выглядит как более “умное” решение, но не более “понятное”.","type":"unstyled","key":"g7ld"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Осталось разобрать последний пример.","type":"unstyled","key":"96d9i"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Пример #5: поиск ключа, спрятанного в ящиках внутри ящиков","type":"header-three","key":"64mar"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Это будет самый сложный пример, но он продемонстрирует идеальный случай применения рекурсии. Представим, что у нас есть коробка. В этой коробке лежат несколько других коробок, внутри которых есть еще коробки и так далее. При этом некоторые коробки могут быть пусты. Нас же интересует та единственная, в которой лежит ключ.","type":"unstyled","key":"clrn8"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Итак, предположим, что:","type":"unstyled","key":"12drh"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"1-ая коробка (коробка A) содержит 3 других коробки (коробку B, коробку C и коробку D).","type":"unordered-list-item","key":"dcuke"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"коробка B пуста.","type":"unordered-list-item","key":"rf4v"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"коробка C содержит 2 коробки (коробку E и коробку F).","type":"unordered-list-item","key":"fnkd"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"коробка E содержит 1 коробку (коробку G).","type":"unordered-list-item","key":"ad5rj"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"коробка G содержит ключ (Ура!).","type":"unordered-list-item","key":"fteqe"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"коробка F пуста.","type":"unordered-list-item","key":"elpef"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"коробка D содержит 1 коробку (коробку H).","type":"unordered-list-item","key":"cg95v"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"коробка H пуста.","type":"unordered-list-item","key":"8nh5v"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Как написать функцию, которая будет обыскивать коробки, пока не найдет ключ?","type":"unstyled","key":"7olmi"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Для этого можно использовать цикл while:","type":"unstyled","key":"v6ev"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"export const findKeyInBox = (box) => {\n const pile = [];\n pile.push(box);\n\n while (pile.length > 0) {\n const currentBox = pile.pop();\n console.log(`Looking in Box ${currentBox.id}`);\n\n for (let i = 0; i < currentBox.contents.length; i++) {\n if (currentBox.contents[i].type === 'key') {\n console.log(`Found the key in Box ${currentBox.id}!`);\n return currentBox.id;\n }\n\n if (currentBox.contents[i].type === 'box') {\n console.log(\n `Found Box ${currentBox.contents[i].id} in Box ${currentBox.id}`\n );\n pile.push(currentBox.contents[i]);\n }\n }\n }\n};","type":"blockquote","key":"fv1ff"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Мы начинаем с пустой кучи (pile, массива, который можно использовать в качестве стека) и затем добавляем в эту кучу первую коробку.","type":"unstyled","key":"7jbkh"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Далее, пока куча не опустеет, мы берем из нее коробку и заглядываем внутрь.","type":"unstyled","key":"4mord"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Каждый обнаруженный в коробке элемент может оказаться либо ключом, либо другой коробкой. Если мы находим ключ, то можно завершать. Если же перед нами оказывается коробка, то мы добавляем ее в кучу.","type":"unstyled","key":"cdhu"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Этот цикл повторяется до тех пор, пока не иссякнут коробки, или же мы не найдем ключ.","type":"unstyled","key":"8lehf"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Теперь интересно взглянуть на рекурсивное решение задачи. Оно у нас будет таким:","type":"unstyled","key":"42vdj"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"export const findKeyInBox = (box) => {\n console.log(`Looking in Box ${box.id}`);\n\n for (let i = 0; i < box.contents.length; i++) {\n if (box.contents[i].type === 'key') {\n console.log(`Found the key in Box ${box.id}!`);\n return box.id;\n }\n\n if (box.contents[i].type === 'box') {\n console.log(`Found Box ${box.contents[i].id} in Box ${box.id}`);\n const boxContainingKey = findKeyInBox(box.contents[i]);\n\n if (boxContainingKey) {\n return boxContainingKey;\n }\n }\n }\n};","type":"blockquote","key":"927op"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Обратите внимание на разницу между рекурсивным решением и решением с помощью цикла. В рекурсивном мы не отслеживаем кучу, а просто заглядываем в 1-ую коробку и, если других коробок там не находим, то рекурсивно вызываем для нее функцию findKeyInBox. При этом состояние за нас снова отслеживается в стеке вызовов.","type":"unstyled","key":"3febr"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Заключение","type":"header-three","key":"ac27g"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Итак, что же лучше: циклы или рекурсия? Как я и говорил, решать вам. В плане быстродействия между этими 2 подходами обычно значительной разницы нет, и нотация “О” большое для них будет одинаковой, поскольку в каждом случае выполняется одинаковое число операций.","type":"unstyled","key":"c17ce"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Единственное, что таким образом можно оптимизировать — это читаемость. Что для вас понятнее — рекурсивное решение или решение с циклом? А если подумать о следующем разработчике, который будет читать ваш код?","type":"unstyled","key":"71k46"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Если при этом дополнительно учесть, что читается код в 10 раз чаще, чем пишется, то оптимизировать его нужно именно под читаемость.","type":"unstyled","key":"3hgvb"},{"data":{},"depth":0,"entityRanges":[{"key":2,"length":21,"offset":99}],"inlineStyleRanges":[],"text":"Если захотите еще раз просмотреть примеры и заглянуть в тестовые кейсы, то все эти функции лежат в репозитории на GitHub.","type":"unstyled","key":"ovca"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Читайте также:","type":"unstyled","key":"ciig3"},{"data":{},"depth":0,"entityRanges":[{"key":3,"length":61,"offset":0}],"inlineStyleRanges":[],"text":"Будьте благодарны за массивы JavaScript: сравнение с языком C","type":"unordered-list-item","key":"87qf6"},{"data":{},"depth":0,"entityRanges":[{"key":4,"length":24,"offset":0}],"inlineStyleRanges":[],"text":"Введение в Web Share API","type":"unordered-list-item","key":"7p7o8"},{"data":{},"depth":0,"entityRanges":[{"key":5,"length":69,"offset":0}],"inlineStyleRanges":[],"text":"Как создать многопользовательский чат с помощью WebSocket за 10 минут","type":"unordered-list-item","key":"f0dd4"},{"data":{},"depth":0,"entityRanges":[{"key":6,"length":8,"offset":14},{"key":7,"length":2,"offset":24}],"inlineStyleRanges":[],"text":"Читайте нас в Telegram, VK","type":"unstyled","key":"2gvr5"},{"data":{},"depth":0,"entityRanges":[{"key":8,"length":13,"offset":15},{"key":9,"length":33,"offset":30}],"inlineStyleRanges":[{"length":14,"offset":0,"style":"ITALIC"}],"text":"Перевод статьи Tyler Hawkins: Recursion vs. Loops in JavaScript","type":"unstyled","key":"3ho15"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"marker","key":"jK1JEwDiaU5zJbEqbLRS"}],"entityMap":{"0":{"data":{"url":"https://nuancesprog.ru/p/16853/"},"mutability":"MUTABLE","type":"LINK"},"1":{"data":{"url":"https://aflink.ru/g/os57fawizi1470bcbdb40da0172cef90ccbaca92/?erid=LatgBV3Ep"},"mutability":"MUTABLE","type":"LINK"},"2":{"data":{"href":"https://github.com/thawkin3/recursion-vs-loops-js","url":"https://github.com/thawkin3/recursion-vs-loops-js"},"mutability":"MUTABLE","type":"LINK"},"3":{"data":{"href":"https://nuancesprog.ru/p/16812/","url":"https://nuancesprog.ru/p/16812/"},"mutability":"MUTABLE","type":"LINK"},"4":{"data":{"href":"https://nuancesprog.ru/p/4632/","url":"https://nuancesprog.ru/p/4632/"},"mutability":"MUTABLE","type":"LINK"},"5":{"data":{"href":"https://nuancesprog.ru/p/16849/","url":"https://nuancesprog.ru/p/16849/"},"mutability":"MUTABLE","type":"LINK"},"6":{"data":{"href":"https://t.me/nuancesprog","url":"https://t.me/nuancesprog"},"mutability":"MUTABLE","type":"LINK"},"7":{"data":{"href":"https://vk.com/nuancesprog","url":"https://vk.com/nuancesprog"},"mutability":"MUTABLE","type":"LINK"},"8":{"data":{"href":"https://thawkin3.medium.com/?source=post_page-----d588c5b0df31--------------------------------","url":"https://thawkin3.medium.com/?source=post_page-----d588c5b0df31--------------------------------"},"mutability":"MUTABLE","type":"LINK"},"9":{"data":{"href":"https://betterprogramming.pub/recursion-vs-loops-in-javascript-d588c5b0df31","url":"https://betterprogramming.pub/recursion-vs-loops-in-javascript-d588c5b0df31"},"mutability":"MUTABLE","type":"LINK"}}},"mentions":[]}