【问题标题】：Number prime test in JavaScriptJavaScript中的数素测试
【发布时间】：2017-03-05 03:34:22
【问题描述】：

我正在尝试完成Codewars 挑战，该挑战要求您检查一个数字是否为质数。无论出于何种原因，我的解决方案似乎不适用于奇素数的平方（例如，9 返回 true 而不是 false）。

function isPrime(num) {

  if (num === 2) {
    return true;
  } else if (num > 1) {
    for (var i = 2; i < num; i++) {

      if (num % i !== 0) {
        return true;
      } else if (num === i * i) {
        return false
      } else {
        return false;
      }
    }
  } else {
    return false;
  }

}

console.log(isPrime(121));

附：我包含第二个 else/if 语句是因为我试图解决问题。

【问题讨论】：

Prime Numbers JavaScript的可能重复
你的 for 循环永远不会迭代超过一次。
@ShashwatKumar 请解释为什么以及如何解决这个问题
这是非常低效的，不要对这样的事情使用循环......检查我的答案，寻找最简单的 CPU 方法来查找质数......here
码流使用你的代码来推广他们的软件......我觉得这很有趣

标签： javascript

【解决方案1】：

从 Node.js 16 开始，这是built-in：

import {checkPrimeSync as isPrime} from 'node:crypto';

console.log(isPrime(13));
//=> true

否则，@IhorSakaylyuk 的答案可以通过跳过偶数来进一步改进：

function isPrime(number) {
    if((number % 2 === 0 && number !== 2) || number <= 1) {
        return false;
    }

    const limit = Math.floor(Math.sqrt(number));

    for(let index = 3; index <= limit; index += 2) {
        if (number % index === 0) {
            return false;
        }
    }

    return true;
}

我还用这个函数创建了一个npm package。

【讨论】：

【解决方案2】：

下面的实现比之前所有的答案都快，这就是我添加它的原因。

以下代码来自my prime library:

/**
 * Maximum prime number that can be generated in JavaScript,
 * using the standard 'number' type (53-bit of integer range).
 */
const maxPrime = 9_007_199_254_740_881;

const dividers = [
    0, 2, 6, 8, 12, 18, 20, 26, 30, 32, 36, 42, 48, 50, 56, 60, 62, 68, 72, 
    78, 86, 90, 92, 96, 98, 102, 110, 116, 120, 126, 128, 132, 138, 140, 146,
    152, 156, 158, 162, 168, 170, 176, 180, 182, 186, 188, 198, 200
];

function isPrime(x: number): boolean {
    if (isNaN(x) || x < 2 || x > maxPrime || x % 1) {
        return false;
    }
    if (x % 2 === 0) return x === 2;
    if (x % 3 === 0) return x === 3;
    if (x % 5 === 0) return x === 5;
    if (x % 7 === 0) return x === 7;
    const m = Math.sqrt(x);
    for (let i = 11; i <= m; i += 210) {
        for (const a of dividers) {
            if (x % (i + a) === 0) {
                return i + a === x;
            }
        }
    }
    return true;
}

在我的机器上，它可以在 217 毫秒内验证前一百万个数字。

【讨论】：

【解决方案3】：

If x is not a prime, then we can find "a" and "b" such that
a**2 <= x <= b**2 , where a,b ∈ N+
=> a <= sqrt(x) <= b
So check until the sqrt(x) its upper bound is enough.

isPrime = x => {
    if (!Number.isInteger(x)) return false

    if (x > 2 && x % 2 ===0) return false 

    for (let divisor=3; divisor<=Math.sqrt(x); ++divisor) {
        if (x % divisor === 0) return false        
    }
    return x > 1
}

testData = [-1, 0, 1, 2, 3, 4, 4.1, 9, 11, "a"]
for (const data of testData) {
  console.log(`${data} is Prime? ${isPrime(data)}`)
}

【讨论】：

【解决方案4】：

此答案基于Ihor Sakaylyuk 的答案。但我不是检查所有数字，而是只检查奇数。这样做我将解的时间复杂度降低到 O(sqrt(n)/2)。

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

