Playground: Generador de identificadores para michis

Aqui quice aportar algo diferente , este genera un string unico de 7 caracteres en cada iteracion

export function* getId() {
  while (true) {
    yield Math.random().toString(36).substring(5).toUpperCase();
  }
}

/*Results examples 

["I84P6YK","O7QL83M8","N5NCIQ1","JY6GGDYF","KLUY7TJQ","PAIU4RJB","Y5HUKX1M","SJWKL74O","62C1OBY7","783334YA"]

*/

export function* getId() {
  let michiId = 1
  while (true) {
    yield michiId++
  }
}

const michiId = getId()
console.log(michiId.next())

Siento que este playground esta algo mal estructurado, además de que la verdad las explicaciones de algunos temas no han sido lo mejor , ojala pudieran poner la respuesta usando exactamente lo que piden por que mire muchos aportes y lo solucionan pero no cumple los requisitos que pide el ejercicio.

export function* getId() {
  const arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'];
  for (let i = 1; i > 0; i++){
    for (const letter in arr) {
      yield i + arr[letter];
    }
  }
}

export function* getId() {
  for (let i = 1; i > 0; i++){
    yield i;
  }
}

Mi sencilla solución:

export function* getId() {
  let catID = 1
  while (true) {
    yield catID++
  }
}

Si te parece no entiendes la respuesta de los compañeros, te dejo la mia:

//como el array no esta debemos generarlo de la nada, por lo cual hacemos lo siguiente, generamos un ciclo while, el cual nos permite hacer sumar un numero al id (variable idsGenerados) cada vez que se ejecute, ¿porque no un for?: porque no sabemos cuantos veces se va a ejecutar (lo cual aparentemente fueran 3 veces, pero no lo es (no lo dice)). 

export function* getId() {
    let idsGenerados = 1;
    while (true) {
      yield idsGenerados++;
    }
  }
  const gatosId = getId();
  console.log(gatosId.next().value);

ezzz Aunque el profesor no lo haya explicado del todo bien leer la pagina web
https://www.digitalocean.com/community/tutorials/understanding-generators-in-javascript-es
me hizo tenerlo mas claro.

export function* getId() {
  let id = 0;
  while (true) { yield id++ }
}

En este caso usamos la funcion generadora para generar una cantidad de id infinitas pero, segun tengo entendido, esta funcion esta mas orientada a recorrer valores infinitos.

Con la funcion generadora podemos iterar por cada valor cada que se lo indiquemos con next() y gracias a su propiedad de poder pausarse (con yield) no genera problemas con un bucle o recorrido infinito.

Aquí el código con el que pude pasar la prueba:

export function* getId() {
  let newMichi = 0 // Es una variable que sirve para llevar el contro de los nuevos ingresos
  let id = Math.random().toString(36).substring(5).toUpperCase(); // Aquí se genera un número aleatorio alfanumérico
  while (true) {
    yield `${newMichi += 1}${id};` // Aquí concateno mi número de control y los codigos que irán variando para evitar que existan Id´s duplicados
  }
}

const michiId = getId()
console.log(michiId.next().value)

A mi se me ocurrio de esta forma.

Basicamente solo ponemos M y generamos el numero del id parta el michi

export function* getId() {
  let lastId = 1;
  while (true) {
    yield lastId++;
  }
}

Esta fue mi solucion

function hash(number) {
  return `MN${number*Math.random().toFixed(10)}-${number}`
}

export function* getId() {
  let indexPoss = 0, id = 0
  while (true) {
    id++
    yield indexPoss = hash(id)
  }
}

  let i = 1;
  while (true) {
    yield (`Michis${i}`);
    i++;
  }

Aqui esta mi solucion:

export function* getId() {
  let id = 0;
  while (true)
    yield id++;
}

solucion Simple y rapida (podria almacenar los valores dentro de un arry, antes confirmar que el valor no exista usando .some o .every(segun el enfoque) y luego almacenarlo, para asi asegurar que el valor no se repite)

export function* getId() {
  // Tu código aquí 👈
  while (true) {
    yield (parseInt(Math.floor(Math.random() * 1000)))
  }
}

export function* getId(array) {
// Tu código aquí
let i = 0;
for (let value of array){
i++
yield value + i;
}
}
const id = getId([‘cod-’, ‘cod-’, ‘cod-’, ‘cod-’]);
console.log(id.next().value);
console.log(id.next().value);
console.log(id.next().value);

