Code

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;
}

Explanation

Note: Prime numbers are those that can only be divisible by themselves and the number one.

Therefore, we have created the function:

function primo(numero) {

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

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

  }

  return numero !== 1;
}

Which in more natural language does the following:

Having a numerowe iterate from 2 to the value of numero - 1and in each iteration we verify if any of these numbers is divisible with numero, if so, we return FALSEotherwise we verify that the entered number is not 1 since this is not considered a prime number . And if the number evaluated was not 1, then we return TRUE, otherwise we return FALSE.

Therefore in this loop:

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

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

}

We start looping through each of the iteration numbers checking through the function primo()if the number is prime and adding it to the array.

Update

Due to the comments that I have seen, it seems that it has not been clear to you how this algorithm works, I proceed to explain it to you step by step.

Having the following function:

Run the Snippet to see how it works step by step.

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);

The calculation of prime numbers has always been a very exciting topic from the point of view of efficiency, since among some of the practical applications that require very large prime numbers, is cryptography. One of the most used algorithms in this field is the RSA algorithm .

ISSUE

It is desired to calculate the number of prime numbers that exist in a range of N positive integers.

SOLUTION

In your solution approximation we have the classic conditional to determine if a number is prime or not:

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; }

This algorithm may be more efficient. If we analyze the part where we divide the candidate by the divisor, we are doing a series of unnecessary additional divisions. For this case, with a value of N=100 we have a total of 1133 iterations!!!

Explanation

A composite number n , is any non -prime natural number , which can be written in the form:

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

This means that both a and b (divisors of n ) have a maximum value that depends on each other.

Then, it is not necessary to iterate all the values ​​from 2 to n looking for the possible divisors of n , it is enough to iterate until the square root of n . And since it won't be exact in most cases, we can skip the decimal part and iterate only to the nearest integer by default.

The improvement of the previous algorithm would be the following:

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; }

We have reduced the number of iterations to 236 iterations!!! to get the same result. Can it be made even more efficient?

Eratosthenes riddle

In the Sieve of Eratosthenes , you are asked to write all the natural numbers from 2 to N , then, starting with 2, you go through the entire list marking (crossing out) all the multiples of 2. Then you do the same with the next value of the list that has not been crossed out (for example 3), and so on until we have crossed out all the composite numbers between 2 and N. In the end, the numbers that have not been crossed out in our screen will be precisely the prime numbers we are looking for.

The algorithm would be something like this:

1. A list is created with all the numbers from 2 to N .
2. Iterates from i=2 to i <= Math.floor(Math.sqrt(N)) (from what we saw earlier)
3. If i has not been struck through, it iterates from j=i to Math.floor(N/i) and strikes through each multiple of i ( i*j ) in the list.
4. When the iteration of step 2 is finished, the prime numbers will be those that have not been crossed out in the list.

An example (taken from Wikipedia):

To implement this algorithm in Javascript, we can do the following:

1. A list of elements from 2 to N is created :

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

In the above code, we have created an Array of 99 elements (from 2 to N there are N - 1 elements), and we have filled this Array with ones.

2. Iterates from i=2 to i<=Math.floor(Math.sqrt(N)) :

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

The code above calculates the square root of N and creates a for loop that goes from 2 to that value.

3. If i has not been struck through, it iterates from j=i to Math.floor(N/i) and strikes through each multiple of i ( i*j ) in the list.

//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
  }
}

In the code above, each multiple of the value being iterated through is crossed out by setting its value in the list to zero.

4. When the iteration of step 2 is finished, the prime numbers will be those that have not been crossed out in the list.

const primos = [];

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

In the code above, an Array called primes is created and the sieve is traversed. For each element not crossed out (whose value is 1), its position added to 2 ( index + 2 ) is saved in the Array of primes , which will be the value of the prime.

An implementation of this algorithm could be:

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; }

Note that this algorithm is even more efficient than the previous two, since, removing the fact that we must create the list of numbers and then go through it to get the primes, the result is achieved in just 113 iterations!!! .

I hope this makes clear the different ways to achieve the goal, with the Sieve of Eratosthenes being one of the most efficient.

Using a generator (ES6)

One possibility is to use a generator to simply iterate over it and return the next prime number in the sequence on each iteration.

The idea is simple and it is not necessary to store the prime values, what is done is to take the idea raised in the Eratosthenes sieve and create an iterable structure that implements the method next(), in such a way that each call to said method returns a prime value and so we can display the first nprime integers.

The first thing is to have a way to iterate over the natural numbers, given an initial value. We can write a generator function that returns the sequence of natural numbers (from a value n) each time the function next()in the sequence is called.

For example:

// 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;
}

Now we need to create a generator function that takes each value of the sequence of natural numbers and, given a prime, returns all the values ​​that are not multiples of that prime. This is a sieve over a sequence of values.

For example:

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

This function loops through a sequence of numbers and returns numbers that are not multiples of primo.

Now that we have these 2 functions that return a sequence, we can write another generator function that from an initial value returns the next prime value. We achieve this by rewriting the sequence of natural values ​​for the one that has the values ​​that are not multiples of the previous prime.

For example:

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

In this function, a sequence is received that (ideally) starts at a prime value (let's say 2). Then, for each value of it, it creates a new sequence containing only the numbers that are not multiples of the generated prime, and returns that value on each call to next().

An example of the above code working to display the first 10 primes would be:

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;
}

While this algorithm may not be as efficient as the ones presented above, it is another way to get primes using Javascript generators to get a sequence that will always return a prime every time the method is called next().

1. Eratosthenes algorithm find all numbers under n
2. we initialize an array for all numbers in true
3. we remove the multiples from the array
4. we add to another array those that do not have multiples

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))

There is also this algorithm https://en.wikipedia.org/wiki/Sieve_of_Atkin is modern to find the prime numbers

It would be better for you knowing that the numbers in pairs except 2 are not prime, we take them out of the formula; We would have to get the odd numbers that could be 3, 5, 7, 9 but we know that 9 is a multiple of 3 and we emit it, we would only have 3, 5 and 7 left, since we already know the numbers from 1 to 10 which are the primes we can omit them and start from 11 adding two by two and thus we do not have to validate if it is even

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)         
}

Well I am based on this formula, I took it from the page: http://www.ceiploreto.es/sugerencias/ceibal/Primo_o_compuesto/cmo_saber_si_un_nmero_es_primo.html !

Use the console to appreciate the result. What I did was create two functions: The first is responsible for evaluating whether or not it is a prime number. And the second takes care of which number to which number you want to know the prime numbers.

 /* 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);

Here the same answer but without comments

  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);

And if in case you wanted to print in the console all the numbers from beginning to end and it appears if it is or is not a prime number then:

 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);

I only add to the empty returns a console.log with a Templai String to add the values ​​and I also add two if at the beginning. I hope it has been useful to you. Cheers !!!

To calculate the semiprimes of a number a, to a number 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);