代码

var c = 100;
var j = 2;
var numerosPrimos = [];

for (; j < c; j++) {

  if (primo(j)) {
    numerosPrimos.push(j);
  }
  
}

console.log(numerosPrimos);

function primo(numero) {

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

    if (numero % i === 0) {
      return false;
    }

  }

  return numero !== 1;
}

解释

注意：质数是那些只能被它们自己和数字一整除的数。

因此，我们创建了函数：

function primo(numero) {

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

    if (numero % i === 0) {
      return false;
    }

  }

  return numero !== 1;
}

以更自然的语言执行以下操作：

让numero我们从 2 迭代到 的值，numero - 1并且在每次迭代中，我们验证这些数字中的任何一个是否可以被 整除numero，如果是，我们返回，FALSE否则我们验证输入的数字不是 1，因为这不被认为是质数。如果评估的数字不是 1，则返回 TRUE，否则返回 FALSE。

因此在这个循环中：

for (; j < c; j++) {

  if (primo(j)) {
    numerosPrimos.push(j);
  }

}

我们开始循环遍历每个迭代数，检查函数primo()是否为素数并将其添加到数组中。

更新

由于我看到的评论，您似乎并不清楚该算法是如何工作的，我将逐步向您解释。

具有以下功能：

运行代码段以逐步查看它的工作原理。

function primo(numero) {

  console.log("Has pasado el numero: " + numero);
  console.log("Inicio bucle desde 2 hasta " + (numero - 1));

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

    console.log("Modulo entre " + numero + " y " + i + " = " + (numero % i));

    if (numero % i === 0) {
      console.log(i + " es un multiplo de " + numero);
      console.log(numero + " no es un numero primo porque " + i + " es un multiplo");
      return false;
    }

  }

  if (numero === 1) {
    console.log("Me has pasado el numero 1, recuerda que NO es un numero primo");
  } else {
    console.log("Como el numero ingresado no tuvo mas múltiplos entonces determinamos que SI es un numero primo.");
  }

  console.log("-------------------------------------");
}

primo(2);
primo(4);
primo(5);
primo(10);

从效率的角度来看，素数的计算一直是一个非常令人兴奋的话题，因为在一些需要非常大素数的实际应用中，密码学就是其中之一。该领域最常用的算法之一是RSA算法。

问题

需要计算存在于N个正整数范围内的素数的数量。

解决方案

在您的解决方案近似中，我们有经典的条件来确定一个数字是否为素数：

const elementos = 100;
const primos = [];
let iteraciones = 0;

for(let candidato = 2; candidato <= elementos; candidato++) {
    let primo = true;
    for(let divisor=2; divisor < candidato; divisor++) {
        iteraciones++;
        if(candidato%divisor === 0) {
            primo = !primo;
            break;
        }
    }
    if(primo) primos.push(candidato);
}

console.log(`iteraciones: ${iteraciones}`);
console.log(primos);

.as-console-wrapper { max-height: 100% !important; top: 0; }

这种算法可能更有效。如果我们分析将候选除以除数的部分，我们正在做一系列不必要的附加除法。对于这种情况，当N=100时，我们总共有1133 次迭代！！！

解释

合数 n是任何非素数自然数，可以写成以下形式：

n = a * b; { con a y b distintos de 1 y además si a >= b  entonces b <= sqrt(n) y viceversa}

这意味着a和b（n的除数）都有一个相互依赖的最大值。

然后，没有必要迭代从2到n的所有值来寻找 n 的可能除数，迭代到 n的平方根就足够了。而且由于在大多数情况下它并不精确，我们可以跳过小数部分，默认情况下只迭代到最接近的整数。

先前算法的改进如下：

const elementos = 100;
const primos = [];
let iteraciones = 0;

for(let candidato = 2; candidato <= elementos; candidato++) {
    let primo = true;
    let maximoDivisor = Math.floor(Math.sqrt(candidato));
    for(let divisor=2; divisor <= maximoDivisor; divisor++) {
        iteraciones++;
        if(candidato%divisor == 0) {
            primo = !primo;
            break;
        }
    }
    if(primo) primos.push(candidato);
}
console.log(`iteraciones: ${iteraciones}`);
console.log(primos);

