Arrays y objetos

Para recordar como se escribe length
lenGTH => Gallina Tiene Huevos

Yo logré imprimir todos los arrays con Object.entries:
.entries -->

const object = {
    name: "goku",
    age: 110,
    poder: "Kamehame haaaaaaaaaa",
    debilidad: "Jeringas",
}

console.log(Object.entries(object));

////////////////////////////// resultado:

[
  [ 'name', 'goku' ],
  [ 'age', 110 ],
  [ 'poder', 'Kamehame haaaaaaaaaa' ],
  [ 'debilidad', 'Jeringas' ]
]

Para ti JuanDC
Paréntesis ( )
Corchetes [ ]
Llaves { }
😎

Yo hice en el último ejercicio esto :3, sentí bonito que funcionara jaja

var amby = {
  nombre: "Achoque",
  localidad: "Michoacán",
  color: ["Verde Oscuro", "Café", "Moteado"]
}

function imprimirAmbys(arr){
  const achoques = Object.values(amby);
  achoques.forEach(function(element){
    console.log(element);
  })
}

Hola profe, yo usé este metodo que lo vi en la clase de javascript basico con el profesor Diego de Granda, no se que opina creo que es bastante corto.
var pc = {
marca: ‘lenovo’,
modelo: ‘laptop’,
año: 2016,
};
function objeto(object) {
for (var item in object) {
console.log(object[item]);
}
}
objeto(pc);

Documentación:

• Object.values()
• Object.keys()
• Object.entries()

Dejo mi aporte para la impresión de las propiedades de un objeto haciendo uso de Object.keys

function printAllObject(object) {
    if (object) {
        let keys = Object.keys(object);
        for (let key of keys) {
            console.log(`${key}: ${object[key]}`);
        }
    }
}

Al usar la funcion

printAllObject({ name: 'Ernesto Perez', age: '2', nickName: 'frailejon'})

Retorna
name: Ernesto Perez
age: 2
nickName: frailejon

Regla nemotécnica para recorrer Arrays usando su longitud:

i < arr.length --> para escribir siempre bien LENGTH,
G --> gallina
T–> tiene
H --> huevos

😉 no te lo olvidas más ❤️

Listas Y Objetos

1️.Responde las siguientes preguntas en la sección de comentarios:
¿Qué es un array?

• Es una lista de elementos, PUEDEN SER DE CUALQUIER TIPO.

¿Qué es un objeto?

• Es una lista de elementos PERO cada elemento tiene un nombre clave.

¿Cuándo es mejor usar objetos o arrays?

• Arrays cuando lo que haremos en un elemento es lo mismo que en todos los demás (la regla se puede incumplir). Mientras que un objeto cuando los nombres de cada elemento son importantes para nuestro algoritmo.

¿Puedo mezclar arrays con objetos o incluso objetos con arrays?

• Sí. Los arrays pueden guardar objetos. Y los objetos pueden guardar arrays entre sus propiedades.

2️.Crea una función que pueda recibir cualquier array como parámetro e imprima su primer elemento.

function imprimirPrimerElementoArray(arr) {
    console.log(arr[1])
}

3️.Crea una función que pueda recibir cualquier array como parámetro e imprima todos sus elementos uno por uno (no se vale imprimir el array completo).

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

4️.Crea una función que pueda recibir cualquier objeto como parámetro e imprima todos sus elementos uno por uno (no se vale imprimir el objeto completo).

function imprimirElementoPorElementoObjeto(obj) {
    const arr = Object.values(obj);
    for (let i = 0; i < arr.length; i++) {
        console.log(arr[i])
    }
}

Dime que tu profesor habla inglés sin decirme que habla inglés:
usa chistes anglosajones en español; “Dijo nadie nunca/Said no one ever” 🤣🤣

Puedes utilizar el ciclo For…in para recorrer un objeto sin necesidad de convertirlo en array.

Oh que chevere como resolvio ese ultimo ejercicio, yo la verdad no pude hacerlo, pero que manera mas intuitiva y facil de resolverlo el profe. Like

Les comparto mi respuestas:
Para imprimir un array use esto

let array= ["Pedro","jose","Armando","Sebastian"];

function callAllElements(array){
    for(let result of array){
        console.log(result);
    }
}
callAllElements(array)

Para imprimir el objeto simplemente lo convertí en un array y luego hice exactamente lo mismo

let object = {
    name: "Pedro",
    age: "Picapiedra",
    county: "CO"
}
function printElements(){
    for(let result of Object.values(object)){
        console.log(result);
    }
}
printElements(object)

Espero les ayude

// Con objetos 
const tipoSuscrip = [
    {suscription:"Free" , msg:"Solo puedes tomar los cursos gratis" },
    {suscription:"Basic" , msg:"Puedes tomar casi todos los cursos de Platzi durante un mes"},
    {suscription:"Expert" , msg:"Puedes tomar casi todos los cursos de Platzi durante un año"},
    {suscription:"ExpertPlus" , msg:"Tú y alguien más pueden tomar TODOS los cursos de Platzi durante un año"}
];

tipoSuscrip.forEach(function(elemento){
    console.log(Object.values(elemento));
});

Lo realice con el for/in