【讨论】：

你有一个错误 isPrime(9) 是 true。您应该在i < Math.sqrt(...) 上添加=

【解决方案5】：

const checkPrime=(no)=>{
  var divisor = 2;

  while (no > divisor){
    if(no % divisor == 0){
     return `${no} is not a  prime no`; 
    }
    else
      divisor++;
  }
  return `${no} is a prime no`;
}
(console.log(checkPrime(3)));
(console.log(checkPrime(12)));
(console.log(checkPrime(233)));

【讨论】：

【解决方案6】：

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

function primeNumber(n) {
    let arr = [];
    if (n <= 1) return false;
    if (n === 2) return true;
    let flag = true;
    for (let i = 3; i < n; i += 2) {
        if (n % i == 0) {
            flag = false;
            break;
        }
    }
    return flag;
}
// It will retrun bollean true/false
// primeNumber(11)  true
// primeNumber(12)  false

最好的部分是复杂度是 o(n/2)

【讨论】：

这对 4 来说返回 true

【解决方案7】：

比常规方法快三倍：

function isPrime (num){
    if (num === 1){
        return false;
    }
    if(num === 2 || num === 3){
        return true;
    }
    if((num % 2 !== 0) && (num % 3 !== 0)){
        let k = 1;
        const numSqrt = Math.sqrt(num);
        if(( 6 * k - 1 ) > numSqrt){
            return true;
        } else {
            while( ( 6 * k - 1 ) <= numSqrt ){
                if(num % (6 * k - 1) !== 0 && num % (6 * k + 1) !== 0){
                return true;
            }
            k++;
        }
        return false;
      }
  }
  return false;
}
console.log(isPrime(29))

【讨论】：

【解决方案8】：

这是一个优化的解决方案，可以防止循环遍历所有范围号。

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

【讨论】：

【解决方案9】：

function isPrime(num) { 
  return Array.from({ length: num }, (i, index) => index + 1).filter(
    (item, i) => (num % item) === 0).length === 2;
}

console.log(isPrime(1)); // false
console.log(isPrime(2)); // true
console.log(isPrime(3)); // true
console.log(isPrime(4)); // false

【讨论】：

【解决方案10】：

function isPrime(num) { // returns boolean
  if (num <= 1) return false; // negatives
  if (num % 2 == 0 && num > 2) return false; // even numbers
  const s = Math.sqrt(num); // store the square to loop faster
  for(let i = 3; i <= s; i += 2) { // start from 3, stop at the square, increment in twos
      if(num % i === 0) return false; // modulo shows a divisor was found
  }
  return true;
}
console.log(isPrime(121));

感谢 Zeph 纠正了我的错误。

【讨论】：

请在您的代码中添加解释。它可以帮助人们理解算法，因此他们可以适应它，而不仅仅是复制你的代码。
在 9 上失败，因为 sqrt(9) = 3，并且您的循环不会被调用。试试i <= s

【解决方案11】：

我会这样做：

const isPrime = (num) => num < 10 ? [2, 3, 5, 7].includes(num) : ![2, 3, 5, 7].some(i => !(num % i));

【讨论】：

【解决方案12】：

如果你想找到 n 个素数，这是一个更可靠的解决方案。

function findPrime(n) {
      const primes = [];
      loop1:
      for (let j = 0; primes.length < n; j++) {
       loop2:
       for(let i = 2; i < j; i++){
        if(j % i === 0){
            continue loop1;
        }
      }
      if(j>1) primes.push(j);
      }
      console.log(primes);
    }
     
    findPrime(5);

【讨论】：

【解决方案13】：

我认为获得它的最简单和更快的方法是

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

console.log(isPrime(9))

【讨论】：

“Ihor Sakailiuk”提供的公认答案已经说明了这一点。

【解决方案14】：

这会以不同的方式计算平方并跳过偶数。

const isPrime = (n) => {
  if (n <= 1) return false;
  if (n === 2) return true;
  if (n % 2 === 0) return false;
  //goto square root of number
  for (let i = 3, s = n ** 0.5; i < s; i += 2) {
    if (n % i == 0) return false;
  }
  return true;
};

