需要在 JavaScript 中生成素数答案

【问题标题】：Need to generate prime numbers in JavaScript需要在 JavaScript 中生成素数
【发布时间】：2014-02-23 08:36:51
【问题描述】：

我正在编写一个 JavaScript 来生成从 2 到 100 的素数。但是它不起作用并且无法弄清楚。

请你帮帮我好吗？

var array = new Array(100);

for (var i=2 ; i<=array.length-1; i++) {
    if((i%2===0) || (i%3===0))
        continue;
    document.writeln(i+",");
}

我修改了我的答案，但现在它不打印 2 和 3；我怎样才能包括 2 和 3... 结果是：

5, 7, 11, 13, 17, 19, 23, 25, 29, 31, 35, 37, 41, 43, 47, 49, 53, 55, 59, 61, 65, 67, 71, 73, 77, 79, 83, 85, 89, 91, 95, 97

【问题讨论】：

请提供比“它不起作用”更好的描述。您希望代码做什么以及它实际做什么？
1) 您的代码仅检查该数字是否可被 2 或 3 整除，2) 在找到第一个不是“素数”的数字后返回 false。 3) 你永远不会向array 添加新的质数 4) 即使你确实向array 添加了质数，你将prime 增加array[i] 这将跳过许多质数。
为什么“i++”而不是“i+=2”，偶数总是素数？您还只需检查要检查的素数的一半...
@p.s.w.g 谢谢你，我会试试的，会告诉你的:)
@dandavis 2 是唯一的偶数。通常它被硬编码为素数，并且代码假定所有其他都是奇数。

标签： javascript jscript

【解决方案1】：

function isPrime(num) {
    for ( var i = 2; i < num; i++ ) {
        if ( num % i === 0 ) {
            return false;
        }
    }
    return true;
}

function display(n) {
    var arr = [2];
    for ( var i = 3; i < n; i+=2 ) {
        if ( isPrime(i) ) {
            arr.push(i);
        }
    }
    console.log(arr); // use arr result on your own
}

display(100);

注意： 在 display 函数中指定 n 参数并获取 2 到 n 的素数 ...

查看JSFiddle

更新：请注意，上面的脚本是正确的，我将离开它，但添加了相同的功能和一个功能：

function prime(n,flag) {
    ( typeof flag === "undefined" || flag === false ) ? flag = false : flag = true;

    function isPrime(num) {
        if ( num === 0 || num === 1 ) {
            return false;
        }
        for ( var i = 2; i < num; i++ ) {
            if ( num % i === 0 ) {
                return false;
            }
        }
        return true;
    }

    if ( flag ) {
        var arr = [2];
        for ( var i = 3; i <= n; i+=2 ) {
            if ( isPrime(i) ) {
                arr.push(i);
            }
        }
        return arr;
    } else {
        return isPrime(n);
    }
}

解释：prime函数需要两个参数，第一个是必需的，第二个是可选的。如果只指定第一个参数，函数将根据是否属于素数返回true 或false。如果第二个参数指定为true（或除undefined 和false 之外的任何其他类型）函数将返回array 的质数从2 到n。例如：

console.log(prime(2)); // returns true ( 2 is prime )
console.log(prime(8)); // returns false ( 8 isn't prime )

console.log(prime(100,true)); // returns [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

【讨论】：

您的解决方案相当低效。显示循环最好从 3 开始并以 2 递增，isPrime 只需要除以素数。
@Christoph 我测试了讨论的解决方案算法之间的经过时间，当N 为100000 时，差异发生在大约 100 毫秒左右
您只需要检查到num的平方根。
我试图了解函数 isPrime(num) 的工作原理。我能理解的是function display(n) 产生这个数组 [2,3,5,7,9] 等等奇数。接下来，通过function isPrime(num) 过滤这个数组。从var i = 2; i < num; i++ 开始并使用这个等式num % i === 0，它应该是这样的，3(num) % 2(i) 有余数，5(num) % 3(i) 有余数，7(num) % 4( i) 有余数，但下一个 9(num) % 5(i) 也有余数，但 9 不是质数。应该发生什么？
@KristinaBressler 如果您将 n 数指定为不带标志的参数，则标志被认为是假，并且函数返回指定的整数是否为质数。另一方面，如果 flag 设置为 true，则函数返回质数，最多为指定的 n 个整数。 isPrime 函数内部通过检查提醒来判断 number 是否为素数，number 是否可以除以指定 n 以内的任意数，并据此返回 boolean。是的 9 不是主要的 nuber。如果你尝试，函数会返回 false。

