Loop: for in

Como se mencionaba en la clase anterior, los objetos (`{}`) en Javascript no son iterables, por eso el método `for... of` no es compatible con ellos, pero no te preocupes que para ello tenemos el ciclo `for... in`! Este ciclo nos permite iterar sobre objetos enumerables, más especificamente sobre las propiedades de estos objetos! **OJO** 👀 este ciclo nos da el nombre de la propiedad en vez del valor de esta como sucedía con el ciclo `for... of` > 💡 [Aquí puedes encontrar la documentación del ciclo for...in](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...in)

🟡 **¿Qué sucede si utilizo un ciclo** `for ... in` **para un iterable?** Como se mencionó en la clase, si intentas recorrer un objeto con la estructura `for ... of`, existirá un error, porque **un objeto no es un iterable**. Por otro lado, si intentas recorrer un iterable con la estructura `for propiedad in iterable`, no obtendrás los valores de los elementos, sino los **índices de cada uno**. Esto se debe a que los iterables son objetos en JavaScript, donde su **propiedad es el índice de cada valor o elemento**. Por ejemplo: el *array* `["Python", "JavaScript", "Java", "C++"]`, en realidad, es el siguiente objeto. ```js let array = { "0": "Python", "1": "JavaScript", "2": "Java", "3": "C++" } ``` Entonces, si utilizar `for ... in`, lo que obtendrás es el **índice del iterable**. ```js let numeros = ["Python", "JavaScript", "Java", "C++"] for (let propiedad in numeros) { console.log(propiedad) // 0 1 2 3 } ``` Espero te haya servido. ¡Nunca pares de aprender! 💚

***Apuntes:*** ### **For of** Nos sirve para crear bucles con elementos iterables (string o array) ```js //for of para Arrays let menu = ['pambazo','quesadilla','pizza','tacos'] for (comida of menu){ console.log(comida); } ``` ### **For in** Nos sirve para crear bucles con elementos numerables (objetos) ```js // for in Objetos let listaCompra = { pan: 3, leche: 2, frutas: 6, carne: 4, especias: 7 } for (item in listaCompra){ console.log(item); } ``` 

## For in El bucle `for...in` en JavaScript es una estructura de control que se utiliza para iterar sobre las propiedades enumerables de un objeto. A diferencia del bucle `for...of`, que itera sobre los valores de un objeto iterable como un array o un string, `for...in` itera sobre todas las propiedades enumerables de un objeto, incluyendo aquellas heredadas de su prototipo. ### Sintaxis del Bucle `for...in` La sintaxis básica de `for...in` es la siguiente: `for (variable in objeto) {` ` // Código a ejecutar para cada propiedad` `}` * **variable**: Una variable que se asigna al nombre de cada propiedad durante cada iteración. * **objeto**: El objeto cuyas propiedades serán iteradas. ### Ejemplo Básico `let persona = {` ` nombre: "Juan",` ` edad: 30,` ` ciudad: "Madrid"` `};` `for (let propiedad in persona) {` ` console.log(propiedad + ": " + persona[propiedad]);` `}` ### Limitaciones y Consideraciones * **Orden de las Propiedades**: No se garantiza el orden en que se iteran las propiedades del objeto. Pueden no seguir el orden en que fueron definidas. * **Solo para Propiedades Enumerables**: `for...in` itera sobre las propiedades enumerables de un objeto. Las propiedades no enumerables (aquellas que tienen el atributo `enumerable` configurado como `false`) no se iteran. * **No es Adecuado para Arrays**: Aunque puede iterar sobre arrays en JavaScript, generalmente no es recomendado usar `for...in` para esto debido a su comportamiento no predecible con propiedades heredadas y la posibilidad de iterar sobre índices del array en lugar de valores.

Aprovecho este ejercicio practico para mostrar algunos articulos que me encantaria ver en PlatziConf 2024 ![]()

¿Qué es un objeto en programación? Los objetos en programación representan cosas del mundo real, así como conceptos abstractos con sus características y comportamientos específicos. Un objeto cuenta con su estructura interna que combina variables, funciones y estructuras de datos. Usando el nombre del objeto y la sintaxis según el lenguaje de programación, puedes visualizar los valores del objeto y llamar las funciones que tiene predefinidas. Los elementos de un objeto se dividen en dos categorías principales: **propiedades y métodos**. Las **propiedades**, también conocidas como **atributos**, incluyen información sobre el objeto. Por ejemplo, si consideramos un objeto Coche, algunas de sus propiedades serán: el color, la marca, el modelo o el año de fabricación. Los **métodos** definen las operaciones que se pueden realizar con el objeto. Por ejemplo, para el objeto Coche, los métodos podrían ser acelerar, frenar o girar. Continua: <https://ebac.mx/blog/objeto-en-programacion>

