Objects: Función constructora

function auto (MARCA, MODELO, ANNIO){
  this.marca = MARCA;
  this.modelo = MODELO;
  this.annio = ANNIO;
}
var autos = [];
for(let i = 0 ; i < 30 ; i++){
  var marca = prompt("Ingresa la marca del auto");
  var modelo = prompt("Ingresa el modelo del auto");
  var annio = prompt("Ingresa el año del auto");
  autos.push(new auto (marca, modelo, annio));
}

for(let i = 0 ; i < autos.length ; i++){
  console.log(autos[i]);
}

Mi solución al ejercicio.

Esta clase no me gusto y aunque la entendi creo que hace falta explicar muchas cosas como por ejemplo nunca explico como agregar una propiedad cuando el objeto ya se habia declarado he inilicializado, dos cosas. hasta este punto si quieren entender con claridad los objetos recomiendo un monton que tomen el curso basico de freecodecamp.org alli explican y colocan ejercecicios con lo aprendido en clases previas para resolverlo y lo otro es leer https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/new

Aqui el mio.

var marca = [
    "Abarth",
    "Alfa Romeo",
    "Aston Martin",
    "Audi",
    "Bentley",
    "BMW",	
   "Cadillac",
    "Caterham",
    "Chevrolet",
    "Citroen",
    "Dacia",
    "Ferrari",
    "Fiat",
    "Ford",
    "Honda",
    "Infiniti",
    "Isuzu",
    "Iveco",
    "Jaguar"   	 	 
]

var modelo = [
    "C-Max",
    "Fiesta",
    "Focus",
    "Mondeo",
    "Ka",
    "S-MA",
   " B-MAX",
    "Grand C-Max",
    "Tourneo Custom",
    "Kuga",
    "Galaxy",
    "Grand Tourneo Connect",
    "Tourneo Connect",
    "EcoSport",
    "Tourneo Courier",
    "Mustang",
    "Transit Connect",
    "Edge",
    "Ka+"
]

var anio = [
    "1988",
    "1989",
    "1978",
    "1989",
    "1928",
    "1989",
    "1968",
    "1989",
    "1888",
    "1989",
    "1288",
    "1989",
    "1938",
    "1989",
    "1988",
    "1999",
    "1983",
    "1989",
    "1918"
]




function auto(marca, modelo, anio){
    this.marca = marca;
    this.modelo = modelo;
    this.anio = anio}

for(var i = 0; marca.length > i && modelo.length > i && anio.length > i; i++){
    var nuevoAuto = new auto(marca[i], modelo[i], anio[i]);
    console.log(nuevoAuto)
}

Demo: https://daniektj.github.io/Reto-con-Objects-y-Funcion-constructora/

Repositorio: https://github.com/daniektj/Reto-con-Objects-y-Funcion-constructora

Me costo mucho llegar al resultado que quería, pero al final lo logre, pensé que lo haría en 1 hora y me tomo mas de 5 porque no lograba imprimir en modalidad tabla.

No se queden solo con la información del video, usen Google para leer un poco mas sobre las propiedades de cada nuevo codigo que nos muestran.

Creo que no basta explicar un solo ejercicio que està en Developer Mozilla, seria bueno explicar varios y con diferentes grados de complejidad…

//RETO

//Paso 1: Creamos una lista vacía de autos
var listaAutos = [];

//Paso 2: Creamos la función constructora
function auto(marca, modelo, anio){
    this.marca = marca;
    this.modelo = modelo;
    this.anio = anio;
};

//Paso 3: Creamos una función que agregue un auto nuevo a la lista
function agregarAuto(marca, modelo, anio){
    var nuevoAuto = new auto(marca, modelo, anio);
    listaAutos.push(nuevoAuto);
};

//Paso 4: Creamos una función para que el usuario agregue un nuevo carro con sus parámetros
function registrarAutoNuevo(){
    var marca = prompt("Ingresa la marca: ");
    var modelo = prompt("Ingresa el modelo: ");
    var anio = prompt("Ingresa el año: ");
    agregarAuto(marca, modelo, anio);
    console.log("¡Agregaste tu nuevo carro con éxito!");
};

//Paso 5: Mostramos el arreglo actualizado
listaAutos;

El que yo hice es de lo mas sencillo y fue la unica manera que se me ocurrio, este curso es lo unico que conozco de Js (o de programacion en si , no me juzguen xD).
Me encantan y sorprenden los aportes de otros compañeros, se ven increiblemente avanzados.

var autos = [];

function auto(marca, modelo, color) {
  this.marca = marca;
  this.modelo = modelo; 
  this.color = color; 
}

for (var i = 0; i < 10; i++ ) {
  var autoNuevo = new auto ("Tesla", "Model S",  "Blue" )
  var agregarAuto = autos.push(autoNuevo);
}
console.log(autos);

1:36 Coyota Torolla!

function autos(marca, modelo, annio){
    this.marca = marca;
    this.modelo = modelo;
    this.annio = annio;
}
var marcaArray = ["TESLA", "NISSAN", "TOYOTA", "HONDA"];
var modeloArray = ["2020", "MODEL X", "COVID19"];
var annioArray = [2018, 2019, 2020];
for(var i=0; i<=30; i++){
    var random0 = Math.floor(Math.random() * marcaArray.length);
    var marca = marcaArray[random0];
    var random1 = Math.floor(Math.random() * modeloArray.length);
    var modelo = modeloArray[random1];
    var random2 = Math.floor(Math.random() * annioArray.length);
    var annio = annioArray[random2];
    var autoNuevo = new autos(marca, modelo, annio);
    console.log(autoNuevo);
}

YEP

var car_list = [];

class Car {
    constructor(brand, model, year) {
        this.brand = brand;
        this.model = model;
        this.year = year
    }
}

function make_anew_car() {
    cars = parseInt(prompt("How much cars do you want? type a number."))

    if (typeof cars === "number"){
        for (var i = 0; i < cars; i++){
            brand = prompt("Type the car brand here");
            model = prompt("Type the car model");
            year = parseInt(prompt("Type the year in which the car came out"));
            car_list.push(new Car (brand, model, year));
        }
    }else{
        alert("C'mon brother type a number please");
    }
}

make_anew_car();
console.log(car_list);

Resumen

Función Constructora

Hay ocaciones en las que vamos a necesitar generar varios objetos y hacerlo manualmente no es la mejor forma de trabajar. Esto se puede automatizar de una simple manera utilizando la función Constructor.

Una función Constructora es un “template” o estructura pre-armada de un objeto con sus propiedades preparados para asignarles un valor.

Vamos a utilizar el mismo concepto que la clase anterior pero vamos a crear el “template”.

Para eso vamos a declarar una función llamada auto() donde vamos a declarar los parámetros que vamos a utilizar, como la marca, modelo y el año.

Vamos a utilizar la palabra clave this que aprendimos en la clase anterior para llamar haciendo referencia a la función auto() seguido del parámetro (que va a ser nuestra propiedad) separado por un punto y se le va a asignar el parámetro de la función para que cada vez que se agregue un nuevo valor se le asigne a esa propiedad.

Así se escribe:

>function auto(marca, modelo, año) {
	this.marca = marca;
	this.modelo = modelo;
	this.año = año;
}

De modo que si llamamos a la función auto() nos va a devolver el objeto.

>auto()
<f auto(marca, modelo, año) {
	this.marca = marca;
	this.modelo = modelo;
	this.año = año;
}

Ahora vamos a ver como agregar un nuevo auto a nuestro “template”.

Vamos a declarar una nueva variable llamada autoNuevo y vamos a asignarle un operador llamado new. Esto va a generar una nueva instancia en nuestra función constructora. (Una instancia es un objeto que deriva de otro objeto). A continuación llamamos la función auto() con las propiedades del auto nuevo en los parámetros de la función.

Así se escribe:

>var autoNuevo = new auto("Tesla", "Model 3" 2020);

De modo que si llamamos a esta nueva variable nos devuelve:

>autoNuevo
<auto {marca: "Tesla", modelo "Model 3", año: 2020}

Si generamos otros autos repetimos el proceso declarando una nueva variable.

>var autoNuevo2 = new auto("Tesla", "Model X", 2018);
>var autoNuevo3 = new auto("Toyota", "Corolla", 2020);

Al llamarlas nos va a devolver:

>autoNuevo2
<auto {marca: "Tesla", modelo "Model X", año: 2018}
>autoNuevo3
<auto {marca: "Toyota", modelo "Corolla", año: 2020}

Se que no es un gran aporte, pero bueno, tengan cuidado en crear loops infinitos xD casi se funde el Chrome JAJAJAJAJAJJA, bueno. #happycode

Mi aporte

<//Creamos la función autos que nos permite registar cada auto
function newAutos(marca, modelo, anno) {
    this.marca = marca;
    this.modelo = modelo;
    this.anno = anno    
}

//Variables a usar
var  Autos = [];
let  recordAuto = 0;


//Preguntamos el numero de autos a ingresar por parte del cliente
let numberAuto = prompt("Cuantos autos quieres ingresar");


//Generamos el loop para ingresar los autos deseados

while (numberAuto > recordAuto) {
    let marca = prompt("Marca: ");
    let modelo =  prompt("Modelo :");
    let anno = prompt("Anno: ")

// Empezamos a guardar la informacióin en la funcion global Autos
var newAuto = new newAutos(marca, modelo, anno);

// Agrego cada auto al final del array
Autos.push(newAuto);

//Contador de autos registrados
recordAuto++;

}

console.log(Autos);>

Conseguí hacer el reto de manera completamente automatizada.

// 1)Creamos la función constructora.
function auto(marca, modelo, annio, color){
    
    this.marca = marca,
    this.modelo = modelo,
    this.annio = annio,
    this.color = color

};