【讨论】：

【解决方案15】：

可能对某些人有用：米勒拉宾素数测试的实现。适用于小于 Number.MAX_SAFE_INTEGER 的所有正整数。

试用 JSFiddle：https://jsfiddle.net/4rxhas2o/


let unsafeToSquare = Math.floor(Math.sqrt(Number.MAX_SAFE_INTEGER))

function addMod(a, b, m) {
  // Returns (a + b) % m

  let sum = a + b

  let result = sum % m

  if (sum < Number.MAX_SAFE_INTEGER)
    return result

  let signature = ((a % 8) + (b % 8)) % 8

  let sumMod = sum % 8

  for (let i = -2; i <= 2; ++i) {
    if ((sumMod + i) % 8 === signature) {
      let ret = result + i

      if (ret > m)
        ret = (result - m) + i // prevent overflow

      return ret
    }
  }
}

function mulMod(a, b, m) {
  if (m === 0)
    return 0

  let prod = a * b

  if (prod < Number.MAX_SAFE_INTEGER)
    return prod % m

  let y = 0
  let result = a

  while (b > 1) {
    if (b % 2 === 0) {
      result = addMod(result, result, m)

      b /= 2
    } else {
      y = addMod(result, y, m)
      result = addMod(result, result, m)

      b = (b - 1) / 2
    }
  }

  return addMod(result, y, m)
}

function squareMod(b, m) {
  // Computes (b * b % m)

  return mulMod(b, b, m)
}

function expModLargeB(b, exponent, m) {
  let y = 1

  while (exponent > 1) {
    if (exponent % 2 === 0) {
      b = squareMod(b, m)

      exponent /= 2
    } else {
      y = mulMod(y, b, m)
      b = squareMod(b, m)

      exponent = (exponent - 1) / 2
    }
  }

  return mulMod(b, y, m)
}

function expMod(b, exponent, m) {
  if (exponent === 0)
    return 1

  if (b >= unsafeToSquare || m >= unsafeToSquare) {
    return expModLargeB(b, exponent, m)
  }

  let y = 1

  while (exponent > 1) {
    if (exponent % 2 === 0) {
      b *= b
      b %= m

      exponent /= 2
    } else {
      y *= b
      b *= b

      y %= m
      b %= m

      exponent = (exponent - 1) / 2
    }
  }

  return (b * y) % m
}

function _isPrimeTrialDivision(p) {
  let sqrtP = Math.ceil(Math.sqrt(p))

  for (let i = 23; i <= sqrtP + 1; i += 2) {
    if (p % i === 0)
      return false
  }

  return true
}

function _isProbablePrimeMillerRabin(p, base=2) {
  let pm1 = p - 1
  let pm1div = pm1
  let d, r = 0

  while (true) {
    if (pm1div % 2 === 0) {
      pm1div /= 2

      r++
    } else {
      d = pm1div
      break
    }
  }

  let x = expMod(base, d, p)

  if (x === 1 || x === pm1)
    return true

  for (let i = 0; i < r - 1; ++i) {
    x = squareMod(x, p)

    if (x === pm1)
      return true
  }

  return false
}

function _isPrimeLarge(p) {
  let bases

  if (p < 2047)
    bases = [2]
  else if (p < 1373653)
    bases = [2, 3]
  else if (p < 9080191)
    bases = [31, 73]
  else if (p < 25326001)
    bases = [2, 3, 5]
  else if (p < 3215031751)
    bases = [2, 3, 5, 7]
  else if (p < 4759123141)
    bases = [2, 7, 61]
  else if (p < 1122004669633)
    bases = [2, 13, 23, 1662803]
  else if (p < 2152302898747)
    bases = [2, 3, 5, 7, 11]
  else if (p < 3474749660383)
    bases = [2, 3, 5, 7, 11, 13]
  else if (p < 341550071728321)
    bases = [2, 3, 5, 7, 11, 13, 17]
  else
    bases = [2, 3, 5, 7, 11, 13, 17, 19, 23]


  return bases.every(base => _isProbablePrimeMillerRabin(p, base))
}