var fruta = {	nombre: "Perra", 
				nombreCientifico: "Pyrus communis", 
				Reino: "Plantae",
				Subreino: "Tracheobionta",
				División: "Magnoliophyta",
				Clase: "Magnoliopsida",
				Subclase: "Rosidae",
				Orden: "Rosales",
				Familia: "Rosaceae",
				Subfamilia: "Amygdaloideae2​",
				Tribu: "Maleae",
				Género: "Pyrus",
				Especie: "P. communis",
			};
			
			
function mostrarObjeto(obj) {
	for ( let valor in obj ) {
		console.log( valor + ": " + fruta[valor] );
	}
}

Resultado:
nombre: Perra
nombreCientifico: Pyrus communis
Reino: Plantae
Subreino: Tracheobionta
División: Magnoliophyta
Clase: Magnoliopsida
Subclase: Rosidae
Orden: Rosales
Familia: Rosaceae
Subfamilia: Amygdaloideae2​
Tribu: Maleae
Género: Pyrus
Especie: P. communis

Para complementar encontré esto en la pag de w3schools:

When to Use Arrays. When to use Objects:

• JavaScript does not support associative arrays.

• You should use objects when you want the element names to be strings (text).

• You should use arrays when you want the element names to be numbers.

let datos = {
nombre: “Carlos”,
apellido: “Lopez”,
edad: 22
}

function retornaObjeto (datos){

for (let [clave,valor] of Object.entries(datos)){
    console.log (clave +" "+ valor)
}

}

retornaObjeto (datos)

Mi aporte 😃

let arregloPrueba = ["perros", "gatos", "ratones", "jirafas", "rinos", "leones", "tortugas"];

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

print(arregloPrueba);

length, width y height causando problemas desde el principio de los tiempos jajaja 🤣

Hola, hice la misma investigacion, para averiguar como imprimier los valores de las propiedades de un objeto. En mi caso (me encuentro en el año 2023, Abril, y Platzi recien saco su curso de AI) use ChatGPT, y le pregunte por un metodo que me permitiera obtener los nombres de las propiedades de un objeto.
aqui el resultado de mi codigo:

para que no esten abriendo la consola de google y cerrando si quieren interpretar codigo practicarlo

yo utilizo esta herramienta https://runjs.app/

Claro es como pasa con los vectores de Java, cuando creamos arreglos dimensionales o bidimensionales. empezamos por la matriz indicándoles lo que deben hacer.

Esta es la opción que yo he hecho en la actividad 3 de este bloque, es un poco diferente pero funciona:

let array = ['Ana', 'Juan', 'Elena' ,'Rosa'];

function mostrarPrimerElemento(){
    document.write(array[0])
}
mostrarPrimerElemento();

() parentesis
[] corchetes
{} llaves
😄

let names = ["Juan", "Jose", "Maria", "Max"];

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

imprimirElementosArray(names);

ya entendí el objeto

Ojo con las mayúsculas y minúsculas, muy importantes, aun no aprendo xd

Signos de agrupación

- ( ) → paréntesis o paréntesis ordinarios.
- [ ] → corchetes o paréntesis angulares o paréntesis rectangulares.
- { } → llaves.
- | | → vínculos o barras.

A mi me gusta mucho este método para obtener las propiedades del objeto:

<code> 

const objetoDePrueba = {
    nombre: 'Manolito',
    apellido: 'Gambito',
    aficiones: ['Piano', 'Reggae', 'Estudiar JS', 'Fútbol', 'Leer'],
    verAficiones() {
        console.log(this.aficiones);
    },
    ciudad: 'Sevilla',
    trabajo: 'Codiguitos SL',
    parado: false,
    casado: false
}

function obtenerPropiedades(objetoComoParametro) {
    for (let valores in objetoComoParametro) {
        console.log(objetoComoParametro[valores]);
    }
}

obtenerPropiedadesObjeto(objetoDePrueba);

let obj = {
nombre: “Gabriel”,
apellido: “Puig”,
edad: 47
}

function prtArr(valor) {
const array = Object.values(valor);
for(let i= 0; i < array.length; i++ ){
console.log(array[i])
}
}

prtArr(obj);

Como convertir Objetos en Arrays

7/27 Arrays y objetos

Los arrays y objetos son la base fundamental con la que se pueden construir otros tipos de listas.

Un array es una lista de elementos sin nombre clave,

mientras que un objeto es una lista de elementos en la que cada elemento tiene un nombre clave.

Los objetos son útiles cuando se crean nuevos usuarios o cuando se necesitan guardar elementos sin nombre clave.

Es importante entender la diferencia entre los dos para saber cuándo usar uno u otro.

Para evitar que una función con ciclo for nos devuelva “undefined”, debemos asegurarnos de que la condición del ciclo sea menor y no menor o igual al tamaño del array.

Si la condición del ciclo es menor o igual, se ejecutará una vez más y, como los arrays comienzan en cero, si intentamos acceder a la posición que corresponde a la longitud del array, la cual no existe, nos devolverá un “undefined”.

Además, si queremos imprimir en una línea cada propiedad de un objeto, debemos convertir el objeto en un array con la función Object.values, lo que nos permitirá imprimir cada valor en una línea diferente.

<let silla = {
    color: 'cafe',
    Ancho: 87,
    Largo: 120,
    Modelo: 2023,
    Marca: 'Rimax',
function imprimirPropiedadesdelObjecto(obj) {
      for (let key in obj) {
        console.log(obj[key]);
      }
  }
  imprimirPropiedadesdelObjecto(silla);//cafe,87,120,2023,Rimax

  };> 