export function* getId() {
  let contID = 0;

  while (true) {
    yield `ID: ${++contID}` // Incrementar antes de devolver el valor.
  }
}

Este es mi aporte a la soluciòn de este problema.
Para el generador use un prefijo con letras para los ids de los michis (‘mid-’), un counter que inicia en 1 y después se construye un string que tiene el prefijo y el counter convertido en string con ceros para completar 5 posiciones, es decir que los ids pueden ir de mid-00001 hasta mid-99999.

export function* getId() {
  // Tu código aquí 👈
  // String prefix
  let id = 'mid-'
  // counter init
  let counter = 1;
  // Generator loop
  while (true) {
    // padStart defines the final lenght and leading character 
    let counterString = counter.toString().padStart(5, "0");
    yield id + counterString;
    counter++;
  }
}

export function* getId() {
  let count = 1;

  while (true) {
    let id = generateIdentifier();
    yield id + count.toString();
    count++;
  }
}

function generateIdentifier() {
  const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
  let result = '';

  for (let i = 0; i < 8; i++) {
    const randomIndex = Math.floor(Math.random() * characters.length);
    result += characters.charAt(randomIndex);
  }

  return result;
}

reto

export function* getId() {
  // Tu código aquí 👈
  let michi = 1
  while (true) {
    michi += 1
    yield michi
  }
}

function* getId() {
  for (let i = 1; i > 0; i++) {
    yield i
  };
};
const id = getId();
id.next().value;

export function* getId() {
  let id = [];
  let i = 0;
  while (true) {
    yield id.push(i++);
  }
}

🦄✨Lo realicé de la siguiente manera:

Aun sabiendo de que es muy poco probable que se generen 2 IDs iguales, de todas maneras agrego una comprobación simple usando el método includes() el cual comprueba si ya existe un elemento en un determinado array 😉

let ids = [];
function* getId() {
  while (true) {
    let idGenerated = [...Array(1)]
      .map(() => (Math.random() + 1).toString(36).substring(2))
      .join("");
    if (!ids.includes(idGenerated)) {
      ids.push(idGenerated);
      yield idGenerated;
    }
  }
}

let generateId = getId();

console.log(generateId.next().value);
console.log(generateId.next().value);
console.log(generateId.next().value);
console.log(generateId.next().value);
//...

Mi solución :

function* generarCadenaAleatoria() {
  const caracteres = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
  while (true) {
    let cadena = '';
    for (let i = 0; i < 7; i++) {
      const indice = Math.floor(Math.random() * caracteres.length);
      cadena += caracteres.charAt(indice);
    }
    yield cadena;
  }
}

// Creas una instancia del generador
const generador = generarCadenaAleatoria();

// Llamas al generador para obtener una cadena aleatoria
const cadenaAleatoria = generador.next().value;
console.log(cadenaAleatoria);

mi solution

function* getId() {
  for (var i = 1; i > 0; i++) {
    yield i;
  }
}

Estoy empezando a ver que los comentarios de que no se estan explicando lo suficientemente bien los diferentes temas del curso es verdad.
En la clase anterior no se aclaro lo de usar una estructura de ciclo para estos generadores.
De todas formas dejo mi respuesta:

export function* getId() {
  while (true) {
    yield Date.now() * (Math.floor(Math.random() * 100))
  }
}

Esta es mi solucion. El unico problema es que no se como hacer para conocer el valor del Symbol que se genera.

export function* getId() {
  // Tu código aquí 👈
  while (true) yield Symbol();
}

Here my solution 😉

export function* getId() {
  let counter = 0
  
  while (true) {
    yield ++counter
  }
}

Mi propuesta 😃

export function* getId() {
  // Tu código aquí 👈
  let id = 1;
  while (true) {
    yield id;
    id++;
  }
}

const id = getId()
console.log(id.next().value);
console.log(id.next().value);
console.log(id.next().value);

const letras = '514a51sdas21621xc1asd351asd0'.split('');

let gatos = {};

function* getId() {
    while (true) {
        const uniqueElements = [];
        
        while (uniqueElements.length < 10) {
            const randomIndex = Math.floor(Math.random() * letras.length);
            const randomElement = letras[randomIndex];
            
            if (!uniqueElements.includes(randomElement)) {
                uniqueElements.push(randomElement);
            }
        }
        
        const newId = uniqueElements.join('');
        const gatoName = `gato${Object.keys(gatos).length + 1}`;

        gatos[gatoName] = newId;

        yield { [gatoName]: newId };
    }
}

const idGenerator = getId();

