Что касается вашей ошибки NaN, вы пытались вызвать функцию многократного использования (функцию в БЛОКЕ № 2), не передавая ей никаких аргументов, поэтому она ничего не возвращает, что, очевидно, является Не число (NaN).

Блок №1 Функция:

Первая функция не является функцией многократного использования, что означает, что каждый раз, когда вам нужно вычислить какие-то новые значения, вам придется соответственно обновлять переменные integer1 и integer2 следующим образом:

function sum() {
  return (integer1 * integer2); 
}

var integer1 = 5;
var integer2 = 10;
console.info(sum());

var integer1 = 11;
var integer2 = 31;
console.info(sum());

Блок № 2 Функция:

Однако вторая функция - это функция многократного использования, которую можно вызывать снова и снова с разными аргументами, передаваемыми в функцию в виде таких параметров:

function sum(integer1, integer2) {
  return (integer1 * integer2); 
}

console.info(sum(5, 25));
console.info(sum(8, 32));
console.info(sum(1, 3));
console.info(sum(5, 9));

Аргументы удобны, потому что вы можете использовать одну и ту же функцию с любыми нужными вам значениями. В своем БЛОКЕ 2 вы забыли передать аргументы при вызове функции суммы.

alert(sum(integer1, integer2))

Поскольку вы не передали аргументы при вызове функции, они не были определены, и попытка умножить две неопределенные переменные привела к NaN.

Функция в блоке 2 использует переменные, которые ожидают передачи. В этом случае вы ничего не передали, поэтому integer1 и integer2 являются нулевыми ссылками / неопределенными.

Для блока 1 вы объявили глобальные переменные с целочисленными значениями, которые затем используются в функции.

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

function product(integer1, integer2) {
  returnValue = integer1 * integer2;
  return returnValue; 
}

alert(product(10, 20));

Ключ к пониманию того, как это работает, заключается в том, что product(10, 20) будет назначать переданные значения каждому параметру в следующем порядке:

var integer1 = 10;
var integer2 = 20;

Только представьте, что функция содержит две вышеупомянутые строки в самом верху.

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

то, что нам нужно, - это простое добавление функциональности.

блок 1

var integer1 = 10;
var integer2 = 20;

function sum () {
  sum = (integer1 + integer2);
  return sum; 
}

alert(sum());

для получения результата вам необходимо иметь integer1 и interger2 в теле, как у вас уже есть. поэтому логика вашей функции где-то зависит от других элементов. Это не очень хорошая практика, поскольку мы создаем функции для обработки определенной логики независимо от остального кода. Так что в рамках всего процесса выполнения мы можем вызывать эту функцию, и она всегда ведет себя одинаково.

блок 2

var integer1 = 10;
var integer2 = 20;

function sum (integer1, integer2) {
  sum = (integer1 + integer2);
  return sum; 
}

alert(sum(integer1, integer2));

Теперь в этом случае мы вызываем ту же функцию, но с параметрами. В этом сценарии сумматору необходимо добавить как минимум 2 значения. Таким образом, любой момент времени, когда мы вызываем эту функцию, дает нам результат суммы переданных аргументов. Таким образом, эта функция не зависит от var integer1 и var integer2, если мы передадим в эту функцию некоторые другие переменные, мы можем получить такое же поведение.

Теперь нам нужно иметь в виду, что когда мы вызываем функцию (как вы делаете в «alert(sum());»), нам нужно проверять, требует ли функция каких-либо параметров, если да, то мы должны передать их в качестве аргументов, например,

// define our adding function
function sum (a, b) {  // argument variables may have different variable names
  sum = (a + b);       // which only live within the function **scope**
  return sum;
}

//calling sum
sum(integer1, integer2); // we already declared these two variables integer1 & integer2

// calling sum with direct values
sum(5, 5);  // it returns 10

// now we have two new variables
var num1 = 50;
var num2 = 20;
sum(num1, num2);  // as we expect it returns 70

почему у тебя NaN

это языковая функция, поскольку вы используете Javascript, любая переменная, которая не определена, имеет значение undefined, вы можете сказать, что это свойство Javascript

NaN означает не число, когда мы выполняем операцию сложения, переменные аргумента внутри функции ожидают себя как переменную числового типа, но, следовательно, мы не передавали никаких параметров при вызове функции sum(), integer1 и integer2 имеют свойство undefined, поэтому вы в результате получил NaN.

как вы можете видеть, я передаю два целочисленных значения 5, 5 для вызова sum, в другом случае переменные целочисленного типа num1, num2 для вызова sum.

* Если вы внимательно посмотрите на последнюю строку, вы увидите, что вы вызвали alert (). Это предопределенная функция, которую мы получаем из коробки языка программирования javascript. Но чтобы предупредить, что он делает, нам нужно передать значение, и только тогда оно может отображать значение в поле предупреждения.

так что пока вы звоните alert(sum(integer1, integer2)); (исправленный код ваш) сначала он выполняет sum и возвращает из него значение, затем вызывает предупреждение, используя возвращаемое значение, и принимает его в качестве аргумента для вызова самого себя. После этого мы получаем окно с предупреждением с результатом сложения.

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