Esta es mi solucion para el ultimo ejecicio

function imprimirObjeto (obj){
for (let key in obj) {
		console.log(key + ':' + obj[key]);
	}
}

mi solución

function imprimir(valor){

    if(Array.isArray(valor)){
        for (const iterator of valor) {
            console.log(iterator)
        }
        return ;
    }

    for (const key in valor) {
       console.log(valor[key])
    }
   
}


const obj ={
    Nombre:"Lucario El Puerco Chaman",
    edad:29,
    habilidad:"Correr",
}

imprimir(obj)

imprimir([1,2,3,4,5,6]);
 

let numeros = { uno: 1, dos: 2, tres: 3 };

function convertirArray(convertir) {
arrayConvertido = Object.values(convertir);
return arrayConvertido;
}

function imprimir() {
arrayConvertido.forEach(function (resultado2) {
console.log(resultado2);
});
}

convertirArray(numeros);
imprimir();

let miAuto = {
	marca: "Mazda",
	modelo: "MAZDA2",
	anio: 2022,
	puertas: 4,
	color: "Plateado"
};

let persona = {
    nombre: "sonia",
	nacionalidad: "Mexicana",
	anioDeNacimiento: 1995
};
function imprimir(objeto){
    for(let elemento in objeto){
        document.write(elemento + ": ")
        document.write(objeto[elemento]);
        document.write("<br />")
    }
}

imprimir(miAuto);
document.write("<br />")
imprimir(persona);
document.write("<br />")

var vehiculo = {

  brand: "Honda",
  model: "Civic",
  year: 2001,

};
function readObject(vehiculo) {
	const array = Object.values(vehiculo);
  	for (let i = 0; i < array.length; i++) {
    		console.log(array[i]);
 	}
 }
readObject(vehiculo);

• ¿Qué es un array?
  Un array es una estructura de datos en JavaScript que se utiliza para almacenar y organizar múltiples valores en una sola variable. Los elementos en un array se almacenan en posiciones numeradas llamadas índices y se acceden mediante estos índices.

• ¿Qué es un objeto?
  Un objeto es una entidad independiente que puede tener propiedades y métodos. En JavaScript, un objeto es una colección de pares clave-valor, donde las claves son cadenas (o símbolos) y los valores pueden ser de cualquier tipo de dato, como números, cadenas, booleanos, arrays u otros objetos. Los objetos en JavaScript se utilizan para representar entidades complejas con propiedades y comportamientos específicos.

• ¿Cuándo es mejor usar objetos o arrays?
  La elección entre usar objetos o arrays depende del contexto y de los requisitos específicos del programa. Aquí hay algunas consideraciones generales:

  • Arrays: Se utilizan cuando necesitas una colección ordenada de elementos del mismo tipo o similar. Los arrays son útiles cuando quieres acceder a elementos por índice y realizar operaciones como recorridos, búsqueda o filtrado de elementos. Por ejemplo, una lista de nombres o una serie temporal de datos numéricos se pueden representar como arrays.

  • Objetos: Se utilizan cuando necesitas almacenar y organizar datos más complejos con propiedades específicas y comportamientos asociados. Los objetos son útiles cuando deseas acceder a los datos mediante claves descriptivas en lugar de índices numéricos. Por ejemplo, para representar una persona con propiedades como nombre, edad y dirección, un objeto sería una elección adecuada.

• ¿Puedo mezclar arrays con objetos o incluso objetos con arrays?
  Sí, en JavaScript puedes mezclar arrays con objetos e incluso objetos con arrays. Los arrays pueden contener objetos como elementos, lo que permite almacenar colecciones de objetos relacionados. Del mismo modo, los objetos pueden contener arrays como propiedades, lo que permite almacenar conjuntos de valores relacionados dentro de un objeto. Esta flexibilidad permite estructurar y organizar datos de manera más compleja y adaptable según las necesidades del programa.
  2️⃣ Crea una función que pueda recibir cualquier array como parámetro e imprima su primer elemento.

function imprimirPrimerElemento(array) {
  if (array.length > 0) {
    console.log("El primer elemento del array es: " + array[0]);
  } else {
    console.log("El array está vacío.");
  }
}

// Ejemplo de uso
const miArray = [1, 2, 3, 4, 5];
imprimirPrimerElemento(miArray);

3️⃣ Crea una función que pueda recibir cualquier array como parámetro e imprima todos sus elementos uno por uno (no se vale imprimir el array completo).

function imprimirElementos(array) {
  for (let i = 0; i < array.length; i++) {
    console.log("Elemento " + (i + 1) + ": " + array[i]);
  }
}

// Ejemplo de uso
const miArray = ["Hola", "mundo", "!"];
imprimirElementos(miArray);

4️⃣ Crea una función que pueda recibir cualquier objeto como parámetro e imprima todos sus elementos uno por uno (no se vale imprimir el objeto completo).

function imprimirElementosObjeto(objeto) {
  for (let clave in objeto) {
    console.log(clave + ": " + objeto[clave]);
  }
}

// Ejemplo de uso
const miObjeto = { nombre: "Juan", edad: 25, profesion: "Programador" };
imprimirElementosObjeto(miObjeto);