// 2)Ahora generamos arrays con los datos necesarios de: Marca, Modelo, Año, Color. Además de un array que almacene los objetos nuevos.
var marcaAuto = ['Toyota', 'Tesla', 'Audi', 'Renault', 'Volkswagen', 'BMW'];
var modeloAuto = ['Z', 'X', 'Y', 'W', 'V', 'H'];
var annioAuto = [2020, 2018, 2017, 2019, 2021];
var colorAuto = ['Negro', 'Rojo', 'Plateado', 'Blanco'];
var listaAutos = [];


// 3)Creamos una iteración que añada 30 nuevos objetos a nuestro array 'listaAutos[]'
//   Además de asignar parametros aleatorios a cada registro nuevo.
//   Y por último imprimimos el resultado en consola. 
for (i = 0; i < 30; i++){

    var marca = marcaAuto[Math.floor(Math.random() * marcaAuto.length)];
    var modelo = modeloAuto[Math.floor(Math.random() * modeloAuto.length)];
    var annio = annioAuto[Math.floor(Math.random() * annioAuto.length)];
    var color = colorAuto[Math.floor(Math.random() * colorAuto.length)];

    listaAutos.push(new auto(marca, modelo, annio, color));
    console.log(listaAutos[i]);

};```

Vi que muchos utilizaron arrays pero yo no lo creí necesario por los momentos, igual se aceptan sugerencias!

//Declaramos nuestra función constructora
function car (brand, model, year) {
    this.brand = brand;
    this.model = model;
    this.year = year;
}

//Establecemos funciones expresivas para que nos den un valor aleatorio de marca y año
var model = function() {
    return  Math.floor(Math.random()* (9 + 1 - 1) + 1);
}

var year = function(min, max) {
   
    return  Math.floor(Math.random()* (2018 - 2006) + 2006);
}

//Este ciclo generará la instancia newCar 30 veces con propiedades aleatorias de modelo y año por cada iteración
for (i = 0; i < 30; i++) {
    newCar = new car ("Audi", "A" + model(), year());
    console.log(newCar);
}```

Consideren una fabrica que con base a una orden de fabricacion se pueda hacer cualquier tipo de automovil? Pues aca esta mi propuesta:

Y por supuesto aca esta su codigo:

function orderCreation(marca, modelo, annio, cantidad){
    this.marca = marca;
    this.modelo = modelo;
    this.annio = annio;
    this.cantidad = cantidad;
}

function automovil(marca, modelo, annio, serie){
    this.marca = marca;
    this.modelo = modelo;
    this.annio = annio;
    this.serie = serie;
}

var crearAutomoviles = function(order){
    var autoList = [];

    for(var i = 0; i < order.cantidad; i++){
        autoList.push(new automovil(order.marca, order.modelo, order.annio, Math.random()));
    }

    return autoList;
}

var order = new orderCreation("Susuki","Swift","2021",30);

var automovilesLst = crearAutomoviles(order)

for(var auto of automovilesLst){
    console.log(`Marca: ${auto.marca}, Modelo: ${auto.modelo}, Annio: ${auto.annio} Serie: ${auto.serie}`);
}

El reto!!!

function carrosNuevos(marca, modelo, color){
    this.marca = marca;
    this.modelo = modelo;
    this.color = color;
}

var marcas = ["BMW", "Volvo", "Saab", "Ford", "Fiat", "Audi", "Renault","Mazda","kya","Chevrolet"];

var modelos = ["serie", "serie1", "serie2", "serie3", "serie4", "serie5","serie6", "serie7", "serie8", "serie9", "serie10"];

var colores = ["rojo", "verde", "amarillo", "naranja", "negro", "morado","azul", "rosado", "blanco", "gris"];

for (i = 0; i < marcas.length && i<modelos.length && i<colores.length; i++) {
    var carros= new carrosNuevos(marcas[i], modelos[i], colores[i]);  
    console.log(carros);   
}

Les comparto mi solución- Creo un Array vacío y por medio de una función agrego más Items.

Al final me di cuenta que no necesite usar ningún ciclo. Voy a intentar una segunda solución usando algún ciclo.

// CONSTRUCTOR
function grupo(nombre, genero, annio) {
    this.nombre = nombre;
    this.genero = genero;
    this.annio = annio;
}

//Guardo los grupos que se van generando
const nuevosGrupos = [];

//Se generan los nuevos grupos y se agregan al Array
function agregarGrupo(nom, gen, ann) {
    let nuevoGrupo = new grupo(nom, gen, ann);
    nuevosGrupos.push(nuevoGrupo);
}

//Aquí es donde agrego los grupos nuevos
agregarGrupo("Anathema", "Post Rock", 1990);
agregarGrupo("Tool", "Metal Progresivo", 1999);
agregarGrupo("Cult of Luna", "Sludge Metal", 1998);
agregarGrupo("Pixies", "Rock Alternativo", 1986);
agregarGrupo("Intronaut", "Metal Progresivo", 1994);
agregarGrupo("Opeth", "Death Metal Progresivo", 1991);

//LLamo en Consola a los grupos generados
console.table(nuevosGrupos);```

Platzicoders, les comparto mis notas:
.

.
Espero que les sea de utilidad.
(⌐■_■)

function Auto (nombre, marca, fecha) {
  this.nombre = nombre;
  this.marca = marca;
  this.fecha = fecha;
}

var modelos = ["C-Max","Fiesta", "Focus", "Mondeo", "Ka", "S-MA", "B-MAX", "Grand C-Max", "Tourneo Custom","Kuga", "Galaxy", "Grand Tourneo Connect", "Tourneo Connect", "EcoSport", "Tourneo Courier", "Mustang", "Transit", "Edge", "Ka+","Fiesta", "Focus", "Mondeo", "Ka", "S-MA", "B-MAX", "Grand C-Max", "Tourneo Custom","Kuga", "Galaxy", "Grand Tourneo Connect"];

var marcas = ["Abarth", "Alfa Romeo", "Aston Martin", "Audi", "Bentley", "BMW", "Cadillac", "Caterham", "Chevrolet", "Citroen", "Dacia", "Ferrari", "Fiat", "Ford", "Honda", "Infiniti", "Isuzu", "Iveco", "Jaguar", "Alfa Romeo", "Aston Martin", "Audi", "Bentley", "BMW", "Cadillac", "Caterham", "Chevrolet", "Citroen", "Dacia", "Ferrari"];

var fechas = ["1988", "1989", "1978", "1989", "1928", "1989", "1968", "1989", "1888", "1989", "1288", "1989", "1938", "1989", "1988", "1999", "1983", "1989", "1918", "1989", "1978", "1989", "1928", "1989", "1968", "1989", "1888", "1989", "1288", "1989"];

for (i = 0; i < 30; i++) {
  var autos = new Auto(modelos[i], marcas[i], fechas[i]);
  console.log(`- ${autos.nombre} ${autos.marca} ${autos.fecha}`);
}

Actualmente, para la creación de objetos, se utiliza la siguiente sintaxis.

Les comparto mis anotaciones

🐱‍💻 Lista de automóviles, utilizando un ciclo.

function auto(marca, modelo, annio) {
    this.marca = marca;
    this.modelo = modelo;
    this.annio = annio;
}

var listaConstruida = [];
var conteo = 0

var cantidadAutos = parseInt(prompt("Agregar cantidad de autos"));

while (conteo < cantidadAutos) {
    var marca = prompt("Ingrese la marca");
    var modelo = prompt("Ingrese el modelo");
    var annio = parseInt(prompt("Ingrese el año"));
    
    var newCar = new auto(marca, modelo, annio);
    conteo++
    listaConstruida.push(newCar);
}

Soy apasionado de las motos 😃

let propiedadMarca,  
    propiedadModelo, 
    propiedadAnnio;
    
let motos = []; 

let cantAgregar = parseInt(prompt("Ingresa cantidad de motos que vas agregar al inventario."));


function moto(marca, modelo, annio){
    this.marca = marca;
    this.modelo = modelo;
    this.annio = annio;
}

function agregarMoto(){
    propiedadMarca = prompt("Ingresa la marca de la moto").toUpperCase();
    prpiedadModelo = prompt("Ingresa el modelo de la moto").toUpperCase();
    propiedadAnnio = parseInt(prompt ("Ingresa el año de la moto"));
}

for(let index = 0; index <= cantAgregar; index++){
    agregarMoto();
    nuevaMoto = new moto(propiedadMarca, propiedadModelo, propiedadAnnio);
    motos.push(nuevaMoto);
}

console.log(motos);

Esto Aprendí de esta maravillosa clase 😄

/*
    Una función constructora permite hacer instancias de un objeto.
    Es decir... Crear un objeto a partir del Template o Estructura de otro.
    Para hacer esta instrancia se usa la palabra reservada new y la siguiente estructura:
    var nuevaInstancia = new nombreConstructora(){}
*/

// Creando Función Cosntructora.

// El .this hace referencia a la función constructora.

var fruta = function(nombre, tamaño, precio, calidad){
    this.nombre = nombre;
    this.tamaño = tamaño;
    this.precio = precio;
    this.calidad = calidad;
}

var nuevaFruta = new fruta("Platano", "Mediano", "3 pesos", "Excelente");
var nuevaFruta2 = new fruta("Manzana", "Chico", "2 pesos", "Regular");
var nuevaFruta3 = new fruta("Cereza", "Pequeño", ".50 pesos", "Buena");
var nuevaFruta4 = new fruta("Mango", "Chico", "2 Pesos", "Regular");

Salida Obtenida

Por acá dejo mi versión del ejercicio. Yo hice uso del concepto class (clase) para que el codigo se parezca un poco más al estilo de programación orientada a objetos.

const Car = class {

  constructor(brand, model, year) {
    this.brand = brand;
    this.model = model;
    this.year = year;
  }
  details() {
    console.log(`DETAILS:\n ${this.brand} Model ${this.model} Year ${this.year}`);
  }

};

const carAry = new Array(
  ["Tesla", "S", 2012],
  ["Tesla", "3", 2017],
  ["Tesla", "X", 2015],
  ["Tesla", "Y", 2020]
);

carAry.forEach((car) => {
  const tesla = new Car(car[0], car[1], car[2]);
  tesla.details();
});

function car(brand, model, year) {
    this.brand = brand;
    this.model = model;
    this.year = year;
}
var brand_array = ["Tesla", "Lamborghini", "Ford", "Chevrolet", "Hyundai", "Tesla", "Audi"];
var model_array = ["Model S", "Aventador SVJ", "Explorer", "Optra", "Tucson", "Model 3", "R8"];
var year_array = [2020, 2018, 2019, 2010, 2008, 2020, 2018];

for(var i = 0; brand_array.length > i; i++){
    var new_car = new car(brand_array[i], model_array[i], year_array[i]);
    console.log(new_car);
}```

