Ответ 1

Вы должны return значение. Вот вы:

function fact(x) {
   if(x==0) {
      return 1;
   }
   return x * fact(x-1);
}

function run(number) {
    alert(fact(parseInt(number, 10)));
}

и

<input type="button" value="Find factiorial" onclick="run(txt1.value)">

(Как заставить работу работать с отрицательными номерами, я оставляю для вас;) (но я все равно показывал это сообщение))

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

function fact(x) {
       if(x == 0) {
           return 1;
       }
       if(x < 0 ) {
           return undefined;
       }
       for(var i = x; --i; ) {
           x *= i;
       }
       return x;
}

Ответ 2

Использовать цикл его легко реализуемый

function fact(num)
{
    if(num<0)
     return "Undefined";
    var fact=1;
    for(var i=num;i>1;i--)
      fact*=i;
    return fact;
 }

<input type="button" value="Find factiorial" onclick="alert(fact(6))">

Ответ 3

function factorial(n) {
  return (n != 1) ? n * factorial(n - 1) : 1;
}

alert( factorial(5) );

Вы можете попробовать использовать метод рекурсии

Ответ 4

• Ваша функция ничего не возвращает.
• Что вы делаете, когда x равно 0?
• Незначительная точка - кроме alert, вы ничего не делаете с возвращаемым значением.

Попробуйте это вместо этого, если вы нажмете над текстом:

if(x==0) return 1;
      return x * fact(x-1);

Рабочий пример: http://jsbin.com/apuka3/2

Ответ 5

В первую очередь вам нужно иметь return.;)

Ответ 6

Я написал это, и он работает.

  var d = 1;
  for (num; num > 1; num--) {
    d *= num;
  }
  return d;

Ответ 7

Здесь короткая рекурсивная версия:

function doFact(n) {
  return +!(+(n)) || doFact(n - 1) * n;
}

function factorialFromInput() {
  var theInputVal = document.getElementsByTagName("input")[0].value;
  var theContainer = document.getElementById("resultContainer");
  theContainer.innerHTML = "" + doFact(Math.abs(theInputVal));
}

.wrapper>* {
  line-height: 2em;
  width: 30%;
}
#resultContainer {
  border: outset grey;
  min-height: 1.1em;
  padding-left: 0.3em;
  background-color: #eff0f1;
  overflow: scroll;
}

<div class="wrapper">
  <input type="text" id="valEntered">
  <br>
  <button onclick="factorialFromInput();">Calculate Factorial</button>
  <br>
  <div id="resultContainer"></div>
</div>

Ответ 8

function fact(n) {
  if (n > 1) {
    return n * fact(n-1);
  } else {
    return 1;
  }
}
console.log(fact(5));

Используя троичный оператор, мы заменяем приведенный выше код одной строкой кода, как показано ниже

function fact(n) {
      return (n != 1) ? n * fact(n - 1) : 1;
 }
console.log(fact(5));

Ответ 9

Это самый простой способ и последний JS (ES6)

factorial = n =>  n - 1 > 0 ? n * factorial(n - 1) : n;

//output
console.log(factorial(5));

Здесь я использовал функцию стрелки ES6. Для лучшего понимания смотрите функцию стрелки.

Ответ 10

Важной частью функции является эта строка:

 x = x * fact(x-1);

но функция fact не возвращает значение, поэтому это то же самое, что и x * undefined. Попробуйте добавить return x; в нижнюю часть вашей функции.

Ответ 11

1) Когда функция X = 0 должна возвращать 1; 2) Добавлено return;

 function fact(num)
 {
    var x=parseInt(num);
    //alert(x+1);
    if(x>0)
        x=x* fact(x-1);
    else
        x=1;
    return x;
 }

Использование

<input type="button" value="Find factiorial" onclick="alert(run(fact.value));">

Ответ 12

Небольшое редактирование кода Антона:

function fact(x) {
   if(x>0)
       return x* fact(x-1);
   if(x===0)
       return 1;
   return null;

}

(факториал отрицательного не существует, но факториал 0 равен 1, в этом случае, если число меньше 0, функция вернет null)

Ответ 13

Как насчет:

function fact(n) {
  n = Math.round(n);
  if (n < 2) {
    return 1;
  }
  else {
    return n * fact(n - 1);
  }
}

?

Ответ 14

Мое предложение:

function fact(x) {
    if (x<0) {
        return Infinity
    };
    var _= 1
    for ($=1;$<=x;++$) {
        _*=$
    };
    return _
};

Он просто возвращает факториал любого "х".

Ответ 15