Yo use for in :

let user = {
  name : "David",
  lastName : "Henao",
}

for (let u in user) {
  console.log(`${u} : ${user[u]}`);
}

Sí solo quieren los valores sería :

for (let u in user) {
  console.log(`${user[u]}`);
}

Yo me confundí e hice un arreglo con objetos dentro, después imprimí objeto por objeto, pero bueno ya aprendí como imprimir los valores de un objeto con la solución del profe.

const cars = [
  {
    model: "Mini",
    Year: 2003,
    Color: "Grey",
  },
  {
    model: "Neon",
    Year: 2017,
    Color: "Blue",
  },
  {
    model: "Mazda 3",
    Year: 2021,
    Color: "Red",
  },
];

function stockCars(object) {
  cars.forEach(item => console.log(item));
//   for (let index = 0; index < object.length; index++) {
//     console.log(object[index]);
//   }
}

stockCars(cars);

Les dejo el ejemplo de como imprimir objeto por objeto que están dentro de un array, con forEach y con un ciclo for, esto lo aprendí en el curso de manipulación de arrays con JavaScript.

Extendí la función para que tambien imprima los elementos del array que se encontraba dentro de comidasFavoritas.

usuario =  {
	nombre: "Fulanito",
	edad: 3, 
	comidasFavoritas: ["Pollo", "Palta"]
}


function imprimirElementoPorElementoObjeto(obj){
	const arr = Object.values(obj);
	for(let i = 0; i < arr.length; i++){
        if (Array.isArray(arr[i])) {
            arr[i].forEach(element => {
                console.log(element);
            });
        } else {
            console.log(arr[i])
        }
	}
}

Utilize el método isArray() del objeto nativo que proporciona JavaScript Array. El cual, si el objeto es un Array, devuelve true; y false, en cualquier otro caso.
Dejo link a la documentación:
Array.isArray() docs

function ImprinirTodoElObjecto(objeto) {
const llaves = Object.keys(objeto);

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

}

Aquí mi aporte:

function imprimir_objeto(objeto){
    for (var propiedad in objeto){
      console.log(propiedad + ": " + objeto[propiedad]);
    } 
  }

function imprimir(objeto) {

  let claves = Object.keys(objeto);

  for (let i = 0; i < claves.length; i++) {
    console.log(claves[i] + " " + objeto[claves[i]]);
  }
}
imprimir({a: 2, d:3, e:5});

Hice mis soluciones procurando closures y arrow functions jeje

🎯Solucion al ejercicio 3

• Usando for … in documentacion
  La instrucción for-in itera sobre todas las propiedades enumerables de un objeto.

const object = { nombre: "Juan",
  localidad: "Castro",
  color: ["Verde Oscuro", "Café", "Moteado"]};

for (const property in object) {
  console.log(`${property}: ${object[property]}`);
}

// nombre: Juan
// localidad: Castro
// color: Verde Oscuro,Café,Moteado

Lo encontre en Google 😋

La primera vez no salió y tuve que abrir mis apuntes.

La primera vez: Horrible, sin embargo el concepto de los ciclos está claro.
Empezó un bucle infinito y tocó reiniciar el Portatil.

function(arr) {
	for(let arr = 0; arr.length <= arr.length; arr.length++) {
	console.log("funcion que imprime Array uno por uno: " + arr[arr.length])
}
}
imprimirElementoPorElemento(["Daniel", "Maria", "Thais", "Marina"])

Después de ver los apuntes: Todo funciona a la perfección.

function imprimirElementoPorElemento(arr) {
    for(let i = 0; i < arr.length; i++ ) {
        console.log("Array que imprime sus elementos uno por uno: " + arr[i])
    }
}
imprimirElementoPorElemento(["Daniel", "Maria", "Thais", "Marina"])

Mi solución

let persona ={
    nombre: 'Obed',
    apellido: 'Tzay',
    edad: 23
}
const imprimirObjeto = person =>{
    for (const key in person) {
        console.log(`mi ${key} es: ${person[key]}`);
    }
}
imprimirObjeto(persona);

Imprimi los elementos de los objectos con un ciclo for in

function allObjForIn(obj) {
    for (const element in obj) {
        console.log(obj[element]);
    }
}

Hola platzi amigos, existe un tipo de ciclo for llamado For In, el cual nos permite iterar un objecto a traves de sus keys, por ejemplo:

// Declaramos un objeto de ejemplo
let obj = {
    nombre: 'Fernando',
    edad: 21, 
    userName: 'fosuna'
}
//declaramos la funcion para imprimir los valores
function imprimirValoresObj(obj){ // obj representa un objecto cualquiera
    for(i in obj){
	
// Analizemos el for de arriba
// (i) representa las keys (el nombre de las propiedades)
//en cada vuelta tomara una key y ese sera el valor de i
// en este caso si mandamos nuestro objeto obj, en la primera vuelta i valdra
// nombre, en la segunda valdra edad y en la tercera UserName

        console.log(obj[i]) // aqui accedemos al valor del objeto usando la variable i
    }
}
imprimirValoresObj(obj) // ejecutamos la funcion

El codigo anterior imprime:
Fernando
21
fosuna

Esta es la forma con la cual yo resolvi el ejercicio, desde mi punto de vista, es mucho mas practico cuando queremos iterar un objeto que transformarlo a un array, cualquiera de las 2 formas esta excelente!!!