【解决方案2】：

var enterNumber = prompt("Enter number: ");

for(var i=2; i<=enterNumber ;i++){

        var isPrime = true;

        for(var j=2; j<i; j++){
            if(i%j === 0 && i !== j){
                isPrime = false;
            }
        }
        if(isPrime === true){
            console.log(i);
        }
    }

【讨论】：

【解决方案3】：

您的原始代码有许多缺陷。要实现Sieve of Eratosthenes，您需要将找到的每个素数添加到数组中，然后针对您目前找到的每个素数测试下一个候选素数。如果候选人不能被数组中的任何素数整除，则它是素数，您可以将其添加到素数数组中。

这是一个工作版本 (Demonstration)：

function start() {    
    var array = [2, 3];
    for (var i = 5; i <= 100; i += 2) {
        if (array.every(function(p) { return i % p; })) {
            array.push(i);
        }
    }
    var result = array.join(",");
    document.getElementById("output").innerHTML = result;
}
start();

请注意，这取决于 ECMAScript 5 中引入的 Array.prototype.every。

【讨论】：

严格来说，这不是 SoE。您多次测试每个数字，这违背了 SoE 的目的。看看我的答案的第二个解决方案，即 SoE。

【解决方案4】：

使用 javascript 生成器的版本：

function* take(length, iterable) {
  for (let x of iterable) {
    if (length <= 0) return;
    length--;
    yield x;
  }
}

function* primes() {
  let n = 2;

  while (true) {
    if (isPrime(n)) yield n;
    n++;
  }

  function isPrime(num) {
    for (var i = 2; i <= Math.sqrt(num); i++) {
      if (num % i === 0) {
        return false;
      }
    }
    return true;
  }
}

console.log([...take(4, primes())]); //[ 2, 3, 5, 7 ]

【讨论】：

【解决方案5】：

你有很多方法可以做到这一点。

您基本上是正确的，但是，您必须检查每个数字是否可以被您迄今为止确定的每个素数整除：

var primes = [2],isPrime;

for (var i=3;i<100;i+=2){
    isPrime = true;
    // test the number you are examaning against
    // all the primes you found so far
    for (var j = 0;j<primes.length;j++){
        if (i%primes[j]==0){
            isPrime=false;
            break;
        }
    }
    if(isPrime){primes.push(i)}
}
console.log(primes);

See the result here

或者您可以使用Sieve of Eratosthenes 对所有数字进行排序以避免重复测试。

SoE 的真正实现：

// initialize the array first
var numbers = [], primes = [], maxNumber = 100;

for(var i = 2;i<=maxNumber;i++){
 numbers.push(i);   
}

while(numbers.length){
    primes.push(numbers.shift());
    numbers = numbers.filter(
        function(i){return i%primes[primes.length-1]!=0}
    );
}

console.log(primes);

Demo

【讨论】：

【解决方案6】：

这可能是一种有效的方法：

function calcPrimes(max){
    var primes = [];
    for(var i=2; i<=max; i++){
        var isPrime = true; 
        for(var j=0; j<primes.length; j++){
            var p = primes[j];
            if( i % p === 0){
                //it is divisible by another prime, so it's not prime
                isPrime=false;
                break;
            }
            //you don't need to check primes bigger than sqrt(i)
            if(p*p > i)
                break;
         }
        if(isPrime)
            primes.push(i);
    }
    console.log(JSON.stringify(primes))
    console.log(primes.length)
}
calcPrimes(100);

【讨论】：

【解决方案7】：