Acá dejo el reto.

Genera Aleatoriamente 30 Coches de colores marcas y años distintos.

for (var i = 0; i < 30; i++) {

var coche = function coche(marca, annio, color) {
    this.marca = marca;
    this.annio = annio;
    this.color = color;
}

function crearCoche(marca, annio, color) {
    var autoNuevo = new coche(marca, annio, color);
    console.log(autoNuevo);
}

var aleatorio = Math.random()
    if (aleatorio < 0.25) {
        var posicionMarcas = 0
    }else if (aleatorio < 0.5) {
        var posicionMarcas = 1
    }else if (aleatorio < 0.75) {
        var posicionMarcas = 2
    }else {
    var posicionMarcas = 3
    }

var aleatorio = Math.random()
    if (aleatorio < 0.25) {
        var posicionColores = 0
    }else if (aleatorio < 0.5) {
        var posicionColores = 1
    }else if (aleatorio < 0.75) {
        var posicionColores = 2
    }else {
    var posicionColores = 3
    }

var aleatorio = Math.random()
    if (aleatorio < 0.25) {
        var annioPatente = 2017
    }else if (aleatorio < 0.5) {
        var annioPatente = 2018
    }else if (aleatorio < 0.75) {
        var annioPatente = 2019
    }else {
    var annioPatente = 2020
    }


var marcasCoches = ["Ford", "Tesla", "Renault", "Toyota"]

var coloresCoches = ["Rojo", "Verde", "Amarillo", "Negro"]


    crearCoche(marcasCoches[posicionMarcas], coloresCoches[posicionColores], annioPatente);
}

Una solución:

function auto(marca, modelo, annio){
    var marca = ['BMW', 'Audi', 'Lexus', 'Toyota', 'Mazda'];
    var modelo = ['Model X', 'Model Y', 'Model Z'];
    var annio = ['2020', '2019', '2018'];
    this.marca = marca[(Math.floor(Math.random() * 4))];
    this.modelo = modelo[(Math.floor(Math.random() * 2))];
    this.annio = annio[(Math.floor(Math.random() * 2))];  
    
}
for(i = 0; i < 30; i++) {
        
    var nuevoAuto = new auto();
    console.log(nuevoAuto)
}

//Arreglos
var Brands = ["Tesla", "Fiat", "Nissan", "Honda"];
var Years = [2020, 2019, 2018, 2017];

//Creacion de una funcion constructora
function Auto(brand, year)
{
    this.brand = brand;
    this.year = year;
}

//Arreglo que guardar los autos
var nuevosAutos = [];

//Llenado de autos
for(var i = 0; i < 30; i++)
{
    var random = Math.floor(Math.random() * 4);
    nuevosAutos.push(new Auto(Brands[random], Years[random]));
}

//Imprimir autos
for(var autos of nuevosAutos)
{
    console.log(autos);
}

function auto (marca, modelo, annio){
    this.marca = marca;
    this.modelo = modelo;
    this.annio = annio;
}
var marca = ["Nissan","Nissan","Nissan","Nissan","Nissan","Nissan","Nissan","Nissan","Nissan","Nissan",
"Ford","Ford","Ford","Ford","Ford","Ford","Ford","Ford","Ford","Ford", 
"Chevrolet","Chevrolet","Chevrolet","Chevrolet","Chevrolet","Chevrolet","Chevrolet","Chevrolet","Chevrolet","Chevrolet"];
var modelo = ["versa", "tida", "altima", "maxima", "sentra", "march","versa" , "altima", "maxima","march",
"mustang", "figo", "fiesta", "fusion","mustang", "figo", "fiesta", "fusion","espape", "edge",
"beat", "aveo", "spark", "onix", "cavalier", "camaro", "corvette", "beat", "aveo","onix"];
var annio = [1999,2000,2004,2020,2019,2014,2012,2006,2020,2005,
    1999,2000,2004,2020,2019,2014,2012,2006,2020,2005,
    1999,2000,2004,2020,2019,2014,2012,2006,2020,2005];



for (var i = 0; i < marca.length; i++) {
    var autoNuevo = new auto (marca, modelo, annio);
    autoNuevo.marca = marca[i]
    autoNuevo.modelo = modelo[i]
    autoNuevo.annio = annio[i]
    console.log(autoNuevo)
}```

function auto(marca, modelo, annio) {
  this.marca = marca;
  this.modelo = modelo;
  this.annio = annio;
}
const autosGenerados = []

const plantillaAutos = [
  {
    marca: 'Tesla',
    modelo: 'Model 1',
    annio: 2020
  },
  {
    marca: 'Tesla',
    modelo: 'Model 2',
    annio: 2020
  },
  {
    marca: 'Tesla',
    modelo: 'Model 3',
    annio: 2020
  },
  {
    marca: 'Tesla',
    modelo: 'Model 4',
    annio: 2020
  },
  {
    marca: 'Tesla',
    modelo: 'Model 5',
    annio: 2020
  },
  {
    marca: 'Tesla',
    modelo: 'Model 6',
    annio: 2020
  }
]

while(plantillaAutos.length > 0) {
  var autoObtenido = plantillaAutos.shift();
  const { marca, modelo, annio } = autoObtenido;
  const newAuto = new auto(marca, modelo, annio);
  autosGenerados.push(newAuto);
}

Alguien sabe como desde el mismo bucle, cada vez que se itere cambie el nombre del objeto? Es decir autoNuevo1, autoNuevo2, y así.

Reto Cumplido

// Función Constructora
function auto(marca, modelo, annio) {
  this.marca = marca;
  this.modelo = modelo;
  this.annio = annio;
}

//Declaración de Variables en Arrays
var marcaArray = ["Toyota", "Mitsubishi", "Subaru", "Tesla", "Honda"];
var modeloArray = ["Corrola", "Lancer", "ModelX", "skyline", "Civic"];
var annio = 1990;

// LOOP
for (var i = 0; i <= 30; i++) {
  //Funciones Math escogen de manera aleatoria los valores de los arrays.
  var ramdon = Math.floor(Math.random() * marcaArray.length);
  var marca = marcaArray[ramdon];
  var ramdon2 = Math.floor(Math.random() * modeloArray.length);
  var modelo = modeloArray[ramdon2];
  // Insstancia del Objeto
  var autoNuevo = new auto(marca, modelo, annio);
  // Incremento de la Variable año y impresión del objeto.
  annio++;
  console.log(autoNuevo);
}

Decalaramos las variables globalas

var marca = marca;	
var modelo = modelo;
var annio = annio;

Creamos un array que va ser la base de datos de todos nuestros coches

var lista = [];

El operador new sirve para generar una nueva instancia,de nuestra función constructora, una instancia es generar un objeto que deriva de otro objeto.

Acá el operador new esta referido a la funcion constructora, y como se esta llamando a una funcion hay que asignarle las propiedades que querramos que tenga en este caso hace referencia a los valores que le dará el ciclo.

var autoNuevo = new auto(marca,modelo,annio);

Acá estamos creando un ciclo FOR donde si se cumple la condicion de que i < 30 (Nuestra lista total de coches) añadirá una nueva entrada al array con el “lista.unshift(autoNuevo);” inicia en “lista” porque es el nombre del array, el “.unshift(autoNuevo);” es el metodo para añadir al inicio una entrada en el array, y el (autoNuevo);es el elemento que vamos a agregar que a su vez hace referencia a la funcion generadora.

for(i = 0; i < 30; i++){
 lista.unshift(autoNuevo);
 lista.marca = prompt("Inserte la marca del auto");
 lista.modelo = prompt("Introduzca el Modelo del Coche");
 lista.annio = prompt("Meta el año del carro")
}

lista.marca = prompt(“Inserte la marca del auto”);

Esto funciona así: lista es el array que estamos llamando, . marca es la propiedad del objeto que estamos creando, y prompt funciona para crear una entrada por parte del usuario, debe invocarse siempre el nombre del array y la propiedad del objeto que se esta defininendo en ese momento.

Esta es una funcion creadora y tiene como parametros las propiedades que queremos colocar en el objeto.

// this.marca = marca;

this hace referencia a la propia funcion creadora “auto”,
this.marca = marca; “marca=marca” hace referencia al atributo de la funcion constructora, esto es para que cuando asignemos un valor al a propiedar marca en la funcion el objeto que se cree remplace la segunda marca “la que esta despues del signo =”

Recuerda que marca esta dentro de la función auto, que es invocada por la variable autoNuevo, ahí es donde se crean los autos, pero donde modificamos a marca es en el el array (que es invocado por autonuevo), allí le pedimos al usuario con un prompt que inserte la marca

function auto(marca,modelo,annio){
 this.marca = marca;
 this.modelo = modelo;
 this.annio = annio;
}



console.log(lista);

Hola, busqué en internet como llamar elementos de manera aleatoria de un array y lo implementé en la respuesta al reto!!! espero les sea de ayuda…

<code> 
var marcas = ["Jeep", "Toyota", "Chevrolet", "Subaru", "Porch", "Nissan"];
var modelos = [2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022];
var color = ["Amarillo", "Negro", "Gris", "Rojo", "Azul", "Rosa"];
var numPuertas = [2, 4, 6];
var cars = [];

function Car (marca, modelo, color, puertas) {
    this.marca = marca;
    this.modelo = modelo;
    this.color = color;
    this.puertas = puertas;
}

for (let i = 0; i < 30; i++){
    (cars.push(new Car(marcas[Math.floor(Math.random()*marcas.length)], modelos[Math.floor(Math.random()*modelos.length)], color[Math.floor(Math.random()*color.length)], numPuertas[Math.floor(Math.random()*numPuertas.length)],)))
}

console.log(cars);

Me parece importante que el profesor muestre la solución a los retos ya que aunque los alumnos pueden publicar el código puede prestarse para confusiones ya que en teoria la mayoria estamos empezando de cero y probablemente comentamos errores que nos dejen aún más confundidos.

Definición de instancia
Se llama instancia a todo objeto que derive de algún otro

Ejemplo práctico:
Tomando como ejemplo a platzi, se genera una función constructora llamada estudiantes

function estudiantes (nombre, correo, nacimiento, pais) {
	this.nombre = nombre;
	this.correo = correo;
	this.nacimiento = nacimiento;
	this.pais = pais;
}

Una vez creada la función constructora solo queda automatizarla, los datos que nosotros ingresamos en el registro se van a una base de datos y quedan guardados como un objeto, nuestros perfiles, entonces nuestros perfiles son el objeto derivado del objeto estudiantes, entonces cada una de nuestras cuentas de platzi es una instancia del objeto estudiantes 🤯🤯

Aquí está el mío! Me costó menos tiempo de lo que pensé 😆
Al principio me arrojaba error porque la consola me indica que el “car” no era una función constructora, investigué un poco y resulta que fue porque debe estar en mayuscula.

var brand = ["Audi", "Toyota", "Mazda", "Skoda", "Kia"];
var model = ["Model 1", "Model 2", "Model 3", "Model 4", "Model 5"];
var year = [2017, 2016, 2018, 2019, 2015];

function Car(brand, model, year){
  this.brand = brand;
  this.model = model;
  this.year = year;
}

for (var i = 0; i < brand.length; i++){
  var car = new Car(brand[i], model[i], year[i]);
  console.log(car)
}

<!DOCTYPE html>
<html lang="es" dir="ltr">
  <head>
    <meta charset="utf-8">
    <title>Función constructora</title>
  </head>
  <body>

    <h1>Vamos a crear una funció contrustora</h1>

    <button type="button" name="button" onclick="displayCars()">Mostrar carros</button>

    <div id="print_cars">

    </div>
    <script type="text/javascript" src="funcion_constructora.js">

    </script>

  </body>
</html>
________________________________________________________________________________________________________



var box = document.getElementById('print_cars');

var marca = ["Acura: Honda Motor Company",
            "Alfa Romeo: Fiat Chrysler Automobiles",
            "Audi: Volkswagen Group",
            "BMW: BMW Group",
            "Bentley: Volkswagen Group",
            "Buick: General Motors",
            "Cadillac: General Motors",
            "Chevrolet: General Motors",
            "Chrysler: Fiat Chrysler Automobiles",
            "Dodge: Fiat Chrysler Automobiles",
            "Fiat: Fiat Chrysler Automobiles"
          ];

var modelo = [
      "Acura NSX",
      "4C",
      "A3",
      "2 series",
      "Flying spur",
      "REGAL",
      "CT4",
      "CAMARO",
      "300",
      "CHALLENGER",
      "500L"
];

function auto(marca, modelo, año){
  this.marca = marca;
  this.modelo = modelo;
  this.año = año;

  this.detallesDelAuto = function(){
    box.innerHTML += "<br>";
    box.innerHTML += ` Auto ${this.marca} ${this.modelo} ${this.año}`;
  }
}


function randomInteger(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}


function makeCars(){

  for (var i = 0; i < marca.length; i++) {
    let car = new auto(marca[i], modelo[i], randomInteger(2010, 2020));
    setTimeout(()=>{
          car.detallesDelAuto();
    }, 1000);

  }
}


function displayCars(){
  var box = document.getElementById('print_cars');
  makeCars();
}

Aqui muestro mi solucion:

let cars = []

function car (brand, model, year) {
    this.brand = brand,
    this.model = model,
    this.year = year
}

const fillCars = () => {
    let carsNumbers = prompt('How many cars do you want to register?')
    for(let i = 0; i < carsNumbers; i++){
        let carBrand = prompt(`Write Car Brand ${i}`);
        let carModel = prompt(`Write Car Model ${i}`);
        let carYear = prompt(`Write Car Year ${i}`);
        let newCar = new car(carBrand, carModel, carYear)
        cars.push(newCar)
    }
}```