console.log(idGenerator.next().value);
console.log(idGenerator.next().value);
console.log(idGenerator.next().value);

Una solución rápida jeje

el 30 que puse es solo para no crear un ciclo infinito con un while true

export function* getId() {
  let size = 0;
  while (size < 30) {
    size++;
    yield size;
  }
}

Hola a todos👋! les comparto mi solución, agrega ‘Michi’ antes del id 😻

bueno en mi caso se da que no entiendo por que me costo tanto llegar al resultado.
Es satisfactorio llegar a llograrlo, pero realmente me senti mareado con este ejercicio.
Logre suprerar con este codigo:

<code> 
export function* getId() {
  for (let id = 1; true; id++) {
    yield id;
  }
}
const id = getId();
console.log(id.next().value)

Les comparto mi solución 😃

export function* getId() {
  while (true) {
    yield Math.floor(Math.random() * 100) 
  }
}

Usando while

function* getId() {
while (true) {
let id = Math.round(Math.random()*10000)
yield Cat-${id}/unique_id-${id*345467};
}
}

Usando for

function* getId() {
for (let i = 0; i <= 10; i++) {
let id = Math.round(Math.random()*10000)
yield Cat-${id}/unique_id-${id*345467};
}
}

Solo se pasa la prueba usando while

export function* getId() {
  // Tu código aquí 👈
  do {
    yield crypto.randomUUID().slice(0, 8);
  } while (true)
}

Comparto mi solución usando el objeto crypto para generar ID aleatorios, recortado el resultado para que no sea excesivamente largo

Mi solución:

export function* getId() {
  while (true) {
    yield Math.random() * 100;
  }
}

Mi solucion fue:

export function* getId() {
  for (let i = 1; true; i++) {
    yield i
  }
}

Aunque tambien se puede hacer con un ciclo while

lo logre pero si me costo un poco

export function* getId() {
  // Tu código aquí 👈
  let i = 1;
  while (true) {
    yield i;
    i++;
  }
}

const generator = getId();
console.log(generator.next().value);
console.log(generator.next().value);
console.log(generator.next().value);

Muy minimal mi respuesta

export function* getId() {
  while (true) { 
    yield crypto.randomUUID();
  }
}

export function* getId() {
  for (let num = 0; num > -1; num++) { yield num + 1 }
}

Para un id diferente tenemos crypto.randomUUID() , que es una forma nativa para obtener UUID’s

Sin quemarme las pestañas. XD

function* getId() {
    let i = 0;
    while (true) {
        yield ++i;
    }
}

este curso es una verdadera verguenza, el profesor no explica nada bien. Pesimo

mi aporte:

function* getId() {
    let value = 0;
    while (true) {
        yield value += 1;
    }
}

const id = getId();
    console.log(id.next().value);
    console.log(id.next().value); 
    console.log(id.next().value);

export function* getId() {
  let count = 1; // Inicializar el contador en 1
  while (true) { // Bucle infinito para generar nuevos identificadores
    let id = ''; // Inicializar la cadena del identificador en vacío
    const possibleChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'; // Definir los caracteres posibles para el identificador
    for (let i = 0; i < 7; i++) { // Generar una cadena aleatoria de 7 caracteres
      id += possibleChars.charAt(Math.floor(Math.random() * possibleChars.length));
    }
    yield count.toString().padStart(3, '0') + '-' + id; // Devolver el identificador como una cadena que combina el contador y la cadena aleatoria
    count++; // Incrementar el contador para el siguiente identificador
  }
}

export function* getId() {
  const michis = ['Felix', 'Figaro', 'Gatsby', 'Obelix', 'Negro', 'Hani', 'Loki', 'Aristogato', 'Misifu', 'Cardenal'];
  const randomId = () => Math.random().toString(36).substring(2, 10);
  for (let id = 0; id <= michis.length; id++){
    yield `${michis[id].toLowerCase()}-${randomId()}-${id}`
  }
}

export function* getId() {
  let id = 1;
  while (true) {
    yield id++;
  }
}

Aquí va mi aporte, no se si el for se puede dejar así ( así me funcionó, pero no se que tan buena practica sea esta implementación)

export function* getId() {
  for (let i = 0; ; i++) {
    yield ("Michi " + i);
  }
}

Entiendo esta solución, pero pq el while

function* getId() {
  let idInicial = 0;
  while (true) {
    yield idInicial++
  }
}

function* getId() {
    let lastId = 1
    while (true){
        yield lastId++;
    }
}