这是一个如何使用 Eratosththenes 筛的变体生成无限数量的素数的工作示例。它是一个真正的 SoE，并且不会执行试除法来确定一个数是否为素数。它可能看起来有点奇怪，但这是因为它被设计为在没有任何上限的情况下工作。

<input type=button value="Start" onClick="do_cancel(); do_once()">
<input type=button value="Stop" onClick="do_cancel()">
<table id="mytable"></table>

<script>
'use strict';
(function () {
    var ptable = document.getElementById("mytable");
    var prow = [2, 3];
    function insertPrimeIntoTable(prime) {
        prow.push(prime);
        if( prow.length < 10 ) return false;
        var tr = document.createElement('tr');
        for( var i = 0; i < prow.length; ++i ) {
            var cell = document.createElement('td');
            cell.appendChild( document.createTextNode( prow[i] ) );
            tr.appendChild( cell );
        }
        ptable.appendChild( tr );
        prow = [];
        return true;
    };

    var factors = [];
    function insertPrimeIntoSieve( factor ) {
        var where = factor;
        while( factors[where] )
            where += factor;
        /* while( factors.length < where ) factors.push(0); */
        factors[ where ] = factor;
    }

    var primes = [];
    var a_prime = 3, a_squared_prime = 9, maybe_prime = 3;
    var canceller;
    function do_once() {
        var factor = factors[0];
        maybe_prime += 2;
        if( factor ) {
            //if( 0 != (maybe_prime % factor) )
            //  throw "Unexpected remainder.";
            insertPrimeIntoSieve( factor );
        } else if( maybe_prime < a_squared_prime ) {
            insertPrimeIntoTable( maybe_prime );
            primes.push( maybe_prime );
        } else if( maybe_prime == a_squared_prime ) {
            insertPrimeIntoSieve( a_prime );
            a_prime = primes.shift();
            a_squared_prime = a_prime * a_prime;
        } else {
            throw "Critical math failure:  Programmer or compiler is innumerate.";
        }
        factors.shift();
        canceller = window.setTimeout( do_once, 5 );
    };
    function do_cancel() {
        if( canceller ) window.clearTimeout( canceller );
        canceller = null;
    }
    window.do_once = do_once;
    window.do_cancel = do_cancel;
})();
</script>

【讨论】：

【解决方案8】：

这是一个简单的函数式答案：

const prime = to => [...Array(to-1).keys()].map(i=>i+2).filter(n =>
  [...Array(n-2).keys()].map(i=>i+2).reduce((acc,x)=> acc && n % x !== 0, true)
)

这将返回一个包含所有素数的数组。

【讨论】：

【解决方案9】：

我们可以只用一个循环找到最多 n 的质数，我也将循环增加 +2：

function primeNumber(n) {
    let arr = [2];
    for (let i = 3; i <= n; i += 2)
        if (!((i % 3 == 0 && i > 3) || (i % 5 == 0 && i > 5) || (i % 7 == 0 && i > 7) || (i % 9 == 0 && i > 9))) {
            arr.push(i);
        }
    return arr;
}
primeNumber(100);
// output: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

时间复杂度为 o(n/2);

【讨论】：

【解决方案10】：

function isPrime(num) {
    if (num % 2 == 0) {
        return false;
    }

    let n = Math.sqrt(num);

    for ( var i = 3; i <= n; i += 2 ) {
        if ( num % i === 0 ) {
            return false;
        }
    }

    return true;
}

function print(n) {
    var arr = [2];
    for ( var i = 3; i < n; i+=2 ) {
        if ( isPrime(i) ) {
            arr.push(i);
        }
    }
    console.log(arr);
}

print(100);

【讨论】：

【解决方案11】：

Please try this,
var a = [...Array(100).keys()];
var primeNumbers = a.map(v => { 
    if (v % 2 === 0 || v % 3 === 0) { 
      if (v === 2 || v === 3) {
       return v;
      } else {
       return;
      } 
    } else {
      return v;
    }
});

primeNumbers.filter(val => val);

you will get 1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 25, 29, 31, 35, 37, 41, 43, 47, 49, 53, 55, 59, 61, 65, 67, 71, 73, 77, 79, 83, 85, 89, 91, 95, 97