Recomiendo mucho el curso de programación orientada a objetos, usa un ejemplo muy bueno durante todo el curso.

Reto terminado ✔️

Alternativa para CREAR CLASE o FUNCION CONSTRUCTORA:

class Auto {
    constructor (marca, modelo, annio) {
        this.marca = marca;
        this.modelo = modelo;
        this.annio = annio;
    }
}

Aplicar uso de clase o INSTANCIAR:

const Auto1 = new Auto ("Ford", "Ecosport", "2013");```

Generar variables aleatorias fue la única forma que hallé para conseguir las 30 combinaciones.

  var carro = []
  var marcas = ["Mini", "Tesla", "Mercedes Benz", "Bmw"]
  var colores = ["Rojo", "Negro", "Verde", "Blanco", "Celeste"]

  function auto(marca, annio, color) {
      this.marca = marca
      this.annio = annio
      this.color = color
  }

  for (var i = 0; i < 30; i++) {
      marcaRandom = marcas[Math.floor(Math.random() * 4)]
      annioRandom = Math.floor(Math.random() * (2020 - 2000)) + 2000
      colorRandom = colores[Math.floor(Math.random() * 5)]

      var nuevoAuto = new auto(marcaRandom, annioRandom, colorRandom)
      carro[i] = nuevoAuto
  }


  for (var i = 0; i < 30; i++) {
  console.log(`marca: ${carro[i].marca} año: ${carro[i].annio} color: ${carro[i].color}`)
  }```

Agregé un alert de estatus para el usuario, de esta forma mejoramos el UX haciéndole saber lo que está pasando. 😄

function autos(brand, model, year) {
  this.brand = brand;
  this.model = model;
  this.year = year;
}

var coches = [];
var maxCars = prompt("¿Cuántos coches quieres agregar?");
var i = 0;

while (i < maxCars) {
  if (i < maxCars) {
    i++;
    var brand = prompt(`¿Qué marca es el auto ${i}?`);
    var model = prompt(`¿Cuál es el modelo del auto ${i}?`);
    var year = prompt(`¿Qué año es el auto ${i}?`);
    coches.push(new autos("brand", "model", "year"));
    window.alert(
      `Agregué ${brand} ${model} ${year} a tu lista.\nHasta ahora tienes ${coches.length} autos.`
    );
  }
}

console.log("¡Felicidades! Has terminado la lista.");

var marca = ["Renault","Mercedes","Toyota","Chevrolet","Porche"];
var modelo =["Modelo X1", "Modelo X2","Modelo X3","Modelo X4", "Modelo X5"];
var annio =["2010","2012","2013","2015","2017"];

function autosNuevos(marca,modelo,annio){
    this.marca = marca;
    this.modelo = modelo;
    this.annio = annio;
}


for(i=0;i<marca.length;i++){
    auto = new autosNuevos (marca[i],modelo[i],annio[i]); 
    console.log(auto);
}

¡Lo logre!, Y aunque puedo decir eso, me gustaría sus opiniones y que pude haber hecho mejor para seguir mejorando:

var marcas = ["Toyota", "Tesla", "BMW", "Ford", "Audi"];

var series = ["serie 1", "serie 2", "serie 3", "serie 4", "serie 5"];

var anio = [2017, 2018, 2019, 2020, 2021];

var carros = [];

function auto(marca, serie, anio) {
    this.marca = marca;
    this.serie = serie;
    this.anio = anio;
}

function random() {
    return Math.floor(Math.random() * (5) * 1)
}

for (var i = 1; i <= 30; i++) {
    carros.push(new auto(marcas[random()], series[random()], anio[random()]))
}