const id = getId();
console.log(id.next().value);
console.log(id.next().value);
console.log(id.next().value);

export function* getId() {
    let michiId = 1;
    while (true) {
    yield michiId++;
    }
  }

const michiId = getId()
console.log(michiId.next().value)
console.log(michiId.next().value)
console.log(michiId.next().value)

Despues de intentar muchas veces, esta es mi olucion:

`export function* getId() {
  let valor = 0;
  while (true)
    yield valor++;
}

Comparto mi solucion:D

export function* getId() {
	let charArray = "abcdefghijklmnopqrstuvwxyz0123456789".split("");
	while (true) {
		let str = "";
		for (let i = 0; i < 8; i++) {
			str += charArray[generarNumeroAleatorio()];
		}
		yield str.toUpperCase();
	}
}

function generarNumeroAleatorio() {
	return Math.floor(Math.random() * 36);
}

let result = getId();

console.log(result.next().value);

while (1) , porque mis inicios en programación se remontan a libros viejos para programar en C

export function* getId() {
  // Tu código aquí 👈
  let n = 1;
  while (1) {
    yield n++
  }
}

Hola, así fue como pude resolver el reto:

export function* getId() {
  // Tu código aquí 👈
  let listaIdMichis = [0]
  for (let idMichi of listaIdMichis) {
    idMichi++
    listaMichis.push(idMichi)
    yield idMichi
  }
}

Este generador podría usarse para generar contraseñas de 60 caracteres con mayúsculas, minúsculas, números y símbolos:

function* generateId() {
  while (true) {
    const alphanumeric = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!"·$%&/()=?¿|@#~€¬-+Ǩ`ºª<>[]{}.,;:*/'.split('');
    const shuffledAlphanumeric = alphanumeric.sort(() => Math.random() - 0.83);
    const first60shuffledAlphanumeric = shuffledAlphanumeric.slice(5, 65);

    yield first60shuffledAlphanumeric.join('');
  };
};

El problema debería especificar que no haya un límite para poder seguir agregando id. Estaba creando un array de 3 elementos 😂 y no me salía.

Mi solución.

Un poco más tricky usando clases:

function* getId() {
    let michiId = 1;
    while (true) {
        yield michiId++;
    }
}

class Michi {
    constructor(name, id) {
        this.name = name;
        this.id = id;
    }
    get mId() {
        return this.id.value;
    }
    set mId(id) {
        this.id = id;
    }
}

const michisId = getId();
const garfield = new Michi('garfield', michisId.next());
console.log(garfield.mId)
const bolaDeNieve2 = new Michi('bolaDeNieve', michisId.next());
console.log(bolaDeNieve2.mId)

Tho, no es muy legible.

Este es mi aporte.

export function* getId() {
  // Tu código aquí 👈
  let value = 1;
  while (true) {
    yield "mich#" + value++;
  }
}

Mi solución:

export function* getId() {
  // Tu código aquí 👈
  let id = 1;
  while (true) {
    id++;
    yield id;
  }
}

const id = getId();
id.next().value
id.next().value
id.next().value

Mi solución:

export function* getId() {
  let value = 0
  while (true) { yield value++ }
}

export function* getId() {
  // Tu código aquí 👈
  while (true) {
    yield Math.floor(Math.random()*10000);
  }
}

export function* getId() {
  // Tu código aquí 👈
  while (true) {
    yield Math.random().toString(36).substring(6);
  }
}
const id = getId()
id.next().value;
id.next().value;
id.next().value;

export function* getId() {
  // Tu código aquí 👈
  let numero = 0;

  while (true) {
    yield numero++;
  }

}

Aquí mi manera de resolverlo

export function* getId() {
  let michis = 1;
  while (true) {
    yield michis++;
  }
  const michilangos = getId()
  return michilangos.next().value;
}

export function* getId() {
  let i = 0;
  while (true) {
    yield i++;
  }
}

export function* getId(array) {
for (let value of array) {
yield value
}
}

const id = getId([‘michi1’, ‘michi2’, ‘michi3’]);
console.log(id.next().value);
console.log(id.next().value);
console.log(id.next().value);

este es mi aporte

🍃 Esta es mi solución, usando “MICHI” como valor inicial para cada ID.