.as-console-wrapper { max-height: 100% !important; top: 0; }

我们已将迭代次数减少到236 次迭代！！！得到相同的结果。它可以变得更高效吗？

埃拉托色尼之谜

在Eratosthenes 的筛子中，你被要求写出从 2 到N的所有自然数，然后，从 2 开始，你遍历整个列表，标记（划掉）所有 2 的倍数。然后你对列表中没有被划掉的下一个值（例如 3），依此类推，直到我们划掉 2和N之间的所有合数。最后，我们屏幕上没有被划掉的数字将正是我们正在寻找的素数。

该算法将是这样的：

1. 使用从 2 到N的所有数字创建一个列表。
2. 从i=2迭代到i <= Math.floor(Math.sqrt(N))（从我们之前看到的）
3. 如果i没有被删除，它会从j=i迭代到Math.floor(N/i)并删除列表中i ( i*j ) 的每个倍数。
4. 当步骤 2 的迭代完成时，素数将是列表中没有被划掉的素数。

一个例子（取自维基百科）：

要在 Javascript 中实现此算法，我们可以执行以下操作：

1. 创建从 2 到N的元素列表：

const elementos = 100;
const criba = (new Array(elementos - 1)).fill(1);

在上面的代码中，我们创建了一个包含 99 个元素的数组（从 2 到N有N - 1 个元素），并且 我们用 1 填充了这个数组。

2. 从i=2迭代到i<=Math.floor(Math.sqrt(N))：

const maxDivisor = Math.floor(Math.sqrt(elementos));
for(let i = 2; i <= maxDivisor; i++) { ... }

上面的代码计算N的平方根并创建一个从 2 到该值的for循环。

3. 如果i没有被删除，它会从j=i迭代到Math.floor(N/i)并删除列表中i ( i*j ) 的每个倍数。

//dentro del bucle for

// i representa el número que estamos probando, su posición en la lista es: i - 2
// si criba[i - 2] vale 1 significa que no ha sido tachado
if(criba[i - 2]) {
  //iteramos hasta Math.floor(elementos/i) ya que multiplicaremos i por j (múltiplos de i)
  //entre i y N hay N/i múltiplos
  for(let j = i; j <= Math.floor(elementos/i); j++){
    criba[(i*j) - 2] = 0; // recordar que debemos restar 2 para indicar el índice correcto
  }
}

在上面的代码中，通过将列表中的值设置为零来删除每个被迭代的值的倍数。

4. 当步骤 2 的迭代完成时，素数将是列表中没有被划掉的素数。

const primos = [];

criba.forEach((primo, index) => {
  if(primo) primos.push(index + 2);
});
console.log(primos);

在上面的代码中，创建了一个名为primes的数组并遍历了筛子。对于每个未被划掉的元素（其值为 1），其加到 2 的位置（索引 + 2 ）保存在素数数组中，这将是素数的值。

该算法的实现可能是：

const elementos = 100;
const primos = [];
const criba = (new Array(elementos - 1)).fill(1);
let iteraciones = 0;

const maxDivisor = Math.floor(Math.sqrt(elementos));

for(let i = 2; i <= maxDivisor; i++) {
  if(criba[i - 2]) {
    for(let j = i; j <= Math.floor(elementos/i); j++){
      criba[(i*j) - 2] = 0;
      iteraciones++;
    }
  }
  iteraciones++;
}
criba.forEach((element, index) => {
  if(element) primos.push(index + 2);
});

console.log(`iteraciones: ${iteraciones}`);
console.log(primos);

.as-console-wrapper { max-height: 100% !important; top: 0; }

请注意，这个算法比前两个算法更有效，因为，去掉我们必须创建数字列表然后通过它来获得素数的事实，结果只需要113 次迭代！.

我希望这能阐明实现目标的不同方法，埃拉托色尼筛是最有效的方法之一。

使用生成器 (ES6)

一种可能性是使用生成器简单地对其进行迭代，并在每次迭代时返回序列中的下一个素数。