for (var j = 0; j < carros.length; j++) {
    console.log(carros[j])
};```

Mi pequeño aporte muchachos

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Autos</title>


</head>
<body>
<p><strong>Marca:</strong></p>
    <input type="text" id=marca>
    <p><strong>Modelo:</strong></p>

    <input type="text" id=modelo>
<p><strong>Año:</strong></p>
    
    <input type="number" id=anio>
    <p></p> 
    <input type="button" value="Enviar" id="enviar">   
    <p id="texto"></p>




<script>

var marca=document.getElementById("marca");
var modelo=document.getElementById("modelo");
var anio=document.getElementById("anio");
var nuevo=[];
var i=0;
var texto=document.getElementById("texto")

var boton=document.getElementById("enviar");
boton.addEventListener('click',lista_autos)

function auto(marca,modelo,anio) {
    
    this.marca=marca;
    this.modelo=modelo;
    this.año=anio;

}

function lista_autos(){
    
    
if (i<2) {

    var nuevoAuto= new auto(marca.value,modelo.value,anio.value);
    nuevo.push(nuevoAuto);   
i++    

texto.innerHTML+="Marca: "+nuevoAuto.marca+"<br> "+"Modelo: "+nuevoAuto.modelo+"<br> "+"Año: "+nuevoAuto.año+"<br>";
} 

   console.log(nuevoAuto)

}






</script>


</body>
</html>

function estudiante(nombre, correo, pais) {
  this.nombre = nombre;
  this.correo = correo;
  this.pais = pais;
}
var estudiantes = [];
var nombre = prompt("¿Cuál es tu nombre?");
var correo = prompt("¿Cuál es tu correo electrónico?");
var pais = prompt("¿De que país eres?");
estudiantes.push(new estudiante(nombre, correo, pais));
console.log(estudiantes[0]);

function repuestos (color, marca, peso) {
    this.color = color;
    this.marca = marca,
    this.peso = peso;
}

var repuesto =[];

for (var i = 0; i<5; i++) {
    var color = prompt(`escribe el color ${i}`);
    var marca = prompt("escribe la marca");
    var peso = prompt("escribe el peso");
    repuesto.push(new repuestos(color, marca, peso));
}

for (var repuest of repuesto) {
    console.log(repuesto[repuest]);
}

var autos = [];
function auto(marca, modelo, annio){
    this.marca = marca;
    this.modelo = modelo;
    this.annio = annio;
}

for(var i=0; i<10; i++){
    var marca = prompt("Ingrese marca");
    var modelo = prompt("Ingrese modelo");
    var annio = prompt("Ingrese año");
    autos.push(new auto(marca, modelo, annio));
}

Ahí está, en la clase se pide que por default sean 30 autos pero al probarlo me pareció una eternidad registrar 90 valores: 30 autos x 3 propiedades, así que mejor le puse que defina cuantos autos quiere registrar.

function auto(marca, modelo, annio) {
  this.marca = marca;
  this.modelo = modelo;
  this.annio = annio;
  this.detalle = function () {
    return `Marca: ${this.marca}\nModelo: ${this.modelo}\nAño: ${this.annio}\n`;
  };
}

var noAutosARegistrar = prompt("¿Cuátos autos quieres registrar?");

var lstAutos = [];
for (var i = 0; i < noAutosARegistrar; i++) {
  var marca = prompt(`Marca del auto ${i + 1}:`);
  var modelo = prompt(`Modelo del auto ${i + 1}:`);
  var annio = prompt(`Año del auto ${i + 1}:`);
  lstAutos.push(new auto(marca, modelo, annio));
}

function printDetalleAutos(autos) {
  var lstDetalleAutos = "";
  autos.forEach((auto) => {
    lstDetalleAutos += auto.detalle() + "\n";
  });
  alert(`########## Autos registrados ###########\n${lstDetalleAutos}`);
}

printDetalleAutos(lstAutos);

Me costó al principio. Tuve que ver los resultados comentados por los colegas y me gustó la solución aportada por Eduardo Antonio Rivero Rivera. En base a su solución abrevié un par de puntos para simplificar.

function auto (marca, modelo, annio) {
  this.marca = marca;
  this.modelo = modelo;
  this.annio = annio;
}

var misAutos = [];

while (misAutos.length < 3) {

  var marca = prompt('Ingresa la marca del auto');
  var modelo = prompt('Ingresa la modelo del auto');
  var annio = prompt('Ingresa el año del auto');

  misAutos.push(new auto(marca, modelo, annio));
}

for (var miAuto of misAutos) {
  console.log(miAuto);
}

Este es mi código para cumplir con el reto.

var listaAutos=[];
function construirAutos(Marca,Modelo,Anio){
        this.Marca=Marca;
        this.Modelo=Modelo;
        this.Anio=Anio;
}

//capturar 
for(i=0;i<30;i++)
{
  var marca=prompt("Marca: " );
  var modelo=prompt("Modelo: ");
  var anio=prompt("Año: ");

  var auto= new construirAutos(marca,modelo,anio);

  listaAutos.push(auto);

}

console.log(listaAutos);

Mi reto, no me quise explayar tanto con el año y tal, pero es una buena solución. De igual manera, también con los loops podríamos llenar nuestros Arrays si trajéramos la info por ejemplo, de una base de datos.

Les comparto el reto de generar 30 autos uando 3 marcas y 3 modelos distintos por marca.

function auto(marca, modelo, year, color) {
    this.marca = marca;
    this.modelo = modelo;
    this.year = year;
    this.color = color;
}

var marca = ["Ford", "Nissan", "Toyota"];
var modeloFord = ["Fiesta","Focus","Fusion"];
var modeloNissan = ["Versa", "Sentra", "Altima"]
var modeloToyota = ["Yaris","Corolla", "Camry"];
var year = [2018,2019,2020];
var color = ["Plata", "Rojo", "Blanco", "Negro"];

for(var i = 1; i<=30; i++ )
 {
    var marcaAuto = marca[Math.floor(Math.random()*3)];
    switch (marcaAuto) {
        case 'Ford':
            modeloAuto = modeloFord[Math.floor(Math.random()*3)];
            break; 
        case 'Nissan':
            modeloAuto = modeloNissan[Math.floor(Math.random()*3)];
        break;
        default:
            modeloAuto = modeloToyota[Math.floor(Math.random()*3)];
    }
    var yearAuto = year[Math.floor(Math.random()*3)];
    var colorAuto = color[Math.floor(Math.random()*4)];

    var newCar = new auto(marcaAuto, modeloAuto, yearAuto, colorAuto);
    console.log(newCar);    
 }
 

function country(country, continent, language){
    this.country = country;
    this.continent = continent;
    this.language = language;
}

var countries = ["Argentina", "China", "Australia", "Colombia", "Italia", "Canada"];
var continents = ["Sudamerica", "Asia", "Oceania", "Sudamerica", "Europa", "Norte América"];
var languages = ["Spanish", "Mandarín", "English", "Spanish", "Italian", "English-French"];


    for(let i=0; i<countries.length; i++){
         var newCountry = new country(countries[i],continents[i],languages[i]);
         console.log(newCountry);
    }

Acá les comparto mi código, sin pedir los datos al usuario para eso hice los Array pre cargados jejeje

//Se declara la structura del Objeto
var miAuto = {
  marca:"",
  modelo:"",
  annio:0000
};

//Se inicializa la cantidad de vehículo
var cantidadVehiculos = 30;

//se Declara el Array que almacenara la lista de los vehículos.
var nuevoVehiculo = [];

//Se tiene la lista en un Array de Marcas   
var marcaVehiculo = ['ACURA', 'CHEVROLET/OPEL/LUV', 'FIAT', 'JCB', 'MASERATI', 'PERKINS TRUCK', 'SELTEC', 'WULING', 'AGRALE', 'CHEVROLET/GMC', 'FIAT TRUCK', 'JEEP', 'MATSUSHITA', 'PEUGEOT', 'SETRA', 'YALE', 'ALFA ROMEO', 'CHEVRO./GMC', 'FORD LIVIANOS & U.S.A.', 'KASSBOHRER', 'MAZDA', 'PLYMOUTH', 'SIMCA', 'YAMAHA', 'CHRYSLER', 'FORD TRUCK -  SER:500 UP', 'KAWASAKI', 'MERCEDES BENZ', 'PONTIAC', 'SKODA'];

//Se tiene la lista en un Array de Modelos  
var modeloVehiculo = ['LUV1', 'LUV2', 'NKR', 'NPR', 'Spark1', 'Spark2', 'LUV 2.3 2WD', 'LUV 2.3 4WD', 'LUV3', 'LUV D-MAX 3.0', 'Alto', 'LUV4 2.3 4WD', 'LUV5', 'Tracker', 'Spark3', 'Astra', 'Combo', 'Corsa', 'LUV6', 'LUV7', 'LUV8 3.2', 'LUV9 D-MAX 3.0 4WD', 'Frontera A', 'Frontera B', 'LUV10 D-MAX 4WD', 'LUV11 3.2 4WD', 'LUV12 3.2 4WD', 'LUV13 2.2', 'LUV15 D-MAX 3.0  4WD', 'LUV15 D-MAX 3.0  4WD'];

//Se tiene la lista en un Array de Años  
var annioVehiculo = [1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019];

//Se realiza la funcion constructora que se engargara de asignar los valores a nuestro objeto
function auto(marca,modelo,annio){
    this.marca = marca;
    this.modelo = modelo;
    this.annio = annio;
}

//Se realiza en un look (For en mi caso) para realizar la inserción de los datos en el nuevo array
for (i=0;i<cantidadVehiculos;i++){
 nuevoVehiculo.push(new auto(marcaVehiculo[i],modeloVehiculo[i],annioVehiculo[i]));
}

//Esta es una linea de validación que devuelve el tamaño del nuevo array
//console.log(nuevoVehiculo.length);

//Muestra la lista de Vehículos.
for(i=0;i<cantidadVehiculos;i++){
    console.log(i +") El Nuevo Vehículo es: " + nuevoVehiculo[i].marca + ", " + nuevoVehiculo[i].modelo + ", " + nuevoVehiculo[i].annio);
  }

function auto(marca,modelo,annio){
  this.marca = marca;
  this.modelo= modelo;
  this.annio =annio;  
}
var carro = [];
cant = 30;
for (let i = 0; i < cant; i++) {
    carro[i]= new auto ( `Carro ${i+1}`,`Modelo ${i+1}`,`Annio 2023`);    
}

console.log(carro);

Realicé este código donde se le pide al usuario mediante un prompt que ingrese cada uno de los datos y se va a continuar el proceso mediante un bucle while hasta que el usuario decida no continuar ingresando datos mediante el caracter “n” cuando se le pregunte si desea continuar:

let continuar = true

let autos = []
function auto(marca,modelo,anio,color){
    this.marca = marca;
    this.modelo = modelo;
    this.anio = anio;
    this.color = color;
    }


function nuevoAuto(){
    let marca = prompt('Ingrese marca de vehículo: ')
    let modelo = prompt(`Ingrese modelo del vehículo ${marca}: `)
    let anio = prompt(`Ingrese año de fabricación del ${marca} ${modelo}: `)
    let color = prompt('Ingrese color del carro: ')
    let autoNuevo = new auto(marca,modelo,anio,color)
    autos.push(autoNuevo)
}