let smallPrimes = [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, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223]

function isPrime(p) {
  if (!Number.isInteger(p) || p < 2)
    return false

  // Test for small primes
  for (let i = 0; i < smallPrimes.length; ++i) {
    let prime = smallPrimes[i]

    if (p === prime)
      return true
    if (p % prime === 0)
      return false
  }

  if (p < 150) {
    return _isPrimeTrialDivision(p)
  } else {
    return _isPrimeLarge(p)
  }
}


const tests = [1, 2, 3, 10, 100, 100019, 10000000019, 100000000003, 10000000000037]
let start = performance.now()

tests.forEach(test => {
    console.log(`${test} is ${ isPrime(test) ? "" : "not " }prime`)
})

let end = performance.now()
console.log("Tests completed in " + (end - start) + " ms.")

【讨论】：

【解决方案16】：

唯一的偶素数是 2，所以我们应该从循环中排除偶数。

function isPrime(a) {
    if (a < 2) return false;
    if (a > 2) {
        if (a % 2 == 0) return false;
        for (let x = 3; x <= Math.sqrt(a); x += 2) {
            if (a % x == 0) return false;
        }
    }
    return true;
}

【讨论】：

【解决方案17】：

我的解决方案，

function isPrimeNumber(number){
  if(number <= 1) return false;
  if(number <= 3) return true;
  for(let i = 2; i < 9; i++) {
    if(number === i) continue;
    if(number % i === 0 ) return false;
  }  
  return true;
}

for(let i = 0; i <= 100; i++){
  if (isPrimeNumber(i)) console.log(i);
}

【讨论】：

【解决方案18】：

你为什么要尝试使用循环！？在这里迭代是一种计算能力的浪费......

这可以使用数学来完成：

function isPrime(num) {
    if ( num !=1 && num%3 != 0 && num%5 != 0 && num%7 != 0 && num%9 != 0 && num%11 != 0 && Math.sign(num) == 1 && Math.round(num) == num) {

        if ( (num-1)%6 == 0 || (num+1)%6 == 0 ) {
            return true;
        }

    } // no need for else statement since if true, then will do return
    return num==11||x==9||num==5||num==3||num==2; // will return T/F;
}

步骤：

检查数字是否能被 5 整除（均匀）
检查数字是否为正数（负数不是素数）
检查数字是否为整数（根据规则，5.236 不是素数）
检查数字 ± 1 是否能被 6 整除（均匀）
欲了解更多信息，请查看3Blue1Brown's Video
检查数字是2、3、9还是11（规则异常）
检查数字是 7 还是 5（由于尝试减少假阳性）

始终尝试使用数学方法，而不是迭代循环。数学几乎总是做某事最有效的方法。是的，这个等式可能会令人困惑......但是，在检查某物是否为质数时，我们不需要太多的可读性......未来的代码编辑器可能不需要维护它。

编辑：
优化代码版本：

function isPrime(x=0) {
    const m = Math;
    return (x%3!=0&&x%5!=0&&x%7!=0&&x%9!=0&&x%11!=0&&x!=1&&m.sign(x)*m.round(x)==x&&(!!!((x-1)%6)||!!!((x+1)%6)))||x==11||x==9||x==7||x==5||x==3||x==2;
}

编辑：
事实证明......还有更多与误报检测有关，因为它们是随机分布的（至少表面上是这样），所以 +-1 %6 的东西真的不适用于所有东西......但我'我肯定在这里...

【讨论】：

2 3 和 5 是素数，但您的函数返回 false。
@Seblor 我现在已经修复了该部分...但是正如您在第二次编辑中看到的那样，我遇到了其他问题并且不知道如何在没有迭代的情况下解决。 ..所以我很接近了，但没有雪茄......无论如何，希望这能激发一些精通数学的人想出一些令人难以置信的东西......但现在......这只是一个垂死的原型......哈哈跨度>
素数有无数个......你可以用你的代码捕获大量非素数，但你肯定需要一个大男孩的循环。

