StepanMogilyov

1.  function getFactorial(num) {
2.    console.log(num)
3.    if (num <= 1) {
4.      return
5.    } else {
6.      getFactorial(num - 1)
7.      console.log(num)
8.      return
9.    }
10. }
11.
12. getFactorial(4)

Что такое стек знаете? В рекурсии вызовы будут в виде стека, последним пришел - первым вышел.

1. Вызов getFactorial(4), отработает строка 2, покажет '4'
2. На строке 6 вызов getFactorial(3), отработает строка 2, покажет '3'
3. На строке 6 вызов getFactorial(2), отработает строка 2, покажет '2'
4. На строке 6 вызов getFactorial(1), отработает строка 2, покажет '1'
5. Выход из функции getFactorial(1), отработает строка 4
6. Продолжится выполнение функции getFactorial(2), отработает строка 7, покажет '2'
7. Выход из функции getFactorial(2), отработает строка 8
8. Продолжится выполнение функции getFactorial(3), отработает строка 7, покажет '3'
9. Выход из функции getFactorial(3), отработает строка 8
10. Продолжится выполнение функции getFactorial(4), отработает строка 7, покажет '4'
11. Выход из функции getFactorial(4), отработает строка 8

Так. В первую очередь, изучайте, что такое стек вызовов (call stack).
Call stack можно рассматривать как коробку книг, куда можно положить сколько угодно книжек, но читать можно книгу, которая лежит поверх всех книг. Как закончим читать, можем достать уже следующую и так до конца. Работает он по принципу LIFO (Last In First Out, последним пришел - первым ушел).
Когда функция вызывается, она создает запись в стеке вызовов, в которой лежат её аргументы и локальные переменные. Эту запись называют stack frame (стековый кадр). Когда функция вызывает другую функцию, в call stack вставляется новый кадр, уже поверх старого. Как только эта функция заканчивает свою работу, запись из стека удаляется и следующая функция продолжает свою работу и в конце её фрейм тоже удаляется.
В общем, эту тему можно очень глубоко изучать в интернете.

У вас функция работает так:
Изначально вы выводите число в консоль, потом рекурсивно вызываете эту функцию в блоке else с аргументом num -1, дальше снова выводите это число в консоль. То есть, вы выводите каждое число по два раза, но поскольку рекурсия забивает call stack, у вас получается такой "странный" вывод. Уберите console.log из else и картинка поменяется.

Нельзя писать arg1 || arg2 != '', подобно кальке с русского языка.
В программировании всё последовательно:

• Либо сначала считает !=, а этот операнд имеет приоритет, поэтому если без скобок, то это эквивалентно такому: arg1 || (arg2 != ''). В этом случае мы проверяем, что arg2 не является пустой строкой. При этом он может быть символом или числом, например. ИЛИ arg1 является истинным.
  
• Либо сначала считает ||, если иначе расставить скобки: (arg1 || arg2) != ''. В этом случае тоже ерунда какая-то. Мы проверяем истинность хотя бы одного аргумента, а потом зачем-то результат операции сравниваем с пустой строкой.
  

Чтобы составить условие правильно, его нужно структурировать для понимания, то есть составление как бы разбить на этапы.

1. Сначала нужно понять, как сформулировать простое условие "не является буквой". Условно запишем по-русски.
   
2. Далее составляем следующее более сложное условие из кирпичиков, полученных на предыдущем этапе: (arg1 является буквой) && (arg2 является буквой). То есть для каждого аргумента повторяем выражение полностью. Если сомневаетесь в приоритетах вычислений, можно ещё и скобки расставить.
   

Но вернёмся к началу. Вроде бы простое условие "arg является буковой", но готовой функции у нас нет. И чтобы проверить это утверждение, нужно проверить ещё более простые:
1) что arg является строкой в принципе (не числом, не булевой переменной, не всякими там null и пр.)
2) что эта строка имеет длину 1. Ведь если больше 1, то это уже не просто буква. А если меньше, то есть 0, то это тем более не буква.
3) что оставшийся символ действительно является буквой. Не прибегая к регулярным выражениям (что для вас будет явно сложно), я бы схитрил так:
arg==arg.toLowerCase() || arg==arg.toUpperCase()
Обратите внимание на порядок операций. Сначала считаются сравнения, а потом они складываются через логическую операцию ИЛИ. То есть, если по-русски, мы записали, что символ равен самому себе в верхнем регистре, либо он равен самому себе в нижнем регистре. Это и будет означать, что это буква.

Если же опустить предыдущие проверки, и допустить, например, что это длинная строка, например "абвгд", то у нас последнее утверждение окажется ошибочно верным, так что сначала нужно исключить всё лишнее.

Ещё один совет: не обязательно городить бесконечный if else. Конечно, так тоже можно, но получается более громоздко и менее очевидно. Проще писать серию return'ов. Это всегда проще, а в вашем примере сам бог велел так делать. Пример:

if (typeof arg1 != "string") return -1;
if (arg1.length != 1) return -1;
//и т.д.

Здесь мы первой проверкой исключаем возможность, что это не строка. То есть если это не строка, то дальше выполнение функции не происходит, и мы сразу выходим. Поэтому во второй проверке уже можно быть точно уверенным, что arg1 - это строка, и исходить из этого. И весь код ниже тоже может рассчитывать, что arg1 - это строка длиной 1 символ, без вариантов.

Три подсказки.

Проверить, что аргумент является строкой:

typeof arg === 'string'
// ещё можно длину проверить, а то, вдруг длинное пришлют
arg.length === 1

Проверить, что это буква и есть пара в другом регистре:

arg.toLowerCase() !== arg.toUpperCase()
// строка перевелась в разные кейсы

В каком кейсе изначально была буква:

arg.toUpperCase() === arg // значит, буква в верхнем регистре

Из этих кирпичиков остаётся сложить домик. И чтоб не рухнул )

Примерно так:

const removeDuplicates = (arr) => 
  arr.reduce(
    (acc, cur) => (acc.includes(cur) ? acc : (acc.push(cur), acc)),
    [],
  );

console.log(removeDuplicates([1,2,3,4,5,1,1,2,2,3,3,65,9,65,1,5,65, 117, 117, 118,118, 12333, 12333]));
// Array(10) [ 1, 2, 3, 4, 5, 65, 9, 117, 118, 12333 ]