【讨论】：

【解决方案12】：

我知道这个问题是在 2014 年提出的，但如果 OP 或任何想知道如何使用 Javascript 生成小素数的人，我已经在 https://github.com/HMaxF/generate-small-prime-number 中分享了小 JS 代码。

在我的 macbook pro 中，我可以在大约 25 秒内生成从 2 到 1 亿的所有素数，但你的机器结果会有所不同。

【讨论】：

【解决方案13】：

我同意 p.s.w.g。您的原始代码有许多缺陷。

var prime = [2,3,5,7];

for(var x = 0; x < 100; x++){
    var isPrime = prime.map(n => x%n > 0).filter(t => !t).length <= 0;
    if(isPrime || prime.includes(x)){
        console.log(x);
   }
}

【讨论】：

【解决方案14】：

function printPrimes(num) {
	let sum = []
  for(let i = 2; i<=num; i++) {
		if(check(i)) {
			sum.push(i)
		}
	}
	return sum
}
function check(num) {     // function to check number is prime or not
	if(num <= 1 || typeof num !== 'number') {
		return false
	}else if(num ===2) {
		return true
	}else if (num%2 === 0) {
		return false
	}
	for(let i=3; i*i <= num;i +=2) {
		if(num%i === 0) {
			return false
		}
	}
   return true
}	
console.log(printPrimes(100))

【讨论】：

请为您的答案添加一些解释。它将帮助其他人更好地理解它。

【解决方案15】：

只需将此 Java 脚本用于从 2 到所需数字的素数：

function primeFactorsTo(num)
{
    var store  = [], i, j, primes = [];
    for (i = 2; i <= num; ++i) 
    {
        if (!store [i]) 
          {
            primes.push(i);
            for (j = i << 1; j <= num; j += i) 
            {
                store[j] = true;
            }
        }
    }
    return primes;
}

console.log(primeFactorsTo(200));

【讨论】：

【解决方案16】：

I’ve Made the easiest Algorithm to solve this Problem

Step 1 –  Create a function to check a number is prime or not  (PrimeFilter) .

Step 2 – Create another function to print prime numbers smaller than given  number ,
               inside it declare an empty array .
Step 3 – Loop from 2 ( first prime number ) to the given number , and pass every loop value
              to the function PrimeFilter ( It will check every loop value if its prime or not ) .
Step 4 – If its a prime add it to the empty array .   Thats it :)


    function PrimeFilter(num){
         if(num===0){
           return false;
        }
        else if(num===1){
            return false;
        }

        else if(num===2){
            return true;
        }

        else {

            for(var i=2; i<num; i++){
                if(num%i===0){
                    return false;
                }
            }
            return true;
         }
     }

     function UptoPrime(number){
        var List =[];
         for(var i=2; i<=number; i++){
            if(PrimeFilter(i)){ 
                List.push(i);
            }
         }
         console.log(List.join(' '));
    }

【讨论】：

【解决方案17】：

参考这个answer，它检查素数并在给定范围内打印所需的素数

const isPrime = num => {
  for(let i = 2; i < num; i++)
    if(num % i === 0) return false;
  return num > 1;
}

primes = [] ;

for(let i = 2; i < max ; i ++) {
if(isPrime(i)) {
   primes.push(i)
 }
}

console.log(primes);

【讨论】：

【解决方案18】：

不久前我想出了一个带有生成器 fn 的 typescript 类，认为它可能有用。

export default class PrimeNumbers {
_number: number
_primes: Array<Buffer> = []

constructor(_number: number) {
    this._number = _number
    var gen = this.generator();
    var curr = gen.next();
    
    while (!curr.done) {
      if(curr.value)
        this._primes.push(Buffer.from(curr.value.toString()))
      curr = gen.next();
    }
}

getPrimes() { 
  return  this._primes 
}

*generator(): IterableIterator<number> {

 /**
 * An integer is prime if it is not divisible by any prime less than or equal to its square root
 **/
  var i = 2;
    if(this._number >= 2 ) {
    
    function isPrime(val: number) {
      for (var i = 2; i <= Math.sqrt(val); i++) {
        if (0 === val % i ) {
          return false;
        }
      }
      return true;
    }

    while(i < this._number) { 
      yield ( isPrime(i))? i: 0 ;
      i++;
    }
    return true;
  }
    return false     
 }



}