🦄✨

JavaScript es muy interesante ;-;
Yo entendía por un ‘objeto’ a la instancia de una clase, pero dicho concepto está más relacionado con la Programación Orientada a Objetos. Sin embargo, en JavaScript se puede determinar como objeto a un tipo de dato que tiene propiedades, tal como una clase podría tener atributos.
.
La diferencia que encuentro es que la clase se puede reutilizar como una plantilla para distintos objetos con los mismos atributos o métodos. Pero en si, los conceptos vendrían a ser los mismos.

Yo lo hice así

function printObjectElements(object) {
    for(let items in object) {
        console.log(object[items]);
    }
}

Como traer un elemento por uno del array
Una de muchas soluciones
podemos intentar en el for que la variable i < 3

podemos usar ciclo while o do while.

function imprimirPrimerElementoArray(arr) {
    for(let i = 0; i <=2; i++ ){
        console.log(arr[i])
    }  
}

Utilice el forEach para los arrays y la opcion Object.entries para iterar los objetos.

let guitars= ["gibson","Jackson","fender"];

//Imprime primer elemento del array
 function firstElement(array){
	console.log(array[0]);
}
firstElement(guitars);

//Listar Array
let list = " ";
guitars.forEach(allElements);

function allElements(item,index){
    list = item + " " + index;
    console.log(list);
}


var myCar = {
    make: 'Ford',
    model: 'Mustang',
    year: 1969
};

//Listar Objetos
Object.entries(myCar).forEach(([key, value]) => {
    let objList = key + ": " + value;
    console.log(objList)
  });

Aqui un poco de codigo que puede ayudar a comprender un poco mas el tema:

// code
[1,2,3].push(4); // [1,2,3,4]
[1,2,3].pop(); // [1,2]
[1,2,3].shift(); // [2,3]
[1,2,3].unshift(0); // [0,1,2,3]
['a','b'].concat('c'); // ['a', 'b', 'c']
['a','b','c'].join('-'); // a-b-c
['a','b','c'].slice(1); // ['b','c']
['a','b','c'].indexOf('b'); // 1
['a','b','c'].includes('c'); // true
[3,5,6,8].find((n) => n % 2 === 0); // 6 - el resto de dividir 6/2 = 0
[3,5,6,8].findIndex((n) => n % 2 === 0); // 2 - el primer elemnto en cumplir la condicion se enceuntra en la posicion 2
[3,5,6,8].map((n) => n * 2); // [6, 10, 12, 16]
[3,5,6,8].filter((n) => n % 2 === 0); // [6, 8]
[3,5,6,8].reduce((acumulador, currentValue) => acumulador + currentValue); // 22
[3,5,6,8].every((n) => n < 10); // true - la condicion de cumple
[3,5,6,8].some((n) => n > 6); // true - la condicion de cumple
[3,5,6,8].reverse(); // [8, 6, 5, 3]
[3,5,6,8].at(1); // 5
[3,5,6,8].at(-2); // 6

Más info aqui

Ultimo ejercicio, mi solucion 😃

let myObject ={
    nickName: ": alma",
    level: ": expert",
    position: ": my pet",
}

function printMyObject(object){
    for(let property in object){
    console.log(property + " " + object[property]);
    } 
}

printMyObject(myObject); 

Listas
1.- Responde:

• ¿Qué es un array?
  Es un objeto tipo lista que almacena una serie de datos organizados en un índice y separados por comas.

• ¿Qué es un objeto?
  Estructura de datos que almacena datos en “clave : valor”, entre llaves y separados por comas.

• ¿Cuándo es mejor usar objetos o arrays?
  Un array guarda valore simples, por ejemplo, una lista de nombres o una lista de edades. Un objeto guarda más datos, propiedades con distintos valores. Por ejemplo un perfil completo: nombre, profesión, edad y más.

• ¿Puedo mezclar arrays con objetos o incluso objetos con arrays?
  Si . Un objeto puede tener arrays por dentro y un array puede guardar a varios objetos.

2.- Crea una función que pueda recibir cualquier array como parámetro e imprima su primer elemento:

3.- Crea una función que pueda recibir cualquier array como parámetro e imprima todos sus elementos uno por uno:

4.- Crea una funcionque pueda recibir cualquier objeto como parámetro e imprima todos sus elementos uno por uno:
No me salió como debería 😁

Haciendo el curso con TypeScript

      function printFirstElement(...params: (string | number)[]):void{
        console.log(params[0]);
      }
      printFirstElement('hola', 1,23,4,5,'hola');

      function printInArray(parametros: (number | string)[]):void{
        console.log(parametros[0]);
      }

      function printAll(parametros: (number | string)[]):void{
        parametros.forEach((item) => {
          console.log(item);
        });
      }
      let myArray: (string | number)[] = [254,35,967,6,84,95,7,'con','strings','hi'];
      printAll(myArray)

Me parece más apropiado para lo de imprimir las propiedades del objeto:

function imprimirPropiedadPorPropiedad(objeto){
	for (property in objeto){
		console.log(property + ": " + objeto[property]);
	}
}

con forEach es un poco mas sencillo

let personas=[“monse”,“caro”,“emilio”]

personas.forEach(function(persona){console.log(persona)})