这个想法很简单，没有必要存储质数，所做的是采用 Eratosthenes 筛子中提出的想法并创建一个实现该方法的可迭代结构，next()这样每次调用该方法都返回一个素值，所以我们可以显示第一个n素数。

第一件事是有一种方法来迭代自然数，给定一个初始值。我们可以编写一个生成器函数，每次next()调用序列中的函数时返回自然数序列（从值 n）。

例如：

// generador de números naturales
const naturales = function* (inicio) {
  inicio = inicio < 1 ? (inicio === 0 ? 1 : -inicio) : inicio; // los naturales no son negativos
  
  yield inicio;
  yield* naturales(inicio + 1);
}

// creamos la secuencia que empiece en 1
const seq = naturales(1);

// mostramos los primeros 10 naturales:
for (let i = 0; i< 10; ++i) {
  console.log(seq.next().value);
}

.as-console-wrapper {
  min-height: 100%;
  top: 0;
}

Ahora necesitamos crear una función generadora que tome cada valor de la secuencia de números naturales y dado un primo, me devuelva todos los valores que no sean múltiplos de dicho primo. Esto es una criba sobre una secuencia de valores.

Por ejemplo:

const criba = function* (seq, primo) {
  for (let num of seq) {
    if (num % primo !== 0) {
      yield num;
    }
  }
}

Esta función recorre una secuencia de números y devuelve aquellos que no sean múltiplos de primo.

Ahora que tenemos estas 2 funciones que devuelven una secuencia, podemos escribir otra función generadora que a partir de un valor inicial devuelva el siguiente valor primo. Esto lo logramos reescribiendo la secuencia de valores naturales por aquella que tenga los valores no múltiplos del primo anterior.

Por ejemplo:

const primos = function* (seq) {
  let primo = seq.next().value;
  yield primo;
  seq = criba(seq, primo);
  yield* primos(seq);
}

En esta función se recibe una secuencia que (idealmente) inicia en un valor primo (supongamos el 2). Luego, por cada valor de la misma, crea una nueva secuencia que contiene sólo los números que no son múltiplos del primo generado, y devuelve dicho valor en cada llamado a next().

Un ejemplo del código anterior funcionando para mostrar los primeros 10 primos sería:

const naturales = function* (inicio) {
  inicio = inicio < 1 ? (inicio === 0 ? 1 : -inicio) : inicio; // los naturales no son negativos
  yield inicio;
  yield* naturales(inicio + 1);
}

const criba = function* (seq, primo) {
  for (let num of seq) {
    if (num % primo !== 0) {
        yield num;
    }
  }
}

const primos = function* (seq) {
  let primo = seq.next().value;
  yield primo;
  seq = criba(seq, primo);
  yield* primos(seq);
}

const p = primos(naturales(2));

// mostrar los primeros 10 valores primos
for(let i = 0; i < 10; ++i) {
  console.log(p.next().value);
}

.as-console-wrapper {
  min-height: 100%;
  top: 0;
}

Si bien este algoritmo tal vez no sea tan eficiente como los presentados con anterioridad, es otra forma de obtener valores primos usando generadores de Javascript para obtener una secuencia que siempre devolverá un valor primo cada vez que se llame al método next().

1. Eratosthenes algorithm encontrar todos los numeros debajo de n
2. iniciamos un array para todos los numeros en true
3. eliminamos del array los multiplos
4. agregamos a otro array los que no tienen multiplos

function eratosthenes(n) {
  var array = [],
    upperLimit = Math.sqrt(n), //(1)
    output = [];

  for (var i = 0; i < n; i++) { //(2)
    array.push(true);
  }

  for (var i = 2; i <= upperLimit; i++) {
    if (array[i]) {
      for (var j = i * i; j < n; j += i) {
        array[j] = false; //(3)
      }
    }
  }

  for (var i = 2; i < n; i++) {
    if (array[i]) {
      output.push(i); //(4)
    }
  }
  return output;
};
console.log(eratosthenes(30))

Tambien existe este algoritmo https://en.wikipedia.org/wiki/Sieve_of_Atkin es moderno para hallar los numeros primos