function* getId() {
  // Creamos un string con todos los caracteres posibles para la ID
  let alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ012345679";
  
  // Creamos una función que genera un número aleatorio en base a la longitud del string 'alphabet'
  let randomCaracter = () => Math.floor(Math.random() * alphabet.length);
  
  // Creamos un string con el valor inicial de la ID
  let id = "MICHI";
  
  // Generamos una ID con 8 caracteres aleatorios y la devolvemos con 'yield'
  for (let index = 0; index < 8; index++) {
    id += alphabet[randomCaracter()];
  }
  yield id;
  
  // Llamamos a la función generadora de forma recursiva para generar una nueva ID
  yield* getId();
}

// Creamos un iterador con la función generadora
const id = getId();

// Llamamos a 'next()' para obtener la primera ID
console.log(id.next().value);

// Llamamos a 'next()' varias veces para obtener IDs adicionales
console.log(id.next().value);
console.log(id.next().value);
console.log(id.next().value);

Investigué e hice un generador de contraseñas super seguras y nice 8)

function* getId() {
    var chars = "0123456789abcdefghijklmnopqrstuvwxyz!@#$%^&*()ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    var passwordLength = 20;
    var password = "";

while(true){
 for (var i = 0; i <= passwordLength; i++) {
   var randomNumber = Math.floor(Math.random() * chars.length);
   password += chars.substring(randomNumber, randomNumber +1);
  }

  yield password
  password=""
}

}

const id=getId()  
console.log(id.next().value)
console.log(id.next().value)
console.log(id.next().value)
console.log(id.next().value)
console.log(id.next().value)

Mi aporte, decidi usar la instancia de Set, ya que no admite elementos repetidos, en vez de un array.

function* getId() {
  // Tu código aquí 👈
  let newMichi = 0
  while (true) {
    //Creamos una instancia de set que no admite elementos repetidos
    const setOfRandoms = new Set()

    //Creamos el id
    const id = Math.random().toString(36).substring(5).toUpperCase();

    //Agregamos el nuevo Id al set de Ids
    setOfRandoms.add(id)

    //Iteramos el set
    for (let value of setOfRandoms) {
      //Devolvemos un id unico personalizado
      yield `mi${newMichi++}${value}`
    }
  }
}

Esta fue mi solucion

export function* getId(array) {
  for (let value of array) {
    yield value;
  }
}

const id = getId(['Pedro', 'Juan', 'Alonso', 'Negro', 'Pato']);
console.log(id.next().value);
console.log(id.next().value);
console.log(id.next().value);
console.log(id.next().value);
console.log(id.next().value);

export function* getId() {
  // Tu código aquí 👈
  while (true) {
    yield Math.random().toString(26).substring(5).toUpperCase();
  }
}```

Mi solucion:

export function* getId() {
  const identifiers = [];
  while (true) {
    // i > 0 no sera un ciclo infinito debido a que se iterara cada ciclo al ejecutar el metodo next()
    for (let i = 1; i > 0; i++) {
      let identify = identifiers.push(i);
      yield identify;
    }
  }
}

quiero compartir con ustedes una referencia
sobre cómo generar IDs únicos y aleatorios en la vida real

export function* getId() {
  // Tu código aquí 👈
  for (let i = 1; i <Infinity; i++) {
    yield i;
  }
}

export function* getId(array) {

    for (let value of array) {
        yield value;
    }
}

const michiArray = (['MIchi Negro', 'Michi Blanco', 'Michi Naranja', 'Michi negro con manchas naranjas']);

const id = getId(michisArray);
    id.next().value

Al parecer la sintaxis se ha actualizado, al querer hacerlo con un ciclo “for” me marca error, ahora se tiene que declarar una variable con un valor inicial y eventualmente, a traves de un “while” ir incrementando la iteración.

<export function* getId() {
let nombreDeVariable = valor inicial
while (validación)
yield nombreDeVariable++ //así se aumenta la iteración
}

const nombreDeConst = Función([argumentos])
nombreDeConst.next().nombreDeVariable
nombreDeConst.next().nombreDeVariable
nombreDeConst.next().nombreDeVariable> 

Parece dificil, las instrucciones me parecen un poco complicadas, pero en realidad son ejercicios sencillos.

export function* getId() {
  let id = 0 
  while (true) {
    yield id;
    id+=1
  }
}

Generator no puede ser un () => {}, pero se puede modernizar a ECMA parcialmente. Agregado el .done.

export const getId = function* () {
    let id;
    for (let michiNum = 1; michiNum <= 10; michiNum++) {
        yield id = `Michi-n#${michiNum}`;
    };
};
const id = getId();
console.log(id.next().value); // x10 times C&P
console.log(id.next().done); // true