一个简单的调用就会得到所有这些素数，

var primeNumbers = new PrimeNumbers(1000)
    console.log(primeNumbers.getPrimes())

【讨论】：

【解决方案19】：

prime-lib 有一个优化良好的Sieve of Eratosthenes 解决方案：

const {generatePrimes, stopOnValue} = require('prime-lib');

const i = generatePrimes(); // create infinite prime iterator 
const s = stopOnValue(i, 100); // stop-iterator after reaching 100

const values = [...s]; // 2, 3, 5, ..., 83, 89, 97

附：我是prime-lib的作者。

【讨论】：

【解决方案20】：

这里已经有很多答案了，但我只想指出两种优化解决方案的方法。

不要一直循环到 n，一旦你达到平方根，它上面的所有数字都不再有效。

...
for (let c = 2; c <= Math.sqrt(n); c++) // use square root as upper limit

所有素数必须是 6n +- 1 的形式，因此非素数可以立即无效而无需任何循环。您只需要检查 6n +- 1 个素数。这里的例外只有 2 和 3。

if ((n - 1) % 6 === 0 || (n + 1) % 6 === 0)
  // test for prime
else
  // not prime

例子：

5 = 6 - 1
7 = 6 + 1
29 = 6(5) - 1
31 = 6(5) + 1

【讨论】：

【解决方案21】：

最近正在使用质数并登陆此页面。这是我使用 Sieve of Eratosthenes 算法和 6k ± 1 优化并忽略所有偶数和除数 5 的工作解决方案。

将代码复制并粘贴为 html。在10 seconds 中打印第一个1,000,000 素数。

<!DOCTYPE html>
<HTML>
<HEAD>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/bulma/0.7.5/css/bulma.min.css">
<script defer src="https://use.fontawesome.com/releases/v5.3.1/js/all.js"></script>
<BODY>
<SCRIPT type="text/javascript">
// The largest integer Java natively supports is 2^53-1, so these
// routines are designed to work for *positive* integers up to that.

// Currently the function check does the idiot proof to see only positive
// integers (not too large) are passed to the other routines.

 
// trial_divide(N,max) uses trial division to seek the smallest
// prime divisor of N, returns 0 if none found.


function trial_divide(N,max) {
  // Trial divides the positive integer N by the primes from 2 to max
  // Returns the first prime divisor found, or 0 if none found
  // Note: if N < max^2 is a prime, then N will be returned. 
  if (N%2 == 0) return 2;
  if (N%3 == 0) return 3;
  // No need to go past the square root of our number
  var Stop = Math.min(Math.sqrt(N),max);
  // Okay, lets "wheel factor" alternately adding 2 and 4
  var di=2;
  for(i=5; i<=Stop; i+=di, di=6-di) {
    if (N%i == 0) return i;
  };
  if (N >= max*max) return 0; 
  return N;
}


// modmult(a,b,N) finds a*b (mod N) where a, b, and N can be 
// up to (2^53-1)/2.  Might up this to 2^53-1 eventually...

  function modadd(a,b,N) {
  // When the integers a, b satisfy a+b > 2^53-1, then (a+b)%N is wrong
  // so we add this routine to allow us to reach a, b = 2^53-1.
    if (a+b > 9007199254740991) {
      // Could reduce a and b (mod N) here, but assuming that has already been done
      // won't hurt if not... subtract 2^52 from one, 2^52-1 from the other and the
      // add it back modulo N (MaxInt+1)  
      var t = ( (a-4503599627370496) + (b-4503599627370495) )%N;
      return ( t + (9007199254740991 % N) );
    }
    // Usual case: a + b is not too large:
    return ( (a+b)%N );
  }