最好知道除了 2 之外的成对数不是素数，我们将它们从公式中取出；我们必须得到可能是 3、5、7、9 的奇数，但我们知道 9 是 3 的倍数并且我们发出它，我们只剩下 3、5 和 7，因为我们已经知道这些数字从 1 到 10 是素数，我们可以省略它们，从 11 开始，将 2 加 2，因此我们不必验证它是否是偶数

var cantidad = 100,j=2;

function espar( x ) {
  return !( x & 1 );
}
function esMultiplo( x , multiplo ) {
  return (x % multiplo) == 0;
}

for(var i=11;i<cantidad;i+=2) {
    if (esMultiplo(i , 3) || esMultiplo(i , 5) || esMultiplo(i , 7)){
      continue;
   }
  console.log(i)         
}

Bueno yo me base en esta formula, Lo saque de la pagina: http://www.ceiploreto.es/sugerencias/ceibal/Primo_o_compuesto/cmo_saber_si_un_nmero_es_primo.html!

Use la consola para apreciar el resultado. Lo que hice fue crear dos funciones: La primera se encarga de evaluar si es o no es un numero primo. Y la segunda se encarga de que numero a que numero deseas saber los números primos.

 /* Esta primera función es la encargada de saber si el
numero ingresado es un numero primo; si en caso es primo
devuelve el numero y en caso que no lo es no devuelve
nada*/

const puederSerPrimo = (numero = undefined) => {

  /*Lo que hago aquí es que 0 y 1 decir que no son
  números primos, ya que al mandar un return sin nada
  entonces no estaríamos enviando ningún valor.*/

  if (numero === 0) return
  if (numero === 1) return
  /*El return vacío no enviara nada al array*/

  /* Lo que hice aquí fue colocar las bases de los
  números primos */
  let basesDePrimos = [2, 3, 5, 7, 11, 13]

  /* Con la ayuda de un for reviso si el numero
  ingresado es igual que alguna base de los primos */
  for (let z = 0; z <= basesDePrimos.length; z++) {
    while (numero === basesDePrimos[z]) {
      return console.log(`El ${numero} si es primo.`)
    }
  }

  /* Lo que hice aquí declarar una una variable
  divisiones para así con la ayuda de un while
  controlar el  numero de las divisiones */
  let divisiones = 0

  /* El numero de divisiones no puede ser mayor que la
  cantidad de números de las bases de los primos*/
  while (divisiones < basesDePrimos.length) {

    /* El for hace que avance 1 por 1 de casilla de el
    Array basesDePrimos*/
    for (let n = 0; n <= basesDePrimos.length; n++) {

      /* El signo % saca el residuo de una división y
      si en caso el residuo es 0, significa que no es
      un numero primo */
      let residuo = numero % basesDePrimos[n]

      while (residuo === 0) {
        return
        /*El return vacío no enviara nada al array*/
      }
    }

    /* Con divisiones++ hago que incremente el valor de
    divisiones dentro del while ya que si no
    incrementamos el valor haremos un bucle infinito*/
    divisiones++
  }

  /* Por ende si el numero al dividirse con las bases
  de los primos no obtuvo un residuo de 0, sacamos la
  conclusión que es un numero primo*/
  return console.log(`El ${numero} si es primo.`)

}

/* Esta función se encarga de saber de que numero a que
numero deseamos saber los números primos; también llama
a la función anterior y con la ayuda del for recorremos
1 por 1 los números*/
const numeroDePrimos = (inicio, final) => {
  for (let v = inicio; v <= final; v++) {

    /* Con la ayuda de un Array vacío y el push imprimo
    en la consola los numero primos encontrados*/
    let primos = []
    primos.push(puederSerPrimo(v))

  }
}

/* Aquí declaro el inicio y el final de todos los
numero que deseo saber si son primos*/
numeroDePrimos(0, 100);