【解决方案19】：

最短的版本之一

isPrime=(n)=>[...Array(n-2)].map((_,i)=>i+2).filter(i=>n%i==0).length==0

【讨论】：

一个更短的：isPrime=n=>!'1'.repeat(n).match(/^1?$|^(11+?)\1+$/)
isPrime(1) 中断

【解决方案20】：

function isPrime(n){
	if (isNaN(n) || !isFinite(n) || n%1 || n<2) {
		return false;
	}

	if (n%2==0){
		return (n==2);
	}

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

【讨论】：

可以参考这里的解决方案：javascripter.net/faq/numberisprime.htm

【解决方案21】：

质数的形式为 6f ± 1，不包括 2 和 3，其中 f 是任意整数

 function isPrime(number)
 { 
   if (number <= 1)
   return false;

   // The check for the number 2 and 3
   if (number <= 3)
   return true;

   if (number%2 == 0 || number%3 == 0)
   return false;

   for (var i=5; i*i<=number; i=i+6)
   {
      if (number%i == 0 || number%(i+2) == 0)
      return false;
   }

   return true;
 }

解的时间复杂度：O(sqrt(n))

【讨论】：

【解决方案22】：

尽可能简单：

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

使用 ES6 语法：

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

如果您运行循环直到数字的平方根，您还可以将算法的复杂性从 O(n) 降低到 O(sqrt(n))：

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

【讨论】：

检查与4 是否相等有什么用？也可以只检查奇数。
所以让它i <= s 并删除那个丑陋的硬编码条件？
@Saka7 这是一个非常有用的答案，特别是因为我没有考虑过sqrt 优化。 @zerkms 建议只检查奇数（当然大于两个），这也是我希望在优化的解决方案中看到的。您可以通过这种方式极大地优化您的解决方案。我制作了this JSPerf test 来演示。谢谢你们两位的指导。
isPrime(0) 返回true，事实并非如此。为了使函数在数学上正确，您需要在 return 语句中添加另一个条件：return num !== 1 && num !== 0;
您可以只使用条件return num >= 2; 而不是return num !== 1 && num !== 0;，因为素数必须是大于1 的自然数。

【解决方案23】：

你可以试试这个

function isPrime(num){
   	
    // Less than or equal to 1 are not prime
    if (num<=1) return false;
    
    // 2 and 3 are prime, so no calculations
    if (num==2 || num==3 ) return true; 
    
    // If mod with square root is zero then its not prime 
    if (num % Math.sqrt(num)==0 ) return false;
    
    // Run loop till square root
    for(let i = 2, sqrt = Math.sqrt(num); i <= sqrt; i++) {
    
        // If mod is zero then its not prime
        if(num % i === 0) return false; 
    }
    
    // Otherwise the number is prime
    return true;
   }
   
   
   for(let i=-2; i <= 35; i++) { 
   	console.log(`${i} is${isPrime(i) ? '' : ' not'} prime`);
   }

【讨论】：

【解决方案24】：

使用 Ticked 解决方案 Ihor Sakaylyuk

const isPrime = num => {
        for(let i = 2, s = Math.sqrt(num); i <= s; i++)
            if(num % i === 0) return false; 
        return num !== 1 && num !== 0;
}

在控制台中提供

isPrime( -100 ) 真的

const isPrime = num => {
  // if not is_number num return false

  if (num < 2) return false

  for(let i = 2, s = Math.sqrt(num); i <= s; i++) {
        if(num % i === 0) return false
  }

  return true
}

在控制台中提供

是素数（1）假的

isPrime( 100 ) 假的

isPrime( -100 ) 假的

前 6 个素数？ 2 3 5 7 11 13 ?

是素数（1）假的

是素数（2） true // 素数 1

isPrime( 3 ) true // 素数 2

isPrime( 4 ) 假的

isPrime( 5 ) true // 素数 3

isPrime( 6 ) 假的

isPrime( 7 ) true // 素数 4

isPrime( 8 ) 假的

isPrime( 9 ) 假的

isPrime( 10 ) 假的

isPrime( 11 ) true // 素数 5

是素数（12）假的

isPrime( 13 ) true // 素数 6

【讨论】：

【解决方案25】：

我认为这个问题缺少递归解决方案：

// Preliminary screen to save our beloved CPUs from unneccessary labour

const isPrime = n => {
  if (n === 2 || n === 3) return true;
  if (n < 2 || n % 2 === 0) return false;

  return isPrimeRecursive(n);
}

// The recursive function itself, tail-call optimized.
// Iterate only over odd divisors (there's no point to iterate over even ones).
 
const isPrimeRecursive = (n, i = 3, limit = Math.floor(Math.sqrt(n))) => {	
  if (n % i === 0) return false;
  if (i >= limit) return true; // Heureka, we have a prime here!
  return isPrimeRecursive(n, i += 2, limit);
}

// Usage example

for (i = 0; i <= 50; i++) {
  console.log(`${i} is ${isPrime(i) ? `a` : `not a` } prime`);
}

这种方法有它的缺点——因为浏览器引擎（编写于 11/2018）仍未经过 TC 优化，如果按 ~~的顺序测试素数，您可能会收到字面的 堆栈溢出 错误几十~~ 几亿或更高（可能会有所不同，取决于实际的浏览器和可用内存）。

【讨论】：

【解决方案26】：

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

如果我们想要两个数之间的质数，我们只需添加此代码

for(var i = 0; i < 100; i++){
        if(isPrime(i))
            console.log(i);
    }

【讨论】：

【解决方案27】：

function isAPrimeNumber(num){
     var counter = 0;
     //loop will go k equals to $num
     for (k = 1; k <= num; k++) {
      //check if the num is divisible by itself and 1
      // `%` modulus gives the reminder of the value, so if it gives the reminder `0` then it is divisible by the value
       if (num % k == 0) {
         //increment counter value 1
         counter  = counter  + 1;
        }
    }
   //if the value of the `counter is 2` then it is a `prime number`
  //A prime number is exactly divisible by 2 times only (itself and 1)
   if (counter == 2) {
     return num + ' is a Prime Number';
   }else{
    return num + ' is nota Prime Number';
   }
 }

现在通过传递一个值来调用isAPrimeNumber() 函数。

var resp = isAPrimeNumber(5);
console.log(resp);

输出：

5 is a Prime Number

【讨论】：

【解决方案28】：

以下代码使用最有效的循环方式来检查给定数字是否为素数。

function checkPrime(number){    
    if (number==2 || number==3) {
    return true
}
    if(number<2 ||number % 2===0){
        return false
    }
    else{
        for (let index = 3; index <= Math.sqrt(number); index=index+2) {
            if (number%index===0) {
                return false
            }        
        }
    }
    return true
}

首先检查排除 2 和更少的数字以及所有偶数
使用 Math.sqrt() 最小化循环次数
循环计数器加 2，跳过所有偶数，循环计数进一步减少一半

【讨论】：

【解决方案29】：

我认为找到素数的更好方法是使用以下逻辑：

var p=prompt("input numeric value","10"); // input your number 
for(j=2;j<p;j++){ 
  if(isPrimes(j)){ 
    document.write(j+", "); // for output the value
  } // end if
}// end for loop
function isPrimes(n) {
  var primes = true;// let prime is true
  for (i=2;i<n;i++) {
    if(n%i==0) {
      primes= false; // return prime is false
      break; // break the loop
    }// end if inner 
  }// end inner loop
  return primes; // return the prime true or false
}// end the function

【讨论】：

【解决方案30】：

(function(value){
    var primeArray = [];
    for(var i = 2; i <= value; i++){ 
        if((i === 2) || (i === 3) || (i === 5) || (i === 7)){ 
            primeArray.push(i);
        }
          else if((i % 2 !== 0) && (i % 3 !== 0) && (i % 5 !== 0) && (i % 7 !== 0)){ 
              primeArray.push(i);
          }
        } 
       console.log(primeArray);
}(100));

【讨论】：

请解释你的答案。照原样，这只是一个代码转储