function modmult(a,b,N) {
  if (a > N) a = a%N;
  if (b > N) b = b%N;
  if (a*b <= 9007199254740991) {
    return ((a*b)%N);
  } else {
    if (b > a) return modmult(b,a,N);

    // Right to left binary multiplication
    var t = 0;
    var f = a;
    while (b > 1) {
      if ((b & 1) == 1) t = modadd(t,f,N);
      b = Math.floor(b/2);
      f = modadd(f,f,N);
    };
    t = modadd(t,f,N);
    return t;
  }
}

// modpow(a,exp,N) finds a^exp (mod N) where a, b, and N are 
// limited by modmult

function modpow(a,exp,N) {
  if (exp == 0) return 1;

  // Right to left binary exponentiation
  var t = 1;
  var f = a;
  while (exp > 1) {
    if ((exp & 1) == 1) {  // if exponent is odd
      t = modmult(t,f,N);
    }
    exp = Math.floor(exp/2);
    f = modmult(f,f,N);
  };
  t = modmult(t,f,N);
  return t;
}

// SPRP(N,a) checks if N (odd!) is a strong probable prime base a 
// (returns true or false)

function SPRP(N,a) {
  var d = N-1; s = 1;  			// Assumes N is odd!
  while ( ((d=d/2) & 1) == 0) s++;	// Using d>>1 changed the sign of d!
  // Now N-1 = d*2^s with d odd
  var b = modpow(a,d,N);
  if (b == 1) return true;
  if (b+1 == N) return true;
  while (s-- > 1) {
    b = modmult(b,b,N);
    if (b+1 == N) return true;
  }
  return false;
}

// The idiot proofing, answer returning script

function check(e){
  if (e.hasAttribute("disabled")) return;
  var start = performance.now();
  var TrialLimit = 1300; // Should be bigger, like 10000
  var N = document.getElementById("primenumbercheck").value;
  var Result = "Unknown error";
  var a;
    
  if (N > 9007199254740991) {
    Result = "Sorry, this routine will only handle integers below 9007199254740991.";
  } else if (N == 1) {
    Result = "The number 1 is neither prime or composite (it the multiplicative identity).";
  } else if (N < 1) {
    Result = "We usually restrict the terms prime and composite to positive integers";
  } else if (N != Math.floor(N)) {
    Result = "We usually restrict the terms prime and composite to positive integers";
  } else {
    // Okay, N is of a resonable size, lets trial divide
    window.status = "Trial dividing " + N + " to " + TrialLimit + ".";
    i = trial_divide(N,TrialLimit);
    if (i > 0 && i != N) { 
      Result = N+" is not a prime! It is "+i+" * "+N/i;
    } else if (N < TrialLimit*TrialLimit) {
      Result = N+" is a (proven) prime!";
    } else if ( SPRP(N,a=2) && SPRP(N,a=3) && SPRP(N,a=5) && SPRP(N,a=7) 
    		&& SPRP(N,a=11) && SPRP(N,a=13) && SPRP(N,a=17)) {
      // Some of these tests are unnecessary for small numbers, but for
      // small numbers they are quick anyway.
      if (N < 341550071728321) {
        Result = N + " is a (proven) prime.";
      } else if (N == 341550071728321) {
        Result = N+" is not a prime! It is 10670053 * 32010157.";
      } else {
        Result = N + " is probably a prime (it is a sprp bases 2, 3, 5, 7, 11, 13 and  17).";
      };
    } else {
      Result = N+" is (proven) composite (failed sprp test base "+a+").";
    };
  };
  var end = performance.now();
  var timeTaken = end - start;
  window.status= "Done!"; // here so says done when present alert box
  var x = document.getElementsByClassName("primecheck");
  x[0].innerHTML = Result;
  setTimer(timeTaken);

}