Вот один, который я сделал, используя цикл while:

function factorialize(num) 
{
  i = 1;
  b = 1;
  while (i < num) {
    b = b + (b * i);
    i = i + 1;
    }
return b;
}

Ответ 16

 <script src="jquery-3.1.0.js"></script>
<script>
    $(function () {
        var target = 5;
        var factorial = 1;
        for (var i = 1; i <= target; i++) {
            factorial *= i;
        }
        alert(factorial);
       });
</script>

вы можете установить любое значение в цель, и эта логика будет вычислять Factorial.

Спасибо...:)

Ответ 17

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

 var mem = [];

 function fact(num)
 {
    var x = parseInt(num);

    if (x == 0 || x == 1) return 1;

    mem[x] = x * fact(x-1);

    return mem[x];
 }

Ответ 18

Рекурсия в JS открыта для ошибки, а также очень медленная. Лучше использовать петлю другими способами. Мой вклад в факторный код был бы одним лайнером;

var fact = n => Array(n).fill().reduce((v,_,i) => (i+1) * v || 2);
console.log(fact(5));

Ответ 19

очень простая форма:

function fact() {
    var x = document.getElementById("txtf").value;
    var f=1;
    for (var i=1; i <= x ; i++){
        f = f*i;
    }
    document.getElementById('showR').innerHTML= f;
}


 <input type="text" id="txtf" value="3">
   <input type="button" id="btnf" value="click for calculate" onclick="fact()">
   <p id="showR">/Factoriel/</p>

Ответ 20

    function factorial(num) {

    var result = 1;

    for (var i = 1; i <= num; i++) {
        result = result * i;

    }

    return result;
}
//call function e.g factorial(4).. 1*2*3*4 it will evaluate in ascending order

Ответ 21

var factorialNumber , factorial=1;
factorialNumber=prompt("Factorial Number" , "write Factorial Number");
for(var i = 1; i<= factorialNumber;i++){
    factorial *= i;
}
alert(factorial);

В приведенном выше коде сначала определяются две переменные, factorialNumber и factorial. factorial инициализируется 1. factorialNumber получит результат prompt (ожидается число), а затем, используя цикл, на каждом шаге факториал умножается на индекс шага, который представлен на i. При успешном вычислении мы показываем результат с помощью alert.

Ответ 22

С циклом Do это довольно просто.

    <table>
    <tr>
        <th>Amount of integers</th>
        <th>Answer</th>
    </tr>
    <tr>
        <th><input id="int" type="number"/></th>
        <th><input id="answer" type="number"/></th>
    </tr>
</table>
<button onclick="calculate()">calculate</button>
<script>
    function calculate() {
        var input = document.getElementById("int").value;
        var int = 1;

        do {
            var product = int *= input;
            input--;
        } while (input > 0);
        answer.value = product;
    }
</script>

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

Входная переменная - это значение, введенное пользователем. Вы также имеете переменную int в качестве заполнителя.

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

Затем в конце он отправляет ответ тегу id ответа в таблице.

Ответ 23

function factorial(num){
    if(num<1||typeof num!=='number'){
    return undefined
  }
  if(num===1){
    return num
  }
    return num*factorial(num-1)
}
console.log(factorial(3))

https://jsfiddle.net/mohittadhiyal/6w64x0sL/10/

Ответ 24

function factorial (n) {
  if (n > 1) {
    return n * factorial(n-1);
  }
  return 1;
}
console.log("recursive way => ",factorial(5)); 

Ответ 25

Я видел рекурсивный подход, используемый во многих местах (Eloquent JavaScript и т.д.). Здесь функция вызывается рекурсивно, пока не достигнет 0, что не должно быть. Мы должны вызывать функцию только до тех пор, пока она не станет> = 2, потому что последнее число, на которое нам нужно умножить, равно 1.

Это очень незначительное изменение, и, вероятно, не имеет значения. Любопытно узнать, что другие люди думают об этом. Предполагая, что это действительное положительное целое число.

/**
 * Popular approach - the recursive function is called till x is 0
 * 
 * @param x
 */
function popularFactorial(x) {
    console.log(x)
    if(x === 0) {
        return 1
    } else {
        return x * popularFactorial(x - 1)
    }
}
var result = popularFactorial(8)
console.log(result)

/**
 * Using this approach, the recursive function is called one less time
 * i.e till x is 1
 * 
 * @param x 
 */
function factorial(x) {
    console.log(x)
    if(x === 0) {
      return 1
    } else if(x >= 2) {
        return x * factorial(x - 1)
    }
    return x
}
var result = factorial(8)
console.log(result)