Un **string** es como una palabra o frase escrita, por ejemplo, "hola" o "buenos días". Un **array** es como una caja donde puedes guardar varias cosas, como números, letras o palabras, todas en su propio espacio. Ahora, un **objeto** es como un juguete avanzado, por ejemplo, un robot que tiene partes (propiedades) como su color, tamaño o nombre, y también puede hacer cosas (métodos) como caminar o hablar. Así que, mientras un string es solo texto y un array es una lista de cosas, un objeto puede tener mucha información y hacer cosas también. Por ejemplo, este sería un objeto: `let auto = {` ` color: "rojo",` ` modelo: 2022,` ` arrancar: function() {` ` console.log("El auto ha arrancado.");` ` }` `};`

por lo que vi en esta clase, los objetos en javascript se parecen a los diccionarios en python (llave:clave)

\# Entendiendo los bucles for...in en JavaScript Los bucles `for...in` son una característica poderosa de JavaScript que te permite iterar sobre las propiedades enumerables de un objeto. Veamos cómo funcionan y cuándo usarlos. ```js for (let key in object) { // código a ejecutar ``` \## Sintaxis básica \## Ejemplo práctico Supongamos que tenemos un objeto `persona`: ```js const persona = { nombre: "Ana", edad: 28, profesion: "Ingeniera" }; // Iterando sobre las claves (nombres de propiedades) for (let key in persona) { console.log(key); } // Salida: nombre, edad, profesion // Iterando sobre los valores for (let key in persona) { console.log(persona[key]); } // Salida: Ana, 28, Ingeniera ``` \## Puntos clave a recordar 1\. \*\*Propiedades enumerables\*\*: `for...in` itera sobre todas las propiedades enumerables, incluyendo las heredadas. 2\. \*\*Orden de iteración\*\*: No está garantizado un orden específico. 3\. \*\*Uso con arrays\*\*: No se recomienda para arrays, ya que puede incluir propiedades no numéricas. 4\. \*\*Verificación de propiedad\*\*: Es buena práctica usar `hasOwnProperty()` para excluir propiedades heredadas si es necesario. \## Cuándo usar for...in \- Ideal para objetos con propiedades dinámicas. \- Útil para depuración o cuando necesitas trabajar con nombres de propiedades.

¿Cómo alteramos los valores de las propiedades del objeto iterativamente con for...in? . Usando la variable del objeto y haciendo condiciones respecto a ella: ```js const power_tools = { drill: 47, saw: 92, hammer: 18, screwdriver: 65, grinder: 33, router: 7, sander: 21, jigsaw: 56, nailGun: 88, impactWrench: 12 } for (tool in power_tools) { if (tool.startsWith('s')){ power_tools[tool] = power_tools[tool] + 100 } } console.log(power_tools) /* { drill: 47, saw: 192, hammer: 18, screwdriver: 165, grinder: 33, router: 7, sander: 121, jigsaw: 56, nailGun: 88, impactWrench: 12 } */ ```...Aquí incrementamos en 100 el valor de la herramienta si esta empezaba por 's'

```js const listDeCompras = { manzana: 5, pera: 3, naranja: 2, uva: 1 }; let i = 1; console.log("########## LISTA DE FRUTAS OP. 1 ##########"); for(fruta in listDeCompras){ console.log(`${i}. ${fruta}`); i++; } console.log("########## LISTA DE FRUTAS OP. 2 ##########"); for(fruta in listDeCompras){ console.log(`${i}. ${fruta}: ${listDeCompras[fruta]}`); i++; } RESULTADO ########## LISTA DE FRUTAS OP. 1 ########## 1. manzana 2. pera 3. naranja 4. uva ########## LISTA DE FRUTAS OP. 2 ########## 5. manzana: 5 6. pera: 3 7. naranja: 2 8. uva: 1 ```

```js for(let in object) { } ```

*Object*.prototype.color = "rojo ";*Object*.prototype.PropiedadHeredada = "Otra propiedad Heredada " ; const ListaDeCompras ={ manzanas : 5, peras: 6, uvas: 9,} for (const frutas in ListaDeCompras) { if (Object.hasOwnProperty.call(ListaDeCompras,frutas)) { *// Object.hasOwnProperty es un metodo que permite verificar si la propiedad iterada es heredada o propia* console.log(`${frutas} es el nonmbre de la propiedad y su valor es : ${ListaDeCompras\[frutas]}.`); console.log(` Es una propiedad PROPIA del objeto ListaDeCompras `); }else{ console.log(`${ListaDeCompras\[frutas]} Es una propiedad Heredada`); }}