while (continuar == true){
    nuevoAuto()
    let conf = prompt('Deseas continuar? [y/n]: ')
    if (conf == 'y'){
        continuar = true
        continue

    }
    else if (conf=='n'){
        continuar = false
        break
    }
}

console.log(autos)

Si me pueden dar ideas para seguir optimizando el código sería ideal! 😀😀😀

mi solución automatica para 10 carros

function auto(marca, modelo, ano){
        this.marca = marca;
        this.modelo = modelo;
        this.ano = ano;
        this.imprimir = function(){
              console.log(`Auto ${this.marca} ${this.modelo} `); 
        }
}

let resumenCarros = []
let cars   = ["Audi", "Bentley", "Bugatti", "Lamborghini", "Porsche", "SEAT", "Skoda", "Volkswagen", "Dacia", "Ferrari"]
let modelo = ["A1",   "B2",      "B3",      "L4",          "P5",      "S6",   "S7",    "V8",         "D9",    "F10"]
let annio  = 2010

for (let i = 0; i < 10; i++ ){
    
    annio = annio + 1
    resumenCarros[i] = new auto(cars[i], modelo[i], annio)
    console.log(resumenCarros[i].imprimir());
} 

var listaAutos = [];

function auto (marca,modelo,año)
    {
        this.marca = marca
        this.modelo = modelo
        this.año = año
    }

function inicioLista() {
    for (var i = 0; i < 30; i++)
    {
        var modelo = prompt("Escribe la Marca ");
        var marca = prompt("Escribe el Modelo ");
        var año = prompt("Escribe el año");
        listaAutos.push(new auto(modelo,marca,año));
    }
}

Despues de casi dañar la PC haciendo loops infinitos, acá esta mi solución:

// Create 30 cars objects using a loop
var car = function (brand, model, year) {
  this.brand = brand;
  this.model = model;
  this.year = year;
};

function create_cars(quantity) {
  var cars = [];

  for (var i = 0; i < quantity; i++) {
    cars.push(new car("Toyota", "Corolla", 1970 + i));
  }

  return cars;
}

Mi solucion a lo planteado:

const prompt = require("prompt-sync")();
function auto (brand, model, year) {
    this.brand = brand;
    this.model = model;
    this.year = year;
};
for(let i = 0 ; i < 5 ; i++){
  let brand = prompt("Type the car brand: ");
  let model = prompt("Type the car model: ");
  let year = prompt("Type the car year: ");
  auto[i] = new auto (brand, model, year);
  console.log("______________________________________________________________");
  console.log("The data was added!");
  console.log("______________________________________________________________");
  console.log("");
}
for (let i = 0; i < 5; i++){
console.log(auto[i].model, auto[i].year);
};

Buenas gente. Comparto mi solucion.

<code> function cauto(marca,modelo,annio ){
    this.marca = marca,
    this.modelo = modelo,
    this.annio = annio
}
var amarca = ["fiat", "peugeot", "tesla"];
var amodelo =["palio","nissan","attractive"];
var annio = ["2010","2020","2030"] 

for(i = 0; i <= 30; i++){
    var randommarca = amarca[Math.floor(Math.random()* amarca.length)]
    var randommodelo = amodelo[Math.floor(Math.random()* amodelo.length)]
    var randomannio = annio[Math.floor(Math.random()* annio.length)]
    var auto2 = new cauto(randommarca, randommodelo,randomannio);
    console.log(auto2);
}


 

hola, aqui les dejo este mega desafio jeje.

function createCar(brand, model, year) {
    this.brand = brand;
    this.model = model;
    this.year = year;
}

function createCars (brand, model, year, numberOfCars) {
    var countOfCars = 0;
    var newCars = []; // it's an array
    while (numberOfCars > countOfCars) {
        var car = new createCar(brand, model, year); // it's a object
        newCars.push(car);
        countOfCars = countOfCars + 1;
    }
    return newCars;
}
createCars("tesla", "model 1", 2022, 20); // esto es la llamada

Como aun no estamos usando la palabra reservada prompt lo hice de esta manera.

Código para generar 30 objetos de auto con propiedades aleatorias.

var cars = [];

var brandList = ['Toyota', 'Tesla', 'Honda', 'Kia'];
var modelList = ['Model S', 'Model X', 'Corolla', 'Odyssey', 'K5', 'Rio'];

function car(brand, model, year){
	this.brand = brand;
	this.model = model;
	this.year = year;
}

function createRandomCars(){
	for(var i = 0; i < 30; i++){	
		var randomBrand = brandList[Math.floor(Math.random() * brandList.length)];
		var randomModel = modelList[Math.floor(Math.random() * modelList.length)]
		cars.push(new car(randomBrand, randomModel,randomYear()));
	}
}

function randomYear(){
	return Math.floor(Math.random() * (2022 - 2000) + 2000);
}

Lo primero que se me vino a la mente…

//-----------Reto --------------//

var marcas = ["honda", "yamaha", "bajaj"];
var modelos = ["Tornado", "Africa", "Dominar"];
var cilindradas = [250,500,450];
var Motos = [];

function Moto(marca, modelo, cilindrada){
    this.marca = marca;
    this.model = modelo;
    this.cilindrada = cilindrada;
}

for(var i=0 ; i < marcas.length; i ++){

    Motos.push(new Moto(marcas[i], modelos[i], cilindradas[i])); 
}

var a=prompt("Ingrese la cantidad de vehículos a registrar");
var baseDeDatosVehiculos= [a]
function auto(marca, modelo, annio) 
    {
        this.marca = marca;
        this.modelo = modelo;
        this.annio = annio;  
    }

for(var i=0; i<a; i++)
    {
        marca=prompt(`Ingrese la marca del vehiculo ,${i}`);
        modelo=prompt(`Ingrese el modelo del vehiculo ,${i}`);
        annio=prompt(`Ingrese el annio del vehiculo ,${i}`);  
        baseDeDatosVehiculos[i]=(new auto(marca,modelo,annio));
    }

mi aporte ❤️ solución al reto, aplicando los conceptos dados en el curso.

//utilizar la función constructora para crear 30 carros haciendo uso de un loopso ciclos

function auto(marca, modelo, annio) { //funcion constructora
this.marca = marca;
this.modelo = modelo;
this.annio = annio;
}
var numAutosNuevos = 30; //numero de autos que quiero agregar
var misAutos = []; // arreglo para manejar mis autos
var contador = 1;//variable contadora
while (misAutos.length < numAutosNuevos) {
var nuevoAuto = new auto(marca ${contador}, modelo ${contador}, 2020 + contador)
misAutos.push(nuevoAuto);
contador++;
}
console.log(misAutos); // pintar el arreglo con el total de autos agregados en el loop

function auto(marca, modelo, annio) {
    this.marca = marca;
    this.modelo = modelo;
    this.annio = annio;
}

for(var i = 0; i <30; i++) {
    var autos = new auto(`Tesla ${i}`, "Model X", 2000+i);
    document.write(`> ${autos.marca}, modelo ${autos.modelo}, año ${autos.annio} <br>`);
}

This is my code

var autoNuevo = [];
var cuantos = prompt('Cuantos autos deseas ingresar: ')

for (let i = 0; i < cuantos; i++){
    var marca = prompt("Ingresa la marca del auto");
    var modelo = prompt("Ingresa el modelo del auto");
    var annio = prompt("Ingresa el año del auto");
    autoNuevo.push(new auto (marca, modelo, annio));
}

for(let i = 0 ; i < autoNuevo.length ; i++){
  console.log(autoNuevo[i]);
}

Mi solución al reto planteado haciendo uso del bucle while

// Constructor Function
function car(brand, model, year, carCode){
    this.brand = brand;
    this.model = model;
    this.year = year;
    this.carCode = carCode;
}

// Javascript test
var carCode = 1;
var carsArray = [];

while(carCode <= 30){
  var newCar = new car("Toyota", "Corola", 2020, carCode);
  carsArray.push(newCar);
  carCode++;
}

console.log(carsArray);

Mi aporte

let cars = [];

function constructor(brand, year, color){
    this.brand = brand,
    this.year = year,
    this.color = color
}

for(let i = 1; i <= 30; i++){
    let car1 = new constructor(`brand ${i}`, `year ${i}`, `color ${i}`)
    cars.push(car1)
}

console.log(cars)

Me iré a Youtube porque aquí no entendí.

Mi aporte con 3 autos para que no sea muy largo:

//Crear el constructor
function auto(marca,modelo,anno) {
    this.marca=marca,
    this.modelo=modelo,
    this.anno=anno
}

// Datos para generar los autos
var marcas=["Toyota","Nissan","Subaru"]
var modelos=["Supra","Sentra","Impreza"]
var annos=[2000,2016,2022]

//Variable para almacenar los autos
var miAuto=[];

//Bucle para tomar el valor 0 de cada array y generar un nuevo auto que se almacenara en la variable definida
for (var i = 0; i < marcas.length && i < modelos.length && i < annos.length; i++) {
    miAuto.push(new auto(marcas[i],modelos[i],annos[i]));
}

//Bucle para mostrar los autos creados
for (var i = 0; i < miAuto.length; i++) {
    console.log(miAuto[i]);
}

function auto(marca, modelo, annio) {
  this.marca = marca;
  this.modelo = modelo;
  this.annio = annio;
}

let autos = [];

for (i = 0; i < 30; i++) {
  let marca = prompt("Ingrese la Marca del Carro");
  let modelo = prompt("Ingrese el Modelo del Carro");
  let annio = prompt("Ingresa el Año del modelo");

  var newAuto = new auto(marca, modelo, annio);

  autos.unshift(newAuto);
}

console.log(autos);