function generate(e){
  if (e.hasAttribute("disabled")) return;
  var start = performance.now();
  var x = document.getElementsByClassName("primelist");
  var N = document.getElementById("primenumberlist").value;

  var i = 2;
  var Result = "2, ";
  var currentInt = 3;
  var possiblePrime;
  if (N == 2) 
    Result = Result + currentInt + ", ";
  else {
    while (i < N) {
      possiblePrime = false;
        if(currentInt == 3) {
          Result = Result + currentInt + ", ";
            possiblePrime = false;
        }
	else if(currentInt % 5 == 0 && currentInt > 5) {
	  possiblePrime = false;
	}
        else if(currentInt % 6 == 1 || currentInt % 6 == 5) 
          possiblePrime = true;
        if(possiblePrime) {
          if(trial_divide(currentInt,Math.ceil(Math.sqrt(currentInt))) == currentInt) {
            Result = Result + currentInt + ", ";
            i++;
          }
        }
        currentInt = currentInt + 2;
      }
    }
  var end = performance.now();
  var timeTaken = end - start;
  x[0].innerHTML = Result.substring(0, Result.length - 2);
  setTimer(timeTaken);
}

function setTimer(timeTaken) {
  var timerElement = document.getElementsByClassName("timeElapsed")[0];
  var timerPreText = "Time Elapsed: ";
  var duration = convertMS(timeTaken);
  timerPreText = timerPreText + duration.day + " days: " + duration.hour + " hours: " + duration.minute + " minutes: " + duration.seconds + " seconds" + ": " + 

duration.milliseconds + " milliseconds";
  timerElement.innerHTML = timerPreText;
}

function isNumberKey(evt)
{
  var charCode = (evt.which) ? evt.which : event.keyCode
  if (charCode > 31 && (charCode < 48 || charCode > 57))
     return false;
     return true;
}

function convertMS( milliseconds ) {
    var day, hour, minute, seconds, milliseconds;
    seconds = Math.floor(milliseconds / 1000);
    milliseconds = milliseconds - (seconds * 1000);
    milliseconds = milliseconds.toFixed(2);
    minute = Math.floor(seconds / 60);
    seconds = seconds % 60;
    hour = Math.floor(minute / 60);
    minute = minute % 60;
    day = Math.floor(hour / 24);
    hour = hour % 24;
    return {
        day: day,
        hour: hour,
        minute: minute,
        seconds: seconds,
	milliseconds: milliseconds
    };
}

function checkInput(input, buttonId)
{
    var name = input.value;
    var cansubmit = (name.length > 0);
    if (cansubmit) {
        document.getElementById(buttonId).removeAttribute("disabled");
    } else {
        document.getElementById(buttonId).setAttribute("disabled", null);
    }
};

</SCRIPT>

<article class="message is-success timerDiv" style="visibility: visible;">
  <div class="message-body">
    <p class="timeElapsed">Time elapsed will be shown here!</p>
  </div>
</article>

<article class="message is-primary">
  <div class="message-body">
    <strong class="title">Check prime number</strong>
	<div class="content" style="margin-top: 10px;">
	<div><input id="primenumbercheck" class="input is-rounded" type="text" placeholder="Enter the number you wanna check..." style="max-width: 25%;" 

onkeypress="return isNumberKey(event)" onkeyup="checkInput(this, 'primenumbercheckButton')">
	<a class="button is-link is-rounded" onclick="check(this)" id="primenumbercheckButton" disabled>Check</a></div>
	</div>
  </div>
</article>

<div class="container is-fullhd">
  <div class="notification primecheck">
    Prime check goes here!
  </div>
</div>

<article class="message is-primary">
  <div class="message-body">
    <strong class="title">List prime numbers</strong>
	<div class="content" style="margin-top: 10px;">
	<div><input id="primenumberlist" class="input is-rounded" type="text" placeholder="Enter the number of prime numbers you wanna generate..." style="max-width: 

35%;" onkeypress="return isNumberKey(event)" onkeyup="checkInput(this, 'primenumberlistButton')">
	<a class="button is-link is-rounded" onclick="generate(this)" id="primenumberlistButton" disabled>List</a></div>
	</div>
  </div>
</article>

<div class="container is-fullhd">
  <div class="notification primelist">
    Prime list goes here!
  </div>
</div>

</div>

</BODY>
</HEAD>
</HTML>

【讨论】：