Imprime todos lo elementos de un array.

nameArray.forEach(e => console.log(e))

Documentación. 👆

Ya que había que investigar, me pareció esta una mejor opción

function showProps(obj) {
  for (let i in obj) {
    console.log(`${obj[i]}`);
  }
}

El ultimo punto lo hice de esta manera

function personObject(numObject){
    

    for (const key in numObject) {
      
        console.log(key+": " +numObject[key]);
        
    }

 }

 const persona={
    nombre:"juan",
    apellido:"rodriguez",
    edad:22
}

 personObject(persona);

Mis apuntes en Notion 😄

APUNTES

function imprimirPorElemento(arreglo){
	for (let i;i++;arreglo[i]){
		console.log(arreglo[i]);
	}
}

imprimirPorElemento(['manzana','Peras','Durazno']);

Así fue que resolví . la ultima pregunta del test
let objeto_1 = {
nombre: ‘Leticia’,
apellido: ‘Lopez’
}
let objeto_2 = {
apodo: ‘Julieta’,
edad: 23,
deporte: ‘beisbol’
}
const imprimir_objeto = (objeto) => {
let propiedades = Object.entries(objeto);
propiedades.forEach(function(elemento){
console.log(${elemento});
})
};
imprimir_objeto(objeto_1);
imprimir_objeto(objeto_2);

Listas

1️⃣ Responde las siguientes preguntas en la sección de comentarios:

• ¿Qué es un array?

  Es una estructura de datos varios que pueden ser anidados.

• ¿Qué es un objeto?

  Es una estructura de datos que tiene propiedades y métodos simulando objetos reales.

• ¿Cuándo es mejor usar objetos o arrays?

  Cuando tenemos propiedades relacionadas a una entidad y esa entidad es repetitiva, es mejor usar objetos.
  Cuando tenemos un conjunto de objetos de alguna manera relacionados es mejor usar arrays.

• ¿Puedo mezclar arrays con objetos o incluso objetos con arrays?

  Sí, y de esta forma: los arrays pueden tener objetos como elementos; podemos usar el spread operator para convertir arrays en objetos.

  const stuff = [{a: 10},{b: 20},{c: 40}];
  
  const arr = ["foo", "boo", "zoo"];
  const obj = {...arr};
  console.log(obj);
  // output
  {0: "foo", 1: "boo", 2: "zoo"}
  

2️⃣ Crea una función que pueda recibir cualquier array como parámetro e imprima su primer elemento.

const seasons = ['winter', 'spring', 'autumn', 'summer'];
let mySeason = (arr) => console.log(arr[0]);
mySeason(seasons);

3️⃣ Crea una función que pueda recibir cualquier array como parámetro e imprima todos sus elementos uno por uno (no se vale imprimir el array completo).

const racquetSports = ['Tennis', 'Ping Pong', 'Squash', 'Badminton', 'Paddle', 'Racquetball', 'Fronton', 'Pickleball', 'Beach Tennis', 'Touchtennis'];
let sports = arr => { arr.forEach(sport => console.log(sport)) }
sports(racquetSports);

4️⃣ Crea una función que pueda recibir cualquier objeto como parámetro e imprima todos sus elementos uno por uno (no se vale imprimir el objeto completo).

let skills = {'softskill': 'Pleasurable', 'hardskill': 'Git'};
let mySkills = arr => {for(let skill in skills) console.log(`👉🏻 ${skill}: ${skills[skill]}`)};
mySkills();

objecr.values convertir un objeto en array :)

Es mejor usar el “for…in” para estos casos de recorrer un objeto.

function solution(objt){
    for(let key in objt){
        console.log(objt[key])
    }
}

solution({
    nombre: "Juan",
    apellido: "Moreno",
    edad: 21,
    padres: [
        "Blanca",
        "Jhon"
    ]
});

const array1 = ['uno', 'dos', 'tres'];
const obj = {
     nombre: 'Jonathan',
     apellido: 'Olmedo',
     Edad:23
 };

const imprimircadaelemento = (arr) => {
    arr.map((item) => {
        console.log(item)
    })
};

imprimircadaelemento(array1);
imprimircadaelemento(Object.values(obj));

Otra forma de imprimir cada elemento del array es utilizar el for (const element of array)

const array = [1, 3, 4, 6, 7, 9, 20];

for (const element of array){
	console.log(element);
}
// 1, 3, 4, 6, 7, 9, 20

Mi solución fue con un for in. En el ejemplo de mi código esta muy simplificado pero con la auto ayuda de vsCode nos da un ejemplo de codigo con detalles.

function imprimirObjeto(obj){
    for (const o in obj) {
        const valor = obj[o];
        console.log(valor)
    }
}

imprimirObjeto({
    name: 'samuel',
    apellido: 'morales',
    edad: 23,
})

function array(arreglo){
return console.log(arreglo[0]);
};
array([“Hola”, “Peru”, 4]);

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

//llamamos al la funcion

imprimir([“Hola”, 2, true, “Eduardo”]);
Hola
2
true
Eduardo

Solución alternativa del ejercicio 4:

/*
   Aclaraciones previas:
   - La funcion "cl()" solo es una función mia auxiliar que uso para ejecutar un console log con menos caracteres.
   - La constante contenedor es por que tengo un html donde lo muestro en un div#contenedor el resultado.
   - Este código es una alternativa a transformar el valor de las propiedades en un array.
*/