var marcas = ['Ford', 'Mazda', 'Nissan'];
var modelos = ['Ford Focus', 'CX-5', 'Opel Astra'];
var agnos = ['2020', '2021', '2022'];

function auto(marca, modelo, agno){
    this.marca = marca,
    this.modelo = modelo,
    this.agno = agno,
    this.detalleAuto = function(){
        console.log(`El auto ${this.marca} es de modelo ${this.modelo} y del año ${this.agno}`);
    }
}

for(var i=0; i<10; i++){
    var nuevoAuto = new auto(
        marcas[Math.floor(Math.random()*3)],
        modelos[Math.floor(Math.random()*3)],
        agnos[Math.floor(Math.random()*3)]
    )

    nuevoAuto.detalleAuto();
}

Reto completado con arrays

function auto(mar, mod, ann) {
  this.marca = mar;
  this.modelo = mod;
  this.annio = ann;
}

var marcas = ["Renault", "Chevrolet", "Hyundai", "Kia", "Mazda"];
var modelos = ["Kwid", "Onix", "Elantra", "Rio", "CX-5"];
var ann = [2021, 2022, 2019, 2020, 2023];
var car = [];

for (i = 0; i < 5; i++) {
  car[i] = new auto(marcas[i], modelos[i], ann[i]);
}

for (mcar of car) {
  console.log(mcar);
}

Desafio completado

<code> 
var marcas = [
    "Audi",
    "Subaru",
    "Lexus",
    "Porsche",
   " BMW",
    "Mazda",
    "Buick",
    "toyota",
    "Kia",
    "Honda",
    "Hyundai",
    "Volvo",
    "Mini",
    "Mercedes-Benz",
    "Volkswagen",
    "Ford",
    "Lincoln",
    "Scion",
    "Acura",
    "Chevrole",
    "Nissan",
    "Infiniti",
    "GMC",
    "Cadillac",
    "Dodge",
    "Land Rover",
    "Jeep",
    "Fiat"
]


var modelos =[
    "C-Max",
    "Fiesta",
    "Focus",
    "Mondeo",
    "Ka",
    "S-MA",
   " B-MAX",
    "Grand C-Max",
    "Tourneo Custom",
    "Kuga",
    "Galaxy",
    "Grand Tourneo Connect",
    "Tourneo Connect",
    "EcoSport",
    "Tourneo Courier",
    "Mustang",
    "Transit Connect",
    "Edge",
    "Ka+"
]


var annios =[
    "1988",
    "1989",
    "1978",
    "1989",
    "1928",
    "1989",
    "1968",
    "1989",
    "1888",
    "1989",
    "1288",
    "1989",
    "1938",
    "1989",
    "1988",
    "1999",
    "1983",
    "1989",
    "1918"
]

function autos(marcas,annios,modelos){   
    this.marcas = marcas;
    this.annios = annios;
    this.modelos = modelos}
for(var i = 0;marcas.length>i && annios.length>i&& modelos.length>i;i++){

    var nuevoAuto = new autos(marcas[i],annios[i],modelos[i]);
    console.log(nuevoAuto)
}

Esta es mi solución!

let autos = [];

class auto {
    constructor(marca, modelo, annio, id) {
        this.marca = marca;
        this.modelo = modelo;
        this.annio = annio;
        this.id = id;
    }
}

let cantidadAutos = parseInt(prompt("¿Cuantos autos desea ingresar?"));

if (cantidadAutos) {
    for (i=0; i<cantidadAutos; i++){
        let marca = prompt("Ingrese una Marca de Autos");
        let modelo = prompt("Ingrese el modelo de auto");
        let annio = parseInt(prompt("Ingrese el año de fabricación"));
        let id = i + 1
        let nextAuto = new auto (marca, modelo, annio , id);
        autos.push(nextAuto);
        console.log(nextAuto);
    }
}else {
    alert("Por favor ingrese un numero")
}
console.log(autos);

Cree una lista donde se guardarán 3 juegos con su nombre y género. De esta manera se evita crear varios objetos con nombre distinto.

function Game(name, genre){
    this.name = name;
    this.genre = genre;
}


function Create(){
    var game = [3];
    
    for(var i=0; i < 3; i++){
        var gameName = prompt("Write a game name");
        var genreName = prompt("Write a genre");
       
        game[i] = new Game(gameName, genreName);   

        
        console.log(game[i]);
        
    }   
}
Create();