Aquí la misma respuesta pero sin comentarios

  const puederSerPrimo = (numero = undefined) => {

  if (numero === 0) return
  if (numero === 1) return

  let basesDePrimos = [2, 3, 5, 7, 11, 13]

  for (let z = 0; z <= basesDePrimos.length; z++) {
    while (numero === basesDePrimos[z]) {
      return console.log(`El ${numero} si es primo.`)
    }
  }

  let divisiones = 0

  while (divisiones < basesDePrimos.length) {

    for (let n = 0; n <= basesDePrimos.length; n++) {

      let residuo = numero % basesDePrimos[n]

      while (residuo === 0) {
        return
      }
    }

    divisiones++
  }

  return console.log(`El ${numero} si es primo.`)

}

const numeroDePrimos = (inicio, final) => {
  for (let v = inicio; v <= final; v++) {

    let primos = []
    primos.push(puederSerPrimo(v))

  }
}

numeroDePrimos(0, 100);

Y si en caso quisieras imprimir en la consola todos los números de inicio a fin y aparezca si es o no es un numero primo entonces:

 const puederSerPrimo = (numero = undefined) => {
  if (numero === undefined) return console.warn(`No se 
  puede dejar vacio`)
  if (numero === 0) return console.log(`El numero 
  ${numero} no es primo.`)
  if (numero === 1) return console.log(`El numero 
  ${numero} no es primo.`)
  if (!numero) return console.error(`No se puede
  colocar texto`)

  let basesDePrimos = [2, 3, 5, 7, 11, 13]

  for (let z = 0; z <= basesDePrimos.length; z++) {
    while (numero === basesDePrimos[z]) {
      return console.log(`El ${numero} si es primo.`)
    }
  }

  divisiones = 0

  while (divisiones < 6) {

    for (let n = 0; n <= basesDePrimos.length; n++) {

      let residuo = numero % basesDePrimos[n]

      while (residuo === 0) {
        return console.log(`El ${numero} no es primo.`)
      }
    }
    divisiones++
  }

  return console.log(`El ${numero} si es primo.`)

}

const numeroDePrimos = (inicio, final) => {
  for (let v = inicio; v <= final; v++) {
    let primos = []
    primos.push(puederSerPrimo(v))

  }
}

numeroDePrimos(0, 100);

我只添加到空返回一个带有Templai String的console.log来添加值，并且我还在开头添加了两个if。我希望它对你有用。干杯！！！

Para calcular los semiprimos de un numero a, a un numero b

function findSemiprimes(rangeStart, rangeEnd) {
  let inicio = rangeStart
  let final = rangeEnd
  // configuramos el inicio 
  if (final < inicio) {
    inicio = rangeEnd
    final = rangeStart
  }

  // calculamos los primos dentro del rango
  let primos = []
  for (let i = 1; i <= final; i++) {
    if (isPrime(i)) {
      primos.push(i)
    }
  }

  let semiPrimos = []

  for (const primo of primos) {
    let primos2 = []
    for (let i = 2; i <= primo; i++) {
      if (isPrime(i)) primos2.push(i)
    }
    for (const primo2 of primos2) {
      let posible = primo * primo2
      if (posible <= final) {
        if (semiPrimos.indexOf(posible) <= 0) {
          semiPrimos.push(posible)
        }
      }
    }

  }

  semiPrimos.sort(function (a, b) {
    return a - b;
  })
  semiPrimos = semiPrimos.filter(primo => primo >= inicio)
  return semiPrimos
}


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

function main() {
  const result = findSemiprimes(20, 100);
  console.log("result:", result)
}

main()

var rango = parseInt(prompt("Ingrese un rango"));
var contador = 0;
const primos = [];
while(contador<=rango){
    var primo = contador;
    if (typeof primo== "number"){
        var ceros = 0;
        for(var i=1; i<=primo; i++){
            if(primo%i==0){
                ceros++;
            }
        }
        if(primo==0 || primo==1){
            primos[i]=null
        }
        else if(ceros==2){
            primos[i]=primo;
        }
    }else{
        alert("Numero incorrecto")
    }
    contador++;
}
// var cadena = primos.toString();
// var a = cadena.replace(/,/g, "")
// var n_Primos = a.length;
document.write(primos);

function esPrimo(n) {
  let i = 1;
  while (n % ++i != 0);
  return n == i;
}

for (let i = 2; i < 100; i++)
  if (esPrimo(i))
    console.log(i);