const contenedor = document.querySelector("#mostrar");

let friend = {
    "name" : "Miguel",
    "phone" : "600 000 001",
    "mail" : "[email protected]",
    "edad" : 40,
    "maried" : false  
}

// Esta función la mantengo en todos los ejercicios porque me sirve para mostrar resultados en un html
let imprimirResultado = (resultado)=>{
    // uso dos formas de visualizar los resultados
    contenedor.innerHTML+= `<br> ${resultado}`;  
}

// Función para recorrer
let recorreValoresObjeto = (obj)=>{
    for(let nombrePropiedad in obj){
        let resultado = `Este es el valor de la propiedad ${nombrePropiedad}: ${obj[nombrePropiedad]} <br>`;
        imprimirResultado(resultado); //mostrar resultado en HTML
        cl(resultado.replace('<br>',''));  // mostrar resultado por consola eliminando los "<br>"
    }
}

recorreValoresObjeto(friend); // Llamada a ejecutar función

Como dijo el profesor, no había manera de recorrer las propiedades de un objeto.
Lo primero que pensé fue pasar de manera convencional el objeto a un Array.
e.j.

miAuto = {
    marca: "Tesla",
    modelo: "Modelo S",
}
let arrayDeprueba = miAuto;

/* La Array obtiene el objeto completo y no sus propiedades como tal, por lo tanto no es posible recorrerlas "una por una" usando [0] */

Luego de buscar y sentir la emoción equivalente a un jugador de DarkSouls.
Puedo encontrar la solución, o al menos funciona.

/* Si utilizamos el metodo: Object.keys(nombreDelObjeto), aquí si devuelve las propiedades de un objeto como si fueran Arrays pudiendo recorrerlas con [0] */
let miAuto = {
    marca: "Tesla",
    modelo: "Model S",
    annio: 2012
}
let claves = Object.keys(miAuto);
for(let i = 0; i < claves.length; i++) {
    console.log(miAuto[claves[i]]);
}

<let obj = {
    nombre:"Marcos",
    edad:"31",
    profesion:"Ing de sistemas"
}

function imprimeObjeto(obj){
   
    var elementos= Object.entries(obj);

    for(var i = 0; i < Object.keys(obj).length;i++){
        console.log(elementos[i]);
    }
    
}> 

Yo lo hice de otra forma , con utilize for in

Dejo mi aporte:

var object={
    number: 1,
    model: "tesla",
    year: 2022,
    color: "red"
};
function exit(param){
    for(var params in param){
        console.log(`${params}: ${param[params]}\n`);
    }
};

exit(object);

Resultado:

number: 1
model: tesla
year: 2022
color: red

Muchas gracias a esa pregunta trampa del objeto me hizo aprender muchisimo me gustan mucho esos tipos de retos

Creo que usando el for in es mas sencillo imprimir los valores de un objeto. Y si es un array for of.

const obj = {
    nombre:"Fulanito",
    edad: 3,
    comidasFavoritas:["pollo frito","vegetales"],
};

const printObject = (obj)=>{

    for (element in obj){
       console.log(obj[element]);
    }
    
}

Gracias a los dioses de la programación, dí con la clase correcta, para resolver el útimo ejercicio

https://platzi.com/clases/1815-ecmascript-6/25944-que-se-implemento-en-es8/

en donde nos muestra que, de conformidad con el ECMAScript versión es8, si tienes on objeto

const cdProjektRed = {
  game: 'Cyberpunk 2077',
  year: '2020',
  country: 'Poland'
}

puedes reconvertir el objeto a un array, utilizando el método de Object.values, para reconvertir este objeto a un array, y así obtener los valores en forma de array

const entries = Object.values(cdProjektRed);

como ya tienes el objeto en forma de array, utilizas un ciclo para imporimir tales valores

for(let i=0;i<entries.length;i++){
  console.log(entries[i]);
}
Cyberpunk 2077
2020
Poland

en mi caso, el problema de crear una funcion que reciba cualquier objeto lo resolvi asi porque queria que imprima no solo el valor sino tambien el nombre del valor

let pokemondetails = {nombre: "Chikorita", numPokedex: 152, tipo: "Planta", generacion: "Segunda", habilidad: "Espesura"};

let improbj = function (anyobject) {

    for (let property in anyobject) {
        console.log (`${property}: ${anyobject[property]}`)
    }
}

con el for in lo resolví sin problema

Yo utilicé arrows function y map.

const imprimeArray = arrays2 => arrays2.map(element=> console.log(element))
imprimeArray([1,3,7,86,5]);

¿Cuándo es mejor usar objetos o arrays?

Un Array, para mi, es mejor cuando todos los datos que estan alli representan un mismo tipo… valor… mmm… ejemplo:

nombres=[‘Juan’, ‘Ruben’, ‘Sergio’]
productos=[‘camisa’, ‘pantalon’, ‘tenis’]

y el objeto para una representación de datos especificos de un solo elemento o una abstracción del mundo… mmm… ejemplo:
estudiante = {
nombre:" “,
apellido:” “,
edad:” "
}

Y que tal si tenemos una lista de clientes:

clientes = [ 
	{
		nombre: "cliente1",
		identificación: 123456789
	},
	{
		nombre: "cliente2",
		identificación: 987654321
	}
]