![](

Hola, mi solución al reto:

Hola a todos, espero que estén bien, para cumplir con el reto de los 30 registros de carros de forma automática, dividí el ejercicio en dos partes la 1. Que consta de la funcion constructura y la estructura de datos que prepare con 3 arrays distintos para establecer cuales serian los datos de la marca, modelo y annio (año) de cada uno de los 30 automoviles (carros-auto) y 2. la parte de la lógica del loop (Bucle) que utilice, realice varias pruebas, para comprobar si era posible usar las 3 estructuras del loop, es por eso que en esta parte muestro las versiones distintas de loop que emplee. Es de aclarar que todo lo que emplee para realizar este reto fueron criterios que se explicaron en este curso, hasta donde se encuentra este video.

Repositorio del ejercicio: https://github.com/nelsonroez29/ejerciciosPlatzi.git

A continuación explico el ejercicio:

Primera Parte

Esta consiste primeramente en establecer la función constructora para crear la plantilla (template) del objeto, en nuestra caso para los 30 automóviles,

//Funcion constructora

function Auto(marca, modelo, annio){
    this.marca = marca;
    this.modelo = modelo;
    this.annio = annio;
    this.description = function(){
        console.log(`El Auto es un ${this.marca} ${this.modelo} del ${this.annio}`)
    }

}

Como se muestra, utilicé las 3 caracteristicas que Diego utilizo en sus ejemplos, y tambien quise colocar una propiedad (método) que mostrara un mensaje personalizado para cada automovil, como lo es ´description´.

Ahora bien, por otro lado, también tuve que preparar 3 arrays que van almacenan los datos de la marca, modelo y annio respectivamente de cada uno de los 30 automoviles, estos los seleccione uno a uno por igual.

//Lista de marcas de Carros.

var marcas = [
    "Audi",
    "BMW",
    "Chevrolet",
    "Ferrari",
    "Ford",
    "Nissan",
    "Suzuki",
    "Tesla",
    "Toyota",
    "Volkswagen",
    "Ferrari",
    "Ford",
    "Nissan",
    "Suzuki",
    "Tesla",
    "Toyota",
    "Volkswagen",
    "Audi",
    "BMW",
    "Chevrolet",
    "Ferrari",
    "Ford",
    "Nissan",
    "Suzuki",
    "Tesla",
    "Toyota",
    "Volkswagen",
    "Audi",
    "BMW",
    "Chevrolet",
];

//Lista de los modelos de estas marcas de Carros.

var modelos = [
    "A6 allroad quattro",
    "Serie 2 Gran Tourer",
    "Camaro",
    "California",
    "Mustang",
    "Murano",
    "Grand Vitara",
    "Model X",
    "Corolla",
    "Fox",
    "GTC4",
    "C-Max",
    "X-TRAIL",
    "Swift",
    "Model S",
    "Avensis",
    "Phaeton",
    "A4",
    "Serie 3",
    "Cruze",
    "488",
    "Fiesta",
    "QASHQAI",
    "SX4 S-Cross",
    "Model Y",
    "Land Cruiser",
    "Golf",
    "SQ7",
    "X1",
    "Aveo"
];

//Lista de los años de cada modelo anterior.

var annios = [
    "2021",
    "2022",
    "2010",
    "2015",
    "2020",
    "2007",
    "2012",
    "2018",
    "2020",
    "2014",
    "2017",
    "2015",
    "2016",
    "2014",
    "2021",
    "2017",
    "2016",
    "2015",
    "2016",
    "2015",
    "2016",
    "2016",
    "2014",
    "2013",
    "2017",
    "2018",
    "2016",
    "2020",
    "2022",
    "2015",

    
];

Utilice arrays porque me permite almacenar una gran cantidad de datos, y estos los puedo llamar mas tarde cuando los necesite.

Antes de procesar esta información para crear el registro de los 30 automoviles, pensé que para ello era importante guardar cada uno de estos registros (u objetos) en una variable pero de forma automática, es por eso que lo mas indicado era declarar un array que guardaría estos registros (u objetos) al momento de cada ciclo del loop (bucle), de allí fue donde surgió la idea de declarar el siguiente array antes de iniciar la parte del loop (bucle).

// Registro de Autos creados

listAutos = [];

Segunda Parte

Aquí es donde interviene la logica para el registro automatico de los automoviles, cada versión del bucle tiene el mismo fin, salvo que su sintaxis es distinta una de la otra.

//-------------------------------------------
// Versiones de Bucles
//-------------------------------------------


// Version 01 con for 01

for(var i = 0; i< marcas.length; i++){
    var newCar = new Auto(marcas[i], modelos[i],annios[i]);
    listAutos.push(newCar);
}

En este inicializamos una variable i en 0, para recorrer desde el index 0 hasta el 29 de los arrays, dentro del bucle for, hay dos sentencias:

1. Que se encargara de crear el nuevo objeto basándose en la planilla (template) de la función constructor, y como parámetros de la función, se pasan los valores de los arrays con index igual a i esto permite que al iniciar el bucle, i sea igual a 0 y por cada ciclo se aumentara +1, hasta alcanzar 29 que es el ultimo índice de los arrays.

2. al obtener el objeto, este será guardado dentro del array listAutos, utilizando el método push()

En resumen, el for hará 30 ciclos, y por cada ciclo creará un nuevo objeto, que en nuestro caso es un automovil, e inmediatamente se guardará dentro de un array.

// Version 02 con for 01 Comprimido

for(var i = 0; i < marcas.length ; i++){
    listAutos.push(new Auto(marcas[i], modelos[i],annios[i]));
}

En esta versión solo se simplifico la expresion de la accion de crear y guardar el objeto en el array

// Version 03 con for...of ...

for(marca of marcas){
    var modelo = modelos.shift();;
    var annio = annios.shift()
    listAutos.push(new Auto(marca, modelo, annio));
}

En esta Version, se debe considerar que para ejecutar el for… of, se realiza partiendo de un grupo especifico de datos en una lista o en este caso de un array (marcas), y cada valor que se obtiene al leer el array se guarda en una variable con una expresión singular a esta (marca), el detalle es que dentro del for solo se usara los datos que guarda la variable singular, es por ello que para llamar a las variable de los otros arrays para completar la creacion del objeto es necesario llamar los valores indexados en los otros arrays (modelos y annios), para ello tuve que recurrir al método shift(), por dos razones, 1. Porque obtiene los valores desde el index 0 en adelante, y 2. el for al momento de leer los arrays siempre lo hace desde el index 0.

// Versión 04 con While tomando valores del primero al ultimo

while(marcas.length > 0){
    var marca = marcas.shift();
    var modelo = modelos.shift();
    var annio = annios.shift();
    listAutos.push(new Auto(marca, modelo,annio));

}

Debido a la naturaleza del while, o su forma de ejecución, partí del principio que utilicé con el método shift() en la versión anterior pero ahora para cada uno de los arrays y así llevar sus valores indexados a los parámetros de la función que construye el objeto, ademas este comportamiento del bucle while, Diego lo explica en su video.

// Version 05 con While tomando valores del ultimo al primero

while(marcas.length > 0){
    var marca = marcas.pop();
    var modelo = modelos.pop();
    var annio = annios.pop();
    listAutos.push(new Auto(marca, modelo,annio));

}

Lo único diferente en esta ultima versión es que cambie el método shift(), por el pop(), esto me permitió condicionar al while que en vez de iniciar por el index 0, iniciar por el ultimo y se regresara hasta el 0, es decir de forma inversa.

También debo recalcar que el uso del método shift() y el pop(), hace que saquemos los elementos del array, y lo que hice fue prácticamente sacar los elementos de los arrays (marcas, modelos y annios) para luego guardarlos en el array listAutos de forma mas organizada, un símil seria tener 3 bolsas de canicas y sacar una canica de cada una de ellas para guardarlas en otra bolsa de canicas mas grande, repitiendo esto 30 veces.

Espero que les haya sido de ayuda.

Hola, les comparto mi resultado

let colores = ['Crimson', 'HotPink', 'OrangeRed', 'Tomato', 'Yellow', 'Gold', 'RebeccaPurple', 'DarkSlateBlue', 'SeaGreen', 'Green', 'SteelBlue', 'Blue', 'MediumBlue', 'DarkBlue', 'White', 'Black'];

let marcas = ['Toyota', 'Mercedes-Benz', 'BMW', 'Honda', 'Hyundai', 'Tesla', 'Ford', 'Audi', 'Volkswagen', 'Porsche', 'Nissan', 'Ferrari', 'Kia', 'Land Rover'];

function aleatorio(color){
  let maximo = color.length
  let resultado = Math.floor(Math.random() * (maximo)); 
  return resultado;
};

class automoviles{
  constructor(marca, color){
    this.marca =  marca; 
    this.color = color;
  }
};

let marcasColor = [];

for(var l = 0; l < marcas.length; l++)
{
    marcasColor.push(new automoviles(marcas[l],colores[aleatorio(colores)] ));
};
console.table(marcasColor);

justo antes de terminar el curso entendi como hacer el reto, quiza no es lo mas interactivo pero cumple con lo que necesita el reto

function newCar(){
    
    var cn = prompt ("how many cars will you register?")
    
    
    function car(brand, model, year){
        this.brand = brand;
        this.model = model;
        this.year = year;
    }
        
    for (var i = 1; i <= cn; i++){

        var bran = prompt("cra's brand?");
        var mod = prompt("car's model?");
        var y = prompt("car's year?");
        var d = prompt("car's ID?");

        var newcar = parseInt(d);
        var newcar = new car(bran, mod, y);

        console.log(newcar)

    }
    
}

// defino la funcion constructora
function auto(marca, modelo, annio){
    this.marca = marca;
    this.modelo = modelo;
    this.annio = annio;
}

 // Definio los arrays con los datos
var marcas = ["A", "B", "C", "D", "E","F", "G", "H", "I", "J", 
"H", "I", "J", "K", "L", "M", "P", "O", "P", "Q",
"R", "S", "T", "U", "V","W", "X", "Y", "Z", "X" ];


var modelos = ["x", "y", "z", "b", "l", "t", "r", "u", "r", "i", 
"n","u", "a", "d", "f", "n", "f", "z", "e", "o", 
"l", "r","l", "r", "o", "o", "a", "b", "c","x"]

var annios = [2000, 1980, 2009, 1993, 2012, 1998, 2012, 2020,
2021, 2019, 2015, 2018, 1998, 2012, 2022, 2018, 
2018, 2022, 2021, 2009, 2008, 2000, 2007, 2001,
2004, 2006, 2009, 2015, 2016, 2020]

//defino donde almacenar la informacion

var listaAutos = []

// defino el loop 

for(var i = 0; i < marcas.length; i++){
    var autoNuevo = new auto(marcas[i], modelos[i], annios[i]);
    listaAutos.push(autoNuevo)
}

// para llamara cualquier auto listaAutos[] 

Mi solución al reto

.
Decidí usar la función random para escoger la marca, el modelo y el año, para después guardarlos en un arreglo ¿Qué opinan? Si alguien gusta el código con gusto puedo compartírselo!
.

el reto

function auto(marca, modelo, annio) {
  this.marca = marca;
  this.modelo = modelo;
  this.annio = annio;
}

var carros = [
  ['ALFA ROMEO', 'Giulietta',2019],
  ['ALFA ROMEO', 'Giulia',201],
  ['ALFA ROMEO', 'Stelvio',219],
  ['AUDI', 'A3',2012],
  ['AUDI', 'A4',2029],
  ['AUDI', 'Q5',2039],
  ['BMW', 'Serie 3',2119],
  ['BMW', 'Serie 5',2119],
  ['BMW', 'Serie 4',2319],
  ['CITROEN','C4 Cactus',3019],
  ['CITROEN','C3',2519],
  ['CITROEN','C4 Aircross',2519],
  ['FIAT', '500', 2019],
  ['HONDA', 'Civic', 2039],
  ['HONDA', 'CR-V', 2029],
  ['ALFA ROMEO', 'Giulietta',2019],
  ['ALFA ROMEO', 'Giulia',201],
  ['ALFA ROMEO', 'Stelvio',219],
  ['AUDI', 'A3',2012],
  ['AUDI', 'A4',2029],
  ['AUDI', 'Q5',2039],
  ['BMW', 'Serie 3',2119],
  ['BMW', 'Serie 5',2119],
  ['BMW', 'Serie 4',2319],
  ['CITROEN','C4 Cactus',3019],
  ['CITROEN','C3',2519],
  ['CITROEN','C4 Aircross',2519],
  ['FIAT', '500', 2019],
  ['HONDA', 'Civic', 2039],
  ['HONDA', 'CR-V', 2029]
]

var cochera = [];

for (let carro of carros) { 
  cochera.push(new auto(carro[0], carro[1], carro[2]));
  

console.log(cochera);

Entonces segùn las funciones constructoras, cuàl seria la diferencia con las clases? porque en teoria hacen lo mismo.

Hola a tod@s! Les comparto mi código.
//CREACIÓN LISTA DE ÚTILES ESCOLARES (basado en ejercicio hecho por compañero)
var tipo =[
“texto”,
“texto”,
“texto”,
“texto”,
“texto”,
“texto”,
“texto”,
“texto”,
“texto”,
“texto”,
“Adhesivo”,
“Adhesivo”,
“Adhesivo”,
“Adhesivo”,
“Adhesivo”,
“Adhesivo”,
“Adhesivo”,
“Adhesivo”,
“Adhesivo”,
“Adhesivo”,
“Cuaderno”,
“Cuaderno”,
“Cuaderno”,
“Cuaderno”,
“Cuaderno”,
“Cuaderno”,
“Cuaderno”,
“Cuaderno”,
“Cuaderno”,
“Cuaderno”,
]

var marca=[
“Santillana”,
“Santillana”,
“Santillana”,
“Santillana”,
“Santillana”,
“Santillana”,
“Santillana”,
“Santillana”,
“Santillana”,
“Santillana”,
“Torre”,
“Torre”,
“Torre”,
“Torre”,
“Torre”,
“Torre”,
“Torre”,
“Torre”,
“Torre”,
“Torre”,
“Faber Castell”,
“Faber Castell”,
“Faber Castell”,
“Faber Castell”,
“Faber Castell”,
“Faber Castell”,
“Faber Castell”,
“Faber Castell”,
“Faber Castell”,
“Faber Castell”,
]

var precio=[
"$22.600",
"$22.600",
"$22.600",
"$22.600",
"$22.600",
"$22.600",
"$22.600",
"$22.600",
"$22.600",
"$22.600",
"$550",
"$550",
"$550",
"$550",
"$550",
"$550",
"$550",
"$550",
"$550",
"$550",
"$1190",
"$1190",
"$1190",
"$1190",
"$1190",
"$1190",
"$1190",
"$1190",
"$1190",
"$1190",

]

function Listaecolar(tipo, marca, precio){
this.tipo = tipo;
this.marca = marca;
this.precio = precio;}

for(var i = 0; tipo.length > i && marca.length > i && precio.length > i; i++){
var nuevaListaescolar = new Listaecolar(tipo[i], marca[i], precio[i]);
console.log(nuevaListaescolar)
}

Tomé fotocaptura porque escribí mucha cosa con todo y comentarios, ojalá a alguien le pueda servir.