Yo puse en practica los de llamar a una función dentro de otra función para hacer un poco más legible mi código.

function lista(arr){
            for(i=0; i<=arr.length; i++){
                console.log(arr[i]);
            }
        }

function listaObjeto(obj){
            const objeto = Object.values(obj);
            lista(objeto);
        }

const obj = {
            nombre: "Carlos",
            apellido: "Villatoro",
            edad: 25,
        }

listaObjeto(obj);

En el ejercicio # 2, utilice un método de “vaciar” el array con .shift e ir mostrando los elemento que se van eliminando uno por uno.
Así se listan todos también:

function lista (arr) {
    for (i=arr.lenght; i=arr.length; i--) {
        elementoArray = arr.shift();
        console.log (elementoArray);
    }
}

lista (["come", "duerme", "programa", "repite"]);

En el ejercicio # 2, utilice un método de “vaciar” el array con .shift e ir mostrando los elemento que se van eliminando uno por uno.
Así se listan todos también:

function lista (arr) {
    for (i=arr.lenght; i=arr.length; i--) {
        elementoArray = arr.shift();
        console.log (elementoArray);
    }
}

lista (["come", "duerme", "programa", "repite"]);

En el ejercicio # 2, utilice un método de “vaciar” el array con .shift e ir mostrando los elemento que se van eliminando uno por uno. Así se listan todos también:

function lista (arr) {
    for (i=arr.lenght; i=arr.length; i--) {
        elementoArray = arr.shift();
        console.log (elementoArray);
    }
}

lista (["come", "duerme", "programa", "repite"]);

😃 Arrays y objetos
1.- Responde las siguientes preguntas en la sección de comentarios:
¿Qué es un array?
Es una estructura de datos tipo objeto que almacena una lista ordenada de valores.
¿Qué es un objeto?
Es una entidad independiente con propiedades y una propiedad es la asociación entre un nombre (o clave) y un valor.
¿Cuándo es mejor usar objetos o arrays?
Es mejor usar los arrays cuando almacenamos múltiples valores de una sola variable y los objetos cuando almacenamos múltiples valores de múltiples variables.
¿Puedo mezclar arrays con objetos o incluso objetos con arrays?
Sí.

2.- Crea una función que pueda recibir cualquier array como parámetro e imprima su primer elemento.

function miFuncion(array){
    console.log(array[0]);
}
var input = prompt('Ingresar un array (separando los argumentos solo con una coma):');
var array = input.split(',');
miFuncion(array);

3.- Crea una función que pueda recibir cualquier array como parámetro e imprima todos sus elementos uno por uno (no se vale imprimir el array completo).

function miFuncion(array){
    for(var i = 0;i<array.length;i++){
        console.log(array[i]);
    }
}
var input = prompt('Ingresar un array (separando los argumentos solo con una coma):');
var array = input.split(',');
miFuncion(array);

4.- Crea una función que pueda recibir cualquier objeto como parámetro e imprima todos sus elementos uno por uno (no se vale imprimir el objeto completo).

function miFuncion(object){
    array= Object.values(object);
    for(var i = 0;i<array.length;i++){
        console.log(array[i]);
    }
}
var miObjeto = {
  nombre: 'Luigi',
  primerApellido: 'del Carpio',
  segundoApellido: 'Mendiola'
};
miFuncion(miObjeto);

Para imprimir los valores de las propiedades de un objeto uno por uno sin necesidad de convertirlo a un arreglo podemos usar el ciclo for in:

En w3schools.com puedes encontrar la explicación del ciclo for in.

Con respecto a lo de la diferencia entre array y objeto creo que falto el punto clave del array, que al final es guardar una colección de elementos (por algo es un tipo de lista), yo lo cambiaría así:
Arrays para cuando se requiere guardar una colección de datos, del mismo tipo o no, incluso objetos y otros arrays. Objeto cuando ocupamos representar un objeto real en memoria por medio de atributos y sus valores (como dice Juan, el nombre del elemento importa).

Para añadir, en la universidad tenía un profesor que nos decía que como buena práctica en programación (orientada a objetos), es que siempre y cuando podamos ejecutar un ciclo con un método propio del elemento optáramos por esté en vez de un for o while que son correctos pero que “son llamados por algo externo en vez del objeto”, esto tiene un nombre pero no me acuerdo cuál era. Por lo anterior opté por el forEach visto en el curso básico para mantener esta responsabilidad en el objeto mismo, aquí mi solución:

let myArray = ["Element1","Element2","Element3"];

function myElements(userArray)
{
    userArray.forEach(element => {
        console.log(element);
    });   
}

myElements(myArray);

Los últimos dos los hice usando For/of y for/in

Array

let frutas = ["manzana", "platano", "Cereza", "Fresa"];

function readFrutas(array){
    for(let x of array){
        console.log(x); 
    }
}

Objeto

let frutas = {
    modelo: "grande",
    color: "rojo"
};

function readObject(objeto)
{
    for(let key in objeto){
        console.log(objeto[key]);

    }

Es interesante saber como en este caso el for/of queda perfecto para los arrays y el for/in para los objetos.

para iterar cada elemento

let arr=['ana','claudia','maria'];
arr.map(element => {
    console.log(element);
});

for (const key of arr) {
    console.log(key);
}