From 96d99aae5e2177fb175fe07284363acf41022cd3 Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Thu, 23 Jul 2020 17:47:04 -0500 Subject: [PATCH 01/32] Update --- 1-js/04-object-basics/01-object/article.md | 44 +++++++++++----------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index 513f2f3e3..4f8b53152 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -1,55 +1,55 @@ -# Objects +# Objetos -As we know from the chapter , there are eight data types in JavaScript. Seven of them are called "primitive", because their values contain only a single thing (be it a string or a number or whatever). +Como aprendimos desde el capítulo , hay ocho tipos de datos en JavaScript. Siete de ellos se denominan "primitivos", porque sus valores contienen solo un dato (sea una cadena, un número o lo que sea). -In contrast, objects are used to store keyed collections of various data and more complex entities. In JavaScript, objects penetrate almost every aspect of the language. So we must understand them first before going in-depth anywhere else. +En contraste, los objetos son usados para almacenar colecciones aseguradas de varios datos y entidades más complejas. En JavaScript, los objetos penetran casi todos los aspectos del lenguaje. Por lo tanto, debemos comprenderlos primero antes de profundizar en cualquier otro lugar. -An object can be created with figure brackets `{…}` with an optional list of *properties*. A property is a "key: value" pair, where `key` is a string (also called a "property name"), and `value` can be anything. +Un objeto se puede crear usando corchetes `{…}` con una lista opcional de *propiedades*. Una propiedad es un par "clave: valor", donde `key` es una cadena (también llamada "nombre de la propiedad"), y `value` puede ser cualquier cosa. -We can imagine an object as a cabinet with signed files. Every piece of data is stored in its file by the key. It's easy to find a file by its name or add/remove a file. +Podemos imaginar un objeto como un gabinete con archivos firmados. Cada pieza de datos es almacenada en su archivo por la clave. Es fácil encontrar un archivo por su nombre o agregar / eliminar un archivo. ![](object.svg) -An empty object ("empty cabinet") can be created using one of two syntaxes: +Se puede crear un objeto vacío ("gabinete vacío") utilizando una de dos sintaxis: ```js -let user = new Object(); // "object constructor" syntax -let user = {}; // "object literal" syntax +let user = new Object(); // cintaxis del "construtor de objetos" +let user = {}; // sintaxis del "objeto literal" ``` ![](object-user-empty.svg) -Usually, the figure brackets `{...}` are used. That declaration is called an *object literal*. +Regularmente, {...}se utilizan los corchetes. Esa declaración se llama *objeto literal*. -## Literals and properties +## Literales y propiedades -We can immediately put some properties into `{...}` as "key: value" pairs: +Podemos poner inmediatamente algunas propiedades dentro de `{...}` como pares "clave: valor": ```js -let user = { // an object - name: "John", // by key "name" store value "John" - age: 30 // by key "age" store value 30 +let user = { // un objeto + name: "John", // Por la clave "name" se almacena el valor "John" + age: 30 // Por la clave "age" se almacena el valor 30 }; ``` -A property has a key (also known as "name" or "identifier") before the colon `":"` and a value to the right of it. +Una propiedad tiene una clave (también conocida como "nombre" o "identificador") antes de los dos puntos `":"` y un valor a la derecha -In the `user` object, there are two properties: +En el objeto `user` hay dos propiedades: -1. The first property has the name `"name"` and the value `"John"`. -2. The second one has the name `"age"` and the value `30`. +1. La primer propiedad tiene el nombre `"name"` y el valor `"John"`. +2. La segunda tienen el nombre `"age"` y el valor `30`. -The resulting `user` object can be imagined as a cabinet with two signed files labeled "name" and "age". +El objeto `user` resultante puede ser imaginado como un gabinete con dos archivos firmados con las etiquetas "name" y "age". ![user object](object-user.svg) -We can add, remove and read files from it any time. +Podemos agregar, eliminar y leer archivos de ahí en cualquier momento. -Property values are accessible using the dot notation: +Se puede acceder a los valores de las propiedades utilizando la notación de punto: ```js -// get property values of the object: +// Obteniendo los valores de las propiedades del objeto: alert( user.name ); // John alert( user.age ); // 30 ``` From f15205739b302f3cb8983fe82f55d7e6c6275c53 Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Thu, 23 Jul 2020 18:52:03 -0500 Subject: [PATCH 02/32] Update --- 1-js/04-object-basics/01-object/article.md | 52 +++++++++++----------- 1 file changed, 26 insertions(+), 26 deletions(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index 4f8b53152..dc9fe9419 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -54,7 +54,7 @@ alert( user.name ); // John alert( user.age ); // 30 ``` -The value can be of any type. Let's add a boolean one: +El valor puede ser de cualquier tipo. Agreguemos uno booleano: ```js user.isAdmin = true; @@ -62,7 +62,7 @@ user.isAdmin = true; ![user object 2](object-user-isadmin.svg) -To remove a property, we can use `delete` operator: +Para remover una propiedad podemos usar el operador `delete`: ```js delete user.age; @@ -70,32 +70,32 @@ delete user.age; ![user object 3](object-user-delete.svg) -We can also use multiword property names, but then they must be quoted: +También podemos nombrar propiedades con más de una plabra (*multiword*). Pero, de ser así, debemos citarlos `"..."`: ```js let user = { name: "John", age: 30, - "likes birds": true // multiword property name must be quoted + "likes birds": true // Las claves multiword deben ir citadas }; ``` ![](object-user-props.svg) -The last property in the list may end with a comma: +La última propiedad en la lista puede terminar con una coma: ```js let user = { name: "John", age: 30*!*,*/!* } ``` -That is called a "trailing" or "hanging" comma. Makes it easier to add/remove/move around properties, because all lines become alike. +Eso se llama una coma "final" o "colgante". Facilita agregar / eliminar / mover propiedades, porque todas las líneas se vuelven iguales. -````smart header="Object with const can be changed" -Please note: an object declared as `const` *can* be modified. +````smart header="Los objetos con *const* pueden cambiarse" +Toma en cuenta: un objeto declarado con `const` *puede* ser modificado. -For instance: +Por ejemplo: ```js run const user = { @@ -109,55 +109,55 @@ user.name = "Pete"; // (*) alert(user.name); // Pete ``` -It might seem that the line `(*)` would cause an error, but no. The `const` fixes the value of `user`, but not its contents. +Podría parecer que la linea `(*)` ocasiona un error, pero no. El `const` corrige el valor de `user` pero no su contenido. -The `const` would give an error only if we try to set `user=...` as a whole. +El `const` podría dar error solo si intentamos configurar `user=...` en lo absoluto. -There's another way to make constant object properties, we'll cover it later in the chapter . +Hay otra manera de crear propiedades de objeto constantes, las cubriremos después en el capítulo . ```` -## Square brackets +## Corchetes -For multiword properties, the dot access doesn't work: +Para acceder a propiedades *multiword* la notación de punto no funciona: ```js run -// this would give a syntax error +// Esto nos daría un error de sintaxis user.likes birds = true ``` -JavaScript doesn't understand that. It thinks that we address `user.likes`, and then gives a syntax error when comes across unexpected `birds`. +JavaScript no entiende eso. El piensa que hemos accedido a `user.likes` y entonces nos da un error de sintaxis cuando aparece el inesperado `birds`. -The dot requires the key to be a valid variable identifier. That implies: contains no spaces, doesn't start with a digit and doesn't include special characters (`$` and `_` are allowed). +El punto requiere que la clave sea un identificador de variable válido. Eso implica que: no contenga espacios, no comience con un dígito y no incluya caracteres especiales (`$` y `_` sí se permiten). -There's an alternative "square bracket notation" that works with any string: +Existe una "notación de corchetes" alternativa que funciona con cualquier string: ```js run let user = {}; -// set +// configurando user["likes birds"] = true; -// get +// obteniendo alert(user["likes birds"]); // true -// delete +// eliminando delete user["likes birds"]; ``` -Now everything is fine. Please note that the string inside the brackets is properly quoted (any type of quotes will do). +Ahora todo está bien. Nota que el string dentro de los corchetes está adecuadamente citado (cualquier tipo de comillas serviría). -Square brackets also provide a way to obtain the property name as the result of any expression -- as opposed to a literal string -- like from a variable as follows: +Los corchetes también nos proveen de una forma para obtener el nombre de la propiedad como resultado de cualquier expresión como una variable -- en lugar de una cadena literal -- de la siguiente manera: ```js let key = "likes birds"; -// same as user["likes birds"] = true; +// Tal cual: user["likes birds"] = true; user[key] = true; ``` -Here, the variable `key` may be calculated at run-time or depend on the user input. And then we use it to access the property. That gives us a great deal of flexibility. +Aquí la variable `key` puede calcularse en tiempo de ejecución o depender de la entrada del usuario y luego lo usamos para acceder a la propiedad. Eso nos da mucha flexibilidad. -For instance: +Por ejemplo: ```js run let user = { From 42f7cc69b9054fd4b51e7881cf8cf7c9bc1501d1 Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Thu, 23 Jul 2020 21:49:37 -0500 Subject: [PATCH 03/32] Update --- 1-js/04-object-basics/01-object/article.md | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index dc9fe9419..573d5c31b 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -165,13 +165,13 @@ let user = { age: 30 }; -let key = prompt("What do you want to know about the user?", "name"); +let key = prompt("¿Qué te gustaría saber acerca del usuario?", "name"); -// access by variable -alert( user[key] ); // John (if enter "name") +// acceso por medio de una variable +alert( user[key] ); // John (si se ingresara "name") ``` -The dot notation cannot be used in a similar way: +La notación de punto no puede ser usada de manera similar: ```js run let user = { @@ -183,22 +183,22 @@ let key = "name"; alert( user.key ) // undefined ``` -### Computed properties +### Propiedades calculadas -We can use square brackets in an object literal, when creating an object. That's called *computed properties*. +Podemos usar corchetes en un objeto literal al crear un objeto. A esto se le llama *propiedades calculadas*. -For instance: +Por ejemplo: ```js run -let fruit = prompt("Which fruit to buy?", "apple"); +let fruit = prompt("¿Qué fruta comprar?", "Manzana"); let bag = { *!* - [fruit]: 5, // the name of the property is taken from the variable fruit + [fruit]: 5, // El nombre de la propiedad se toma de la variable fruit */!* }; -alert( bag.apple ); // 5 if fruit="apple" +alert( bag.apple ); // 5 si fruit es="apple" ``` The meaning of a computed property is simple: `[fruit]` means that the property name should be taken from `fruit`. From a17a435bee6673d92396accafc300859fc8384b1 Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Thu, 23 Jul 2020 23:26:52 -0500 Subject: [PATCH 04/32] Update --- 1-js/04-object-basics/01-object/article.md | 26 +++++++++++----------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index 573d5c31b..9ef4a1f6f 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -194,29 +194,29 @@ let fruit = prompt("¿Qué fruta comprar?", "Manzana"); let bag = { *!* - [fruit]: 5, // El nombre de la propiedad se toma de la variable fruit + [fruit]: 5, // El nombre de la propiedad se obtiene de la variable fruit */!* }; alert( bag.apple ); // 5 si fruit es="apple" ``` -The meaning of a computed property is simple: `[fruit]` means that the property name should be taken from `fruit`. +El significado de una propiedad calculada es simple: `[fruit]` significa que se debe tomar el nombre de la propiedad `fruit`. -So, if a visitor enters `"apple"`, `bag` will become `{apple: 5}`. +Entonces, si un visitante ingresa `"apple"`, `bag` se convertira en `{apple: 5}`. -Essentially, that works the same as: +Esencialmente esto funciona igual que: ```js run -let fruit = prompt("Which fruit to buy?", "apple"); +let fruit = prompt("¿Qué fruta comprar?", "Manzana"); let bag = {}; -// take property name from the fruit variable +// Toma el nombre de la propiedad de la variable fruit bag[fruit] = 5; ``` -...But looks nicer. +...Pero luce mejor. -We can use more complex expressions inside square brackets: +Podemos usar expresiones más complejas dentro de los corchetes: ```js let fruit = 'apple'; @@ -225,15 +225,15 @@ let bag = { }; ``` -Square brackets are much more powerful than the dot notation. They allow any property names and variables. But they are also more cumbersome to write. +Los corchetes son mucho más potentes que la notación de punto. Permiten cualquier nombre de propiedad y variables. Pero también son más engorrosos de escribir. -So most of the time, when property names are known and simple, the dot is used. And if we need something more complex, then we switch to square brackets. +Entonces, la mayoría de las veces, cuando los nombres de propiedad son conocidos y simples, se utiliza el punto. Y si necesitamos algo más complejo, entonces cambiamos a corchetes. -## Property value shorthand +## Taquigrafía de los valores de propiedad -In real code we often use existing variables as values for property names. +En el código real, a menudo usamos variables existentes como valores de los nombres de propiedades. -For instance: +Por ejemplo: ```js run function makeUser(name, age) { From f17b890a33e535d900cddaa12777ea0a0561d60a Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Fri, 24 Jul 2020 14:28:06 -0500 Subject: [PATCH 05/32] Update --- 1-js/04-object-basics/01-object/article.md | 36 +++++++++++----------- 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index 9ef4a1f6f..fd256b12d 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -229,7 +229,7 @@ Los corchetes son mucho más potentes que la notación de punto. Permiten cualqu Entonces, la mayoría de las veces, cuando los nombres de propiedad son conocidos y simples, se utiliza el punto. Y si necesitamos algo más complejo, entonces cambiamos a corchetes. -## Taquigrafía de los valores de propiedad +## Shorthand paraa valores de propiedad En el código real, a menudo usamos variables existentes como valores de los nombres de propiedades. @@ -240,7 +240,7 @@ function makeUser(name, age) { return { name: name, age: age, - // ...other properties + // ...otras propiedades }; } @@ -248,40 +248,40 @@ let user = makeUser("John", 30); alert(user.name); // John ``` -In the example above, properties have the same names as variables. The use-case of making a property from a variable is so common, that there's a special *property value shorthand* to make it shorter. +En el ejemplo anterior las propiedades tienen los mismos nombres que las variables. El uso de la creación de propiedades a partir de las variables es tan común que existe un *shorthand (abreviatura) para valores de propiedad* especial para acortarla. -Instead of `name:name` we can just write `name`, like this: +En lugar de `name:name`, simplemente podemos escribir `name`, tal cual: ```js function makeUser(name, age) { *!* return { - name, // same as name: name - age, // same as age: age + name, // igual que name:name + age, // igual que age:age // ... }; */!* } ``` -We can use both normal properties and shorthands in the same object: +Podemos usar ambos tipos de notación en un mismo objeto, la normal y el shorthand: ```js let user = { - name, // same as name:name + name, // igual que name:name age: 30 }; ``` -## Property names limitations +## Limitaciones de nombres de propiedad -As we already know, a variable cannot have a name equal to one of language-reserved words like "for", "let", "return" etc. +Como ya sabemos, una variable no puede tener un nombre igual a una de las palabras reservadas del lenguaje como "for", "let", "return", etc. -But for an object property, there's no such restriction: +Pero para una propiedad de objeto no existe tal restricción: ```js run -// these properties are all right +// Estas propiedades están bien let obj = { for: 1, let: 2, @@ -291,20 +291,20 @@ let obj = { alert( obj.for + obj.let + obj.return ); // 6 ``` -In short, there are no limitations on property names. They can be any strings or symbols (a special type for identifiers, to be covered later). +En resumen, no hay limitaciones en los nombres de propiedades. Pueden ser cadenas o símbolos (un tipo especial para identificadores que se cubrirán más adelante). -Other types are automatically converted to strings. +Otros tipos se convierten automáticamente en cadenas. -For instance, a number `0` becomes a string `"0"` when used as a property key: +Por ejemplo, un número `0` se convierte en cadena `"0"` cuando se usa como clave de propiedad: ```js run let obj = { - 0: "test" // same as "0": "test" + 0: "test" // igual que "0": "test" }; -// both alerts access the same property (the number 0 is converted to string "0") +// ambos alerts acceden a la misma propiedad (el número 0 se convierte a una cadena "0") alert( obj["0"] ); // test -alert( obj[0] ); // test (same property) +alert( obj[0] ); // test (la misma propiedad) ``` There's a minor gotcha with a special property named `__proto__`. We can't set it to a non-object value: From 0db6fe7cd02452e4d978c260946c8901844f0d29 Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Fri, 24 Jul 2020 17:35:26 -0500 Subject: [PATCH 06/32] Update --- 1-js/04-object-basics/01-object/article.md | 34 +++++++++++----------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index fd256b12d..2a7e0a6e7 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -307,55 +307,55 @@ alert( obj["0"] ); // test alert( obj[0] ); // test (la misma propiedad) ``` -There's a minor gotcha with a special property named `__proto__`. We can't set it to a non-object value: +Hay una pequeña sorpresa por una propiedad especial llamada `__proto__`. No podemos establecerlo dentro de un valor que no sea de objeto: ```js run let obj = {}; -obj.__proto__ = 5; // assign a number -alert(obj.__proto__); // [object Object] - the value is an object, didn't work as intended +obj.__proto__ = 5; // asignando un número +alert(obj.__proto__); // [objeto Object] - el valor es un objeto, no funciona como se "debería" ``` -As we see from the code, the assignment to a primitive `5` is ignored. +Como podemos ver en el código, se ignora la asignación a un primario `5`. -We'll cover the special nature of `__proto__` in [subsequent chapters](info:prototype-inheritance), and suggest the [ways to fix](info:prototype-methods) such behavior. +Veremos la naturaleza especial de `__proto__` en los [capítulos siguientes](info:prototype-inheritance), y sugeriremos las [formas de arreglar](info:prototype-methods) tal comportamiento. -## Property existence test, "in" operator +## La prueba de propiedad existente, el operador "in" -A notable feature of objects in JavaScript, compared to many other languages, is that it's possible to access any property. There will be no error if the property doesn't exist! +Una notable característica de los objetos en JavaScript, en comparación con muchos otros lenguajes, es que es posible acceder a cualquier propiedad. ¡No habrá error si la propiedad no existe! -Reading a non-existing property just returns `undefined`. So we can easily test whether the property exists: +La lectura de una propiedad no existente solo devuelve `undefined`. Así que podemos probar fácilmente si la propiedad existe: ```js run let user = {}; -alert( user.noSuchProperty === undefined ); // true means "no such property" +alert( user.noSuchProperty === undefined ); // true significa que "no existe tal propiedad" ``` -There's also a special operator `"in"` for that. +También existe un operador especial para ello: `"in"`. -The syntax is: +La sintaxis es: ```js "key" in object ``` -For instance: +Por ejemplo: ```js run let user = { name: "John", age: 30 }; -alert( "age" in user ); // true, user.age exists -alert( "blabla" in user ); // false, user.blabla doesn't exist +alert( "age" in user ); // mostrará "true", user.age sí existe +alert( "blabla" in user ); // mostará false, user.blabla no existe ``` -Please note that on the left side of `in` there must be a *property name*. That's usually a quoted string. +Nota que a la izquierda de `in` debe estar el *nombre de la propiedad* que suele ser un string citado. -If we omit quotes, that means a variable, it should contain the actual name to be tested. For instance: +Si omitimos las comillas significa una variable. Esta variable debería contener el nombre real que será probado. Por ejemplo: ```js run let user = { age: 30 }; let key = "age"; -alert( *!*key*/!* in user ); // true, property "age" exists +alert( *!*key*/!* in user ); // true, porque su propiedad "age" si existe dentro del objeto ``` Why does the `in` operator exist? Isn't it enough to compare against `undefined`? From c3aee228c81ece27354fca3327ac5fbd550b3a17 Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Fri, 24 Jul 2020 19:11:36 -0500 Subject: [PATCH 07/32] Update --- 1-js/04-object-basics/01-object/article.md | 118 ++++++++++----------- 1 file changed, 59 insertions(+), 59 deletions(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index 2a7e0a6e7..b62b9a810 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -349,7 +349,7 @@ alert( "blabla" in user ); // mostará false, user.blabla no existe Nota que a la izquierda de `in` debe estar el *nombre de la propiedad* que suele ser un string citado. -Si omitimos las comillas significa una variable. Esta variable debería contener el nombre real que será probado. Por ejemplo: +Si omitimos las comillas significa una variable. Esta variable debería almacenar el nombre real que será probado. Por ejemplo: ```js run let user = { age: 30 }; @@ -358,40 +358,40 @@ let key = "age"; alert( *!*key*/!* in user ); // true, porque su propiedad "age" si existe dentro del objeto ``` -Why does the `in` operator exist? Isn't it enough to compare against `undefined`? +Pero... ¿Por qué existe el operador `in`? ¿No es suficiente comparar con `undefined`? -Well, most of the time the comparison with `undefined` works fine. But there's a special case when it fails, but `"in"` works correctly. +La mayoría de las veces las comparaciones con `undefined` funcionan bien. Pero hay un caso especial donde esto falla y aún así `"in"` funciona correctamente. -It's when an object property exists, but stores `undefined`: +Es cuando existe una propiedad de objeto, pero almacena `undefined`: ```js run let obj = { test: undefined }; -alert( obj.test ); // it's undefined, so - no such property? +alert( obj.test ); // es undefined, entonces... ¿Quiere decir realmente existe tal propiedad? -alert( "test" in obj ); // true, the property does exist! +alert( "test" in obj ); //es true, ¡La propiedad sí existe! ``` -In the code above, the property `obj.test` technically exists. So the `in` operator works right. +En el código anterior, la propiedad `obj.test` técnicamente existe. Entonces el operador `in` funciona correctamente. -Situations like this happen very rarely, because `undefined` should not be explicitly assigned. We mostly use `null` for "unknown" or "empty" values. So the `in` operator is an exotic guest in the code. +Situaciones como esta suceden raramente ya que `undefined` no debe ser explícitamente asignado. Comunmente usamos `null` para valores "desconocidos" o "vacios". Por lo que el operdaor `in` es un invitado exótico en nuestro código. -## The "for..in" loop +## El bucle "for..in" -To walk over all keys of an object, there exists a special form of the loop: `for..in`. This is a completely different thing from the `for(;;)` construct that we studied before. +Para recorrer todas las claves de un objeto existe una forma especial de bucle: `for..in`. Esto es algo completamente diferente a la construcción `for(;;)` que estudiaremos más adelante. -The syntax: +La sintaxis: ```js for (key in object) { - // executes the body for each key among object properties + // se ejecuta e cuerpo para cada clave entre las propiedades del objeto } ``` -For instance, let's output all properties of `user`: +Por ejemplo, mostremos todas las propiedades de `user`: ```js run let user = { @@ -401,24 +401,24 @@ let user = { }; for (let key in user) { - // keys + // claves alert( key ); // name, age, isAdmin - // values for the keys + // valores de las claves alert( user[key] ); // John, 30, true } ``` -Note that all "for" constructs allow us to declare the looping variable inside the loop, like `let key` here. +Nota que todas las construcciones "for" nos permiten declarar variables para bucle dentro del bucle, como `let key` aquí. -Also, we could use another variable name here instead of `key`. For instance, `"for (let prop in obj)"` is also widely used. +Además podriamos usar otros nombres de variables en lugar de `key`. Por ejemplo, `"for (let prop in obj)"` también se usa bastante. -### Ordered like an object +### Ordenado como un objeto -Are objects ordered? In other words, if we loop over an object, do we get all properties in the same order they were added? Can we rely on this? +¿Los objetos son ordenados? Es decir, si creamos un bucle sobre un objeto, ¿obtenemos todas las propiedades en el mismo orden en el que se agregaron? ¿Podemos confiar en ello? -The short answer is: "ordered in a special fashion": integer properties are sorted, others appear in creation order. The details follow. +La respuesta corta es: "ordenados de una forma especial": las propiedades de enteros se ordenan, los demás aparecen en el orden de la creación. Entremos en detalle. -As an example, let's consider an object with the phone codes: +Como ejemplo, consideremos un objeto con códigos telefónicos: ```js run let codes = { @@ -436,48 +436,48 @@ for (let code in codes) { */!* ``` -The object may be used to suggest a list of options to the user. If we're making a site mainly for German audience then we probably want `49` to be the first. +El objeto puede usarse para sugerir una lista de opciones al usuario. Si estamos haciendo un sitio principalmente para el público alemán, entonces probablemente queremos que `49` sea el primero. -But if we run the code, we see a totally different picture: +Pero si ejecutamos el código, veremos una imagen totalmente diferente: -- USA (1) goes first -- then Switzerland (41) and so on. +- USA (1) va primero +- Luego Switzerland (41) y así sucecivamente. -The phone codes go in the ascending sorted order, because they are integers. So we see `1, 41, 44, 49`. +Los códigos telefónicos van en orden ascendente porque son enteros. Entonces vemos `1, 41, 44, 49`. -````smart header="Integer properties? What's that?" -The "integer property" term here means a string that can be converted to-and-from an integer without a change. +````smart header="¿Propiedades de enteros? ¿Qué es eso?" +El término "propiedad de enteros" aquí significa que una cadena se puede convertir a y desde desde un entero sin nigún cambio. -So, "49" is an integer property name, because when it's transformed to an integer number and back, it's still the same. But "+49" and "1.2" are not: +Entonces, "49" es un nombre de propiedad entero, porque cuando este se transforma a un entero y viceversa continua siendo el mismo. Pero "+49" y "1.2" no lo son: ```js run -// Math.trunc is a built-in function that removes the decimal part -alert( String(Math.trunc(Number("49"))) ); // "49", same, integer property -alert( String(Math.trunc(Number("+49"))) ); // "49", not same "+49" ⇒ not integer property -alert( String(Math.trunc(Number("1.2"))) ); // "1", not same "1.2" ⇒ not integer property +// Math.trunc es una función incorporada que elimina la parte decimal +alert( String(Math.trunc(Number("49"))) ); // "49", es igual, una propiedad entera +alert( String(Math.trunc(Number("+49"))) ); // "49", no es igual "+49" ⇒ no es una propiedad entera +alert( String(Math.trunc(Number("1.2"))) ); // "1", no es igual "1.2" ⇒ no es una propiedad entera ``` ```` -...On the other hand, if the keys are non-integer, then they are listed in the creation order, for instance: +...Por otro lado, si las claves no son enteras, se enumeran en el orden de creación, por ejemplo: ```js run let user = { name: "John", surname: "Smith" }; -user.age = 25; // add one more +user.age = 25; // Se agrega una propiedad más *!* -// non-integer properties are listed in the creation order +// Las propiedades que no son enteras se enumeran en el orden de creación */!* for (let prop in user) { alert( prop ); // name, surname, age } ``` -So, to fix the issue with the phone codes, we can "cheat" by making the codes non-integer. Adding a plus `"+"` sign before each code is enough. +Entonces, para solucionar el problema con los códigos telefónicos, podemos "hacer trampa" haciendo que los códigos no sean enteros. Agregar un signo más `"+"` antes de cada código será más que suficiente. -Like this: +Justo así: ```js run let codes = { @@ -493,34 +493,34 @@ for (let code in codes) { } ``` -Now it works as intended. +Ahora sí funciona como debería. -## Summary +## Resumen -Objects are associative arrays with several special features. +Los objetos son arreglos asociativos con varias características especiales. -They store properties (key-value pairs), where: -- Property keys must be strings or symbols (usually strings). -- Values can be of any type. +Almacenan propiedades (pares de clave-valor), donde: +- Las claves de propiedad deben ser cadenas o símbolos (generalmente strings). +- Los valores pueden ser de cualquier tipo. -To access a property, we can use: -- The dot notation: `obj.property`. -- Square brackets notation `obj["property"]`. Square brackets allow to take the key from a variable, like `obj[varWithKey]`. +Para acceder a una propiedad, podemos usar: +- La notación de punto: `obj.property`. +- Notación de corchetes `obj["property"]`. Los corchetes permiten tomar la clave de una variable, como `obj[varWithKey]`. -Additional operators: -- To delete a property: `delete obj.prop`. -- To check if a property with the given key exists: `"key" in obj`. -- To iterate over an object: `for (let key in obj)` loop. +Operadores adicionales: +- Para eliminar una propiedad: `delete obj.prop`. +-Para comprobar si existe una propiedad con la clave proporcionada: `"key" in obj`. +- Para crear bluces sobre un objeto: bucle `for (let key in obj)`. -What we've studied in this chapter is called a "plain object", or just `Object`. +Lo que hemos estudiado en este capítulo se llama "objeto simple", o solamente `Object`. -There are many other kinds of objects in JavaScript: +Hay muchos otros tipos de objetos en JavaScript: -- `Array` to store ordered data collections, -- `Date` to store the information about the date and time, -- `Error` to store the information about an error. -- ...And so on. +- `Array` para almacenar colecciones de datos ordenados, +- `Date` para almacenar la información sobre fecha y hora, +- `Error` para almacenar información sobre un error. +- ...Y así. -They have their special features that we'll study later. Sometimes people say something like "Array type" or "Date type", but formally they are not types of their own, but belong to a single "object" data type. And they extend it in various ways. +Tienen sus características especiales que estudiaremos más adelante. A veces las personas dicen algo como "Tipo de matriz" o "Tipo de fecha", pero formalmente no son tipos en sí, sino que pertenecen a un tipo de datos de "objeto" simple y lo amplian a varias maneras. -Objects in JavaScript are very powerful. Here we've just scratched the surface of a topic that is really huge. We'll be closely working with objects and learning more about them in further parts of the tutorial. +Los objetos en JavaScript son muy poderosos. Aquí acabamos de arañar la superficie de un tema que es realmente enorme. Trabajaremos estrechamente con los objetos y aprenderemos más sobre ellos en otras partes del tutorial. From 22a88dc0af8b13e80a13490d41b04908877c7f9d Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Fri, 24 Jul 2020 19:55:48 -0500 Subject: [PATCH 08/32] Update --- .../01-object/2-hello-object/task.md | 14 +++++++------- .../01-object/3-is-empty/_js.view/solution.js | 2 +- .../01-object/3-is-empty/_js.view/test.js | 4 ++-- .../01-object/3-is-empty/solution.md | 2 +- .../01-object/3-is-empty/task.md | 8 ++++---- .../01-object/5-sum-object/task.md | 8 ++++---- .../8-multiply-numeric/_js.view/source.js | 6 +++--- .../8-multiply-numeric/_js.view/test.js | 8 ++++---- .../01-object/8-multiply-numeric/task.md | 18 +++++++++--------- 9 files changed, 35 insertions(+), 35 deletions(-) diff --git a/1-js/04-object-basics/01-object/2-hello-object/task.md b/1-js/04-object-basics/01-object/2-hello-object/task.md index 2841a058f..6fee89d57 100644 --- a/1-js/04-object-basics/01-object/2-hello-object/task.md +++ b/1-js/04-object-basics/01-object/2-hello-object/task.md @@ -2,13 +2,13 @@ importance: 5 --- -# Hello, object +# Hola objeto -Write the code, one line for each action: +Escribe el código, una línea para cada acción: -1. Create an empty object `user`. -2. Add the property `name` with the value `John`. -3. Add the property `surname` with the value `Smith`. -4. Change the value of the `name` to `Pete`. -5. Remove the property `name` from the object. +1. Crea un objeto `user` vacio. +2. Agrega la propiedad `name` con el valor `John`. +3.Agrega la propiedad `surname` con el valor `Smith`. +4. Cambia el valor de `name` a `Pete`. +5. Remueve la propiedad `name` del objeto. diff --git a/1-js/04-object-basics/01-object/3-is-empty/_js.view/solution.js b/1-js/04-object-basics/01-object/3-is-empty/_js.view/solution.js index db3283e49..15eadf371 100644 --- a/1-js/04-object-basics/01-object/3-is-empty/_js.view/solution.js +++ b/1-js/04-object-basics/01-object/3-is-empty/_js.view/solution.js @@ -1,6 +1,6 @@ function isEmpty(obj) { for (let key in obj) { - // if the loop has started, there is a property + // Si el bucle ha comenzado quiere decir que sí hay al menos una propiedad return false; } return true; diff --git a/1-js/04-object-basics/01-object/3-is-empty/_js.view/test.js b/1-js/04-object-basics/01-object/3-is-empty/_js.view/test.js index 4db5efabe..399a20533 100644 --- a/1-js/04-object-basics/01-object/3-is-empty/_js.view/test.js +++ b/1-js/04-object-basics/01-object/3-is-empty/_js.view/test.js @@ -1,9 +1,9 @@ describe("isEmpty", function() { - it("returns true for an empty object", function() { + it("retorna true para un objeto vacío", function() { assert.isTrue(isEmpty({})); }); - it("returns false if a property exists", function() { + it("retorna false si existe una propiedad", function() { assert.isFalse(isEmpty({ anything: false })); diff --git a/1-js/04-object-basics/01-object/3-is-empty/solution.md b/1-js/04-object-basics/01-object/3-is-empty/solution.md index b876973b5..fc1c0d969 100644 --- a/1-js/04-object-basics/01-object/3-is-empty/solution.md +++ b/1-js/04-object-basics/01-object/3-is-empty/solution.md @@ -1 +1 @@ -Just loop over the object and `return false` immediately if there's at least one property. +Solo cre un bucle sobre el objeto y un `return false` inmediatamente si hay al menos una propiedad. diff --git a/1-js/04-object-basics/01-object/3-is-empty/task.md b/1-js/04-object-basics/01-object/3-is-empty/task.md index c438d36a2..ab3eff3d0 100644 --- a/1-js/04-object-basics/01-object/3-is-empty/task.md +++ b/1-js/04-object-basics/01-object/3-is-empty/task.md @@ -2,18 +2,18 @@ importance: 5 --- -# Check for emptiness +# Verificar los vacíos -Write the function `isEmpty(obj)` which returns `true` if the object has no properties, `false` otherwise. +Escribe la función `isEmpty(obj)` que devuelva el valor `true` si el objeto no tiene propiedades, en caso contrario `false`. -Should work like that: +Debería funcionar así: ```js let schedule = {}; alert( isEmpty(schedule) ); // true -schedule["8:30"] = "get up"; +schedule["8:30"] = "Hora de levantarse"; alert( isEmpty(schedule) ); // false ``` diff --git a/1-js/04-object-basics/01-object/5-sum-object/task.md b/1-js/04-object-basics/01-object/5-sum-object/task.md index 7e3e048d0..445e55ccb 100644 --- a/1-js/04-object-basics/01-object/5-sum-object/task.md +++ b/1-js/04-object-basics/01-object/5-sum-object/task.md @@ -2,9 +2,9 @@ importance: 5 --- -# Sum object properties +# Suma de propiedades de un objeto -We have an object storing salaries of our team: +Tenemos un objeto que almacena los salarios de nuestro equipo: ```js let salaries = { @@ -14,6 +14,6 @@ let salaries = { } ``` -Write the code to sum all salaries and store in the variable `sum`. Should be `390` in the example above. +Escribe el código para sumar todos los salarios y almacenarl el resultado en la variable `sum`. En el ejemplo de arriba nos debería dar `390`. -If `salaries` is empty, then the result must be `0`. \ No newline at end of file +Si `salaries` está vacio entonces el resultado será `0`. \ No newline at end of file diff --git a/1-js/04-object-basics/01-object/8-multiply-numeric/_js.view/source.js b/1-js/04-object-basics/01-object/8-multiply-numeric/_js.view/source.js index a02b1e1cb..795ff0b7d 100644 --- a/1-js/04-object-basics/01-object/8-multiply-numeric/_js.view/source.js +++ b/1-js/04-object-basics/01-object/8-multiply-numeric/_js.view/source.js @@ -1,17 +1,17 @@ let menu = { width: 200, height: 300, - title: "My menu" + title: "Mi menu" }; function multiplyNumeric(obj) { - /* your code */ + /* tu código */ } multiplyNumeric(menu); -alert( "menu width=" + menu.width + " height=" + menu.height + " title=" + menu.title ); +alert( "ancho del menú=" + menu.width + " alto=" + menu.height + " título=" + menu.title ); diff --git a/1-js/04-object-basics/01-object/8-multiply-numeric/_js.view/test.js b/1-js/04-object-basics/01-object/8-multiply-numeric/_js.view/test.js index 064e5414f..7e2234a7b 100644 --- a/1-js/04-object-basics/01-object/8-multiply-numeric/_js.view/test.js +++ b/1-js/04-object-basics/01-object/8-multiply-numeric/_js.view/test.js @@ -1,17 +1,17 @@ describe("multiplyNumeric", function() { - it("multiplies all numeric properties by 2", function() { + it("multiplicar todas las propiedades numéricas por 2", function() { let menu = { width: 200, height: 300, - title: "My menu" + title: "Mi menú" }; let result = multiplyNumeric(menu); assert.equal(menu.width, 400); assert.equal(menu.height, 600); - assert.equal(menu.title, "My menu"); + assert.equal(menu.title, "Mi menú"); }); - it("returns nothing", function() { + it("No devuelve nada", function() { assert.isUndefined( multiplyNumeric({}) ); }); diff --git a/1-js/04-object-basics/01-object/8-multiply-numeric/task.md b/1-js/04-object-basics/01-object/8-multiply-numeric/task.md index 33eb89220..8e4d26ae2 100644 --- a/1-js/04-object-basics/01-object/8-multiply-numeric/task.md +++ b/1-js/04-object-basics/01-object/8-multiply-numeric/task.md @@ -2,32 +2,32 @@ importance: 3 --- -# Multiply numeric properties by 2 +# Multiplicar propiedades numéricas por 2 -Create a function `multiplyNumeric(obj)` that multiplies all numeric properties of `obj` by `2`. +Crea una función `multiplyNumeric(obj)` que multiplique todas las propiedades numéricas de `obj` por `2`. -For instance: +Por ejemplo: ```js -// before the call +// Antes de la llamada let menu = { width: 200, height: 300, - title: "My menu" + title: "Mi menú" }; multiplyNumeric(menu); -// after the call +// Después de la llamada menu = { width: 400, height: 600, - title: "My menu" + title: "Mi menú" }; ``` -Please note that `multiplyNumeric` does not need to return anything. It should modify the object in-place. +Nota que `multiplyNumeric` no necesita devolver nada. Debe modificar el objeto en su lugar. -P.S. Use `typeof` to check for a number here. +P.D. Usa `typeof` para verificar si hay un número aquí. From 5228b7e7f17c3e0702150633cdcff2677c29b986 Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Sat, 25 Jul 2020 01:15:07 -0500 Subject: [PATCH 09/32] Update 1-js/04-object-basics/01-object/2-hello-object/task.md Co-authored-by: Daniel Garcia --- 1-js/04-object-basics/01-object/2-hello-object/task.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/1-js/04-object-basics/01-object/2-hello-object/task.md b/1-js/04-object-basics/01-object/2-hello-object/task.md index 6fee89d57..2e19b7225 100644 --- a/1-js/04-object-basics/01-object/2-hello-object/task.md +++ b/1-js/04-object-basics/01-object/2-hello-object/task.md @@ -6,9 +6,8 @@ importance: 5 Escribe el código, una línea para cada acción: -1. Crea un objeto `user` vacio. +1. Crea un objeto `user` vacío. 2. Agrega la propiedad `name` con el valor `John`. 3.Agrega la propiedad `surname` con el valor `Smith`. 4. Cambia el valor de `name` a `Pete`. 5. Remueve la propiedad `name` del objeto. - From 41da6623d5ea162c2920c31e5deba9cfdbd24aaa Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Sat, 25 Jul 2020 01:19:27 -0500 Subject: [PATCH 10/32] Update task.md --- 1-js/04-object-basics/01-object/2-hello-object/task.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/04-object-basics/01-object/2-hello-object/task.md b/1-js/04-object-basics/01-object/2-hello-object/task.md index 2e19b7225..1664de1c0 100644 --- a/1-js/04-object-basics/01-object/2-hello-object/task.md +++ b/1-js/04-object-basics/01-object/2-hello-object/task.md @@ -2,7 +2,7 @@ importance: 5 --- -# Hola objeto +# Hola, objeto Escribe el código, una línea para cada acción: From 84181eac56256f63bca98d040f15b8f867e8ada4 Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Sat, 25 Jul 2020 01:19:50 -0500 Subject: [PATCH 11/32] Update task.md --- 1-js/04-object-basics/01-object/2-hello-object/task.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/04-object-basics/01-object/2-hello-object/task.md b/1-js/04-object-basics/01-object/2-hello-object/task.md index 1664de1c0..2a76f05a2 100644 --- a/1-js/04-object-basics/01-object/2-hello-object/task.md +++ b/1-js/04-object-basics/01-object/2-hello-object/task.md @@ -8,6 +8,6 @@ Escribe el código, una línea para cada acción: 1. Crea un objeto `user` vacío. 2. Agrega la propiedad `name` con el valor `John`. -3.Agrega la propiedad `surname` con el valor `Smith`. +3. Agrega la propiedad `surname` con el valor `Smith`. 4. Cambia el valor de `name` a `Pete`. 5. Remueve la propiedad `name` del objeto. From 6fa85e813f05df9e55652bead5f5c2cde379ebe5 Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Sat, 25 Jul 2020 01:23:08 -0500 Subject: [PATCH 12/32] Update solution.md --- 1-js/04-object-basics/01-object/3-is-empty/solution.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/04-object-basics/01-object/3-is-empty/solution.md b/1-js/04-object-basics/01-object/3-is-empty/solution.md index fc1c0d969..2ba2b89e0 100644 --- a/1-js/04-object-basics/01-object/3-is-empty/solution.md +++ b/1-js/04-object-basics/01-object/3-is-empty/solution.md @@ -1 +1 @@ -Solo cre un bucle sobre el objeto y un `return false` inmediatamente si hay al menos una propiedad. +Solo crea un bucle sobre el objeto y, si hay al menos una propiedad, devuelve `false` inmediatamente. From d5be7a68f8d77eb43754de90d98c0ffa73f96794 Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Sat, 25 Jul 2020 01:26:24 -0500 Subject: [PATCH 13/32] Update 1-js/04-object-basics/01-object/8-multiply-numeric/_js.view/source.js Co-authored-by: Daniel Garcia --- .../01-object/8-multiply-numeric/_js.view/source.js | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/1-js/04-object-basics/01-object/8-multiply-numeric/_js.view/source.js b/1-js/04-object-basics/01-object/8-multiply-numeric/_js.view/source.js index 795ff0b7d..8aa93a62f 100644 --- a/1-js/04-object-basics/01-object/8-multiply-numeric/_js.view/source.js +++ b/1-js/04-object-basics/01-object/8-multiply-numeric/_js.view/source.js @@ -1,7 +1,7 @@ let menu = { width: 200, height: 300, - title: "Mi menu" + title: "Mi menú" }; @@ -14,4 +14,3 @@ function multiplyNumeric(obj) { multiplyNumeric(menu); alert( "ancho del menú=" + menu.width + " alto=" + menu.height + " título=" + menu.title ); - From a896cac2c3b796abd03920fb55daad90221458e6 Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Sat, 25 Jul 2020 01:28:43 -0500 Subject: [PATCH 14/32] Update article.md --- 1-js/04-object-basics/01-object/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index b62b9a810..da3d6b09c 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -1,7 +1,7 @@ # Objetos -Como aprendimos desde el capítulo , hay ocho tipos de datos en JavaScript. Siete de ellos se denominan "primitivos", porque sus valores contienen solo un dato (sea una cadena, un número o lo que sea). +Como aprendimos desde el capítulo , hay ocho tipos de datos en JavaScript. Siete de ellos se denominan "primitivos", porque sus valores contienen solo un dato (sea un `string`, un número o lo que sea). En contraste, los objetos son usados para almacenar colecciones aseguradas de varios datos y entidades más complejas. En JavaScript, los objetos penetran casi todos los aspectos del lenguaje. Por lo tanto, debemos comprenderlos primero antes de profundizar en cualquier otro lugar. From c69573f8f1c4cd42eb16cfe7000aa105393610e9 Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Sat, 25 Jul 2020 01:41:24 -0500 Subject: [PATCH 15/32] Update article.md --- 1-js/04-object-basics/01-object/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index da3d6b09c..778364e4e 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -3,7 +3,7 @@ Como aprendimos desde el capítulo , hay ocho tipos de datos en JavaScript. Siete de ellos se denominan "primitivos", porque sus valores contienen solo un dato (sea un `string`, un número o lo que sea). -En contraste, los objetos son usados para almacenar colecciones aseguradas de varios datos y entidades más complejas. En JavaScript, los objetos penetran casi todos los aspectos del lenguaje. Por lo tanto, debemos comprenderlos primero antes de profundizar en cualquier otro lugar. +En contraste, los objetos son usados para almacenar colecciones varios datos por medio de una clave --`key`-- y entidades más complejas. En JavaScript, los objetos penetran casi todos los aspectos del lenguaje. Por lo tanto, debemos comprenderlos primero antes de profundizar en cualquier otro lugar. Un objeto se puede crear usando corchetes `{…}` con una lista opcional de *propiedades*. Una propiedad es un par "clave: valor", donde `key` es una cadena (también llamada "nombre de la propiedad"), y `value` puede ser cualquier cosa. From 2337f501bd7c51497c0cab4d53a29c2d03a040fb Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Sat, 25 Jul 2020 01:44:04 -0500 Subject: [PATCH 16/32] Update article.md --- 1-js/04-object-basics/01-object/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index 778364e4e..2895718fa 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -5,7 +5,7 @@ Como aprendimos desde el capítulo , hay ocho tipos de datos en Java En contraste, los objetos son usados para almacenar colecciones varios datos por medio de una clave --`key`-- y entidades más complejas. En JavaScript, los objetos penetran casi todos los aspectos del lenguaje. Por lo tanto, debemos comprenderlos primero antes de profundizar en cualquier otro lugar. -Un objeto se puede crear usando corchetes `{…}` con una lista opcional de *propiedades*. Una propiedad es un par "clave: valor", donde `key` es una cadena (también llamada "nombre de la propiedad"), y `value` puede ser cualquier cosa. +Un objeto se puede crear usando corchetes `{…}` con una lista opcional de *propiedades*. Una propiedad es un par "key: value", donde `key` es una cadena (también llamada "nombre de la propiedad"), y `value` puede ser cualquier cosa. Podemos imaginar un objeto como un gabinete con archivos firmados. Cada pieza de datos es almacenada en su archivo por la clave. Es fácil encontrar un archivo por su nombre o agregar / eliminar un archivo. From 98ed40eb18d413a5551bf408d89df17fa90bf1a8 Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Sat, 25 Jul 2020 01:44:35 -0500 Subject: [PATCH 17/32] Update 1-js/04-object-basics/01-object/article.md Co-authored-by: Daniel Garcia --- 1-js/04-object-basics/01-object/article.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index 2895718fa..59d59f8ee 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -14,8 +14,8 @@ Podemos imaginar un objeto como un gabinete con archivos firmados. Cada pieza de Se puede crear un objeto vacío ("gabinete vacío") utilizando una de dos sintaxis: ```js -let user = new Object(); // cintaxis del "construtor de objetos" -let user = {}; // sintaxis del "objeto literal" +let user = new Object(); // sintaxis de "construtor de objetos" +let user = {}; // sintaxis de "objeto literal" ``` ![](object-user-empty.svg) From 127a18f81759d53c4bf5057ef3ebc8d3fa215324 Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Sat, 25 Jul 2020 01:46:06 -0500 Subject: [PATCH 18/32] Update 1-js/04-object-basics/01-object/article.md Co-authored-by: Daniel Garcia --- 1-js/04-object-basics/01-object/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index 59d59f8ee..d3083e8ee 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -20,7 +20,7 @@ let user = {}; // sintaxis de "objeto literal" ![](object-user-empty.svg) -Regularmente, {...}se utilizan los corchetes. Esa declaración se llama *objeto literal*. +Regularmente, {...} se utilizan los corchetes. Esa declaración se llama *objeto literal*. ## Literales y propiedades From 216253d6e4dd21f473bfbd1ad5849adb62112908 Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Sat, 25 Jul 2020 01:47:26 -0500 Subject: [PATCH 19/32] Update 1-js/04-object-basics/01-object/article.md Co-authored-by: Daniel Garcia --- 1-js/04-object-basics/01-object/article.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index d3083e8ee..c3ce8180d 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -28,8 +28,8 @@ Podemos poner inmediatamente algunas propiedades dentro de `{...}` como pares "c ```js let user = { // un objeto - name: "John", // Por la clave "name" se almacena el valor "John" - age: 30 // Por la clave "age" se almacena el valor 30 + name: "John", // En la llave "name" se almacena el valor "John" + age: 30 // En la llave "age" se almacena el valor 30 }; ``` From ecb9dc2b6cda056608f620f34429c88f5c1d38da Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Sat, 25 Jul 2020 01:50:36 -0500 Subject: [PATCH 20/32] Update article.md --- 1-js/04-object-basics/01-object/article.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index c3ce8180d..3e6e9b02f 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -3,9 +3,9 @@ Como aprendimos desde el capítulo , hay ocho tipos de datos en JavaScript. Siete de ellos se denominan "primitivos", porque sus valores contienen solo un dato (sea un `string`, un número o lo que sea). -En contraste, los objetos son usados para almacenar colecciones varios datos por medio de una clave --`key`-- y entidades más complejas. En JavaScript, los objetos penetran casi todos los aspectos del lenguaje. Por lo tanto, debemos comprenderlos primero antes de profundizar en cualquier otro lugar. +En contraste, los objetos son usados para almacenar colecciones varios datos por medio de una llave --`key`-- y entidades más complejas. En JavaScript, los objetos penetran casi todos los aspectos del lenguaje. Por lo tanto, debemos comprenderlos primero antes de profundizar en cualquier otro lugar. -Un objeto se puede crear usando corchetes `{…}` con una lista opcional de *propiedades*. Una propiedad es un par "key: value", donde `key` es una cadena (también llamada "nombre de la propiedad"), y `value` puede ser cualquier cosa. +Un objeto se puede crear usando llaves `{…}` con una lista opcional de *propiedades*. Una propiedad es un par "key: value", donde `key` es un string (también llamada "nombre de la propiedad"), y `value` puede ser cualquier cosa. Podemos imaginar un objeto como un gabinete con archivos firmados. Cada pieza de datos es almacenada en su archivo por la clave. Es fácil encontrar un archivo por su nombre o agregar / eliminar un archivo. From 89c905bd16bc7d7738e6924687bd1997b011052b Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Sat, 25 Jul 2020 02:02:21 -0500 Subject: [PATCH 21/32] Update 1-js/04-object-basics/01-object/article.md Co-authored-by: Daniel Garcia --- 1-js/04-object-basics/01-object/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index 3e6e9b02f..4477aa92b 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -76,7 +76,7 @@ También podemos nombrar propiedades con más de una plabra (*multiword*). Pero, let user = { name: "John", age: 30, - "likes birds": true // Las claves multiword deben ir citadas + "likes birds": true // Las claves multiword deben ir entre comillas }; ``` From 3965ce27f2f80a8a74e53532d9162f0e98ad92de Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Sat, 25 Jul 2020 02:05:09 -0500 Subject: [PATCH 22/32] Update 1-js/04-object-basics/01-object/article.md Co-authored-by: Daniel Garcia --- 1-js/04-object-basics/01-object/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index 4477aa92b..44cbfdfe2 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -92,7 +92,7 @@ let user = { ``` Eso se llama una coma "final" o "colgante". Facilita agregar / eliminar / mover propiedades, porque todas las líneas se vuelven iguales. -````smart header="Los objetos con *const* pueden cambiarse" +````smart header="Los objetos con const pueden cambiarse" Toma en cuenta: un objeto declarado con `const` *puede* ser modificado. Por ejemplo: From bbe7591bfe684f145037d11ce9ed6da41430c7d4 Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Sat, 25 Jul 2020 02:15:28 -0500 Subject: [PATCH 23/32] Update article.md --- 1-js/04-object-basics/01-object/article.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index 44cbfdfe2..edef7c141 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -40,7 +40,7 @@ En el objeto `user` hay dos propiedades: 1. La primer propiedad tiene el nombre `"name"` y el valor `"John"`. 2. La segunda tienen el nombre `"age"` y el valor `30`. -El objeto `user` resultante puede ser imaginado como un gabinete con dos archivos firmados con las etiquetas "name" y "age". +Podemos imaginar al objeto `user` resultante como un gabinete con dos archivos firmados con las etiquetas "name" y "age". ![user object](object-user.svg) @@ -70,7 +70,7 @@ delete user.age; ![user object 3](object-user-delete.svg) -También podemos nombrar propiedades con más de una plabra (*multiword*). Pero, de ser así, debemos citarlos `"..."`: +También podemos nombrar propiedades con más de una plabra (*multiword*). Pero, de ser así, debemos colocarlos entre comillas `"..."`: ```js let user = { @@ -90,7 +90,7 @@ let user = { age: 30*!*,*/!* } ``` -Eso se llama una coma "final" o "colgante". Facilita agregar / eliminar / mover propiedades, porque todas las líneas se vuelven iguales. +Eso se llama una coma "final" o "colgante". Facilita agregar / eliminar / mover propiedades, porque todas las líneas se vuelven similares. ````smart header="Los objetos con const pueden cambiarse" Toma en cuenta: un objeto declarado con `const` *puede* ser modificado. @@ -109,23 +109,23 @@ user.name = "Pete"; // (*) alert(user.name); // Pete ``` -Podría parecer que la linea `(*)` ocasiona un error, pero no. El `const` corrige el valor de `user` pero no su contenido. +Puede parecer que la linea `(*)` ocasionaría un error, pero no. El `const` fija el valor de `user` pero no su contenido. -El `const` podría dar error solo si intentamos configurar `user=...` en lo absoluto. +El `const` podría dar error solo si intentamos asignar `user=...` en su totalidad. -Hay otra manera de crear propiedades de objeto constantes, las cubriremos después en el capítulo . +Hay otra manera de crear objetos con propiedades fijas, las veremos después en el capítulo . ```` ## Corchetes -Para acceder a propiedades *multiword* la notación de punto no funciona: +Para acceder a propiedades de varias palabras la notación de punto no funciona: ```js run // Esto nos daría un error de sintaxis user.likes birds = true ``` -JavaScript no entiende eso. El piensa que hemos accedido a `user.likes` y entonces nos da un error de sintaxis cuando aparece el inesperado `birds`. +JavaScript no entiende eso. Piensa que hemos accedido a `user.likes` y entonces nos da un error de sintaxis cuando aparece el inesperado `birds`. El punto requiere que la clave sea un identificador de variable válido. Eso implica que: no contenga espacios, no comience con un dígito y no incluya caracteres especiales (`$` y `_` sí se permiten). From 87b529212f0d0ea30c7b6a1ffca1e55ee3638494 Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Sun, 26 Jul 2020 13:27:38 -0500 Subject: [PATCH 24/32] Update article.md --- 1-js/04-object-basics/01-object/article.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index edef7c141..af6d2edc5 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -3,9 +3,9 @@ Como aprendimos desde el capítulo , hay ocho tipos de datos en JavaScript. Siete de ellos se denominan "primitivos", porque sus valores contienen solo un dato (sea un `string`, un número o lo que sea). -En contraste, los objetos son usados para almacenar colecciones varios datos por medio de una llave --`key`-- y entidades más complejas. En JavaScript, los objetos penetran casi todos los aspectos del lenguaje. Por lo tanto, debemos comprenderlos primero antes de profundizar en cualquier otro lugar. +En contraste, los objetos son usados para almacenar colecciones de varios datos y entidades más complejas asociados con un nombre clave. En JavaScript, los objetos penetran casi todos los aspectos del lenguaje. Por lo tanto, debemos comprenderlos primero antes de profundizar en cualquier otro lugar. -Un objeto se puede crear usando llaves `{…}` con una lista opcional de *propiedades*. Una propiedad es un par "key: value", donde `key` es un string (también llamada "nombre de la propiedad"), y `value` puede ser cualquier cosa. +Podemos crear un objeto usando las llaves `{…}` con una lista opcional de *propiedades*. Una propiedad es un par "key:value", donde `key` es un string (también llamado "nombre clave"), y `value` puede ser cualquier cosa. Podemos imaginar un objeto como un gabinete con archivos firmados. Cada pieza de datos es almacenada en su archivo por la clave. Es fácil encontrar un archivo por su nombre o agregar / eliminar un archivo. From 3070aa6d080809e170d74f5dd0b0ddbb1bcb0687 Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Sun, 26 Jul 2020 14:25:48 -0500 Subject: [PATCH 25/32] Update --- 1-js/04-object-basics/01-object/article.md | 84 +++++++++++----------- 1 file changed, 42 insertions(+), 42 deletions(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index af6d2edc5..645b06910 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -3,9 +3,9 @@ Como aprendimos desde el capítulo , hay ocho tipos de datos en JavaScript. Siete de ellos se denominan "primitivos", porque sus valores contienen solo un dato (sea un `string`, un número o lo que sea). -En contraste, los objetos son usados para almacenar colecciones de varios datos y entidades más complejas asociados con un nombre clave. En JavaScript, los objetos penetran casi todos los aspectos del lenguaje. Por lo tanto, debemos comprenderlos primero antes de profundizar en cualquier otro lugar. +En contraste, los objetos son usados para almacenar colecciones de varios datos y entidades más complejas asociados con un nombre clave. En JavaScript, los objetos penetran casi todos los aspectos del lenguaje. Por lo tanto, debemos comprenderlos primero antes de profundizar en cualquier otro lugar. llaves -Podemos crear un objeto usando las llaves `{…}` con una lista opcional de *propiedades*. Una propiedad es un par "key:value", donde `key` es un string (también llamado "nombre clave"), y `value` puede ser cualquier cosa. +Podemos crear un objeto usando las llaves `{…}` con una lista opcional de *propiedades*. Una propiedad es un par "key:value", donde `key` es un string (también llamado "nombre clave"), y `value` puede ser cualquier cosa. P.D. Para fines prácticos de la lección, nos referiremos a este par de conceptos como "clave:valor". Podemos imaginar un objeto como un gabinete con archivos firmados. Cada pieza de datos es almacenada en su archivo por la clave. Es fácil encontrar un archivo por su nombre o agregar / eliminar un archivo. @@ -20,16 +20,16 @@ let user = {}; // sintaxis de "objeto literal" ![](object-user-empty.svg) -Regularmente, {...} se utilizan los corchetes. Esa declaración se llama *objeto literal*. +Regularmente, se utilizan las llaves `{...}`. Esa declaración se llama *objeto literal*. ## Literales y propiedades -Podemos poner inmediatamente algunas propiedades dentro de `{...}` como pares "clave: valor": +Podemos poner inmediatamente algunas propiedades dentro de `{...}` como pares "clave:valor": ```js let user = { // un objeto - name: "John", // En la llave "name" se almacena el valor "John" - age: 30 // En la llave "age" se almacena el valor 30 + name: "John", // En la clave "name" se almacena el valor "John" + age: 30 // En la clave "age" se almacena el valor 30 }; ``` @@ -37,8 +37,8 @@ Una propiedad tiene una clave (también conocida como "nombre" o "identificador" En el objeto `user` hay dos propiedades: -1. La primer propiedad tiene el nombre `"name"` y el valor `"John"`. -2. La segunda tienen el nombre `"age"` y el valor `30`. +1. La primer propiedad tiene la clave `"name"` y el valor `"John"`. +2. La segunda tienen la clave `"age"` y el valor `30`. Podemos imaginar al objeto `user` resultante como un gabinete con dos archivos firmados con las etiquetas "name" y "age". @@ -70,13 +70,13 @@ delete user.age; ![user object 3](object-user-delete.svg) -También podemos nombrar propiedades con más de una plabra (*multiword*). Pero, de ser así, debemos colocarlos entre comillas `"..."`: +También podemos nombrar propiedades con más de una palabra. Pero, de ser así, debemos colocar la clave entre comillas `"..."`: ```js let user = { name: "John", age: 30, - "likes birds": true // Las claves multiword deben ir entre comillas + "likes birds": true // Las claves con más de una palabra deben ir entre comillas }; ``` @@ -109,16 +109,16 @@ user.name = "Pete"; // (*) alert(user.name); // Pete ``` -Puede parecer que la linea `(*)` ocasionaría un error, pero no. El `const` fija el valor de `user` pero no su contenido. +Puede parecer que la linea `(*)` ocasionaría un error, pero no. El `const` restablece el valor de `user` pero no su contenido. -El `const` podría dar error solo si intentamos asignar `user=...` en su totalidad. +El `const` podría dar error solo si intentamos asignar `user=...` en la totalidad de su contenido. -Hay otra manera de crear objetos con propiedades fijas, las veremos después en el capítulo . +Hay otra manera de crear objetos con propiedades constantes, las veremos después en el capítulo . ```` -## Corchetes +## Llaves -Para acceder a propiedades de varias palabras la notación de punto no funciona: +La notación de punto no funciona para acceder a propiedades con claves de más de una palabra: ```js run // Esto nos daría un error de sintaxis @@ -129,12 +129,12 @@ JavaScript no entiende eso. Piensa que hemos accedido a `user.likes` y entonces El punto requiere que la clave sea un identificador de variable válido. Eso implica que: no contenga espacios, no comience con un dígito y no incluya caracteres especiales (`$` y `_` sí se permiten). -Existe una "notación de corchetes" alternativa que funciona con cualquier string: +Existe una "notación de llaves" alternativa que funciona con cualquier string: ```js run let user = {}; -// configurando +// asignando user["likes birds"] = true; // obteniendo @@ -144,9 +144,9 @@ alert(user["likes birds"]); // true delete user["likes birds"]; ``` -Ahora todo está bien. Nota que el string dentro de los corchetes está adecuadamente citado (cualquier tipo de comillas serviría). +Ahora todo está bien. Nota que el string dentro de las llaves está adecuadamente entre comillas (cualquier tipo de comillas servirían). -Los corchetes también nos proveen de una forma para obtener el nombre de la propiedad como resultado de cualquier expresión como una variable -- en lugar de una cadena literal -- de la siguiente manera: +Las llaves también nos proveen de una forma para obtener la clave de la propiedad como resultado de cualquier expresión como una variable -- en lugar de una cadena literal -- de la siguiente manera: ```js let key = "likes birds"; @@ -185,7 +185,7 @@ alert( user.key ) // undefined ### Propiedades calculadas -Podemos usar corchetes en un objeto literal al crear un objeto. A esto se le llama *propiedades calculadas*. +Podemos usar llaves en un objeto literal al crear un objeto. A esto se le llama *propiedades calculadas*. Por ejemplo: @@ -201,7 +201,7 @@ let bag = { alert( bag.apple ); // 5 si fruit es="apple" ``` -El significado de una propiedad calculada es simple: `[fruit]` significa que se debe tomar el nombre de la propiedad `fruit`. +El significado de una propiedad calculada es simple: `[fruit]` significa que se debe tomar la clave de la propiedad `fruit`. Entonces, si un visitante ingresa `"apple"`, `bag` se convertira en `{apple: 5}`. @@ -216,7 +216,7 @@ bag[fruit] = 5; ...Pero luce mejor. -Podemos usar expresiones más complejas dentro de los corchetes: +Podemos usar expresiones más complejas dentro de las llaves: ```js let fruit = 'apple'; @@ -225,11 +225,11 @@ let bag = { }; ``` -Los corchetes son mucho más potentes que la notación de punto. Permiten cualquier nombre de propiedad y variables. Pero también son más engorrosos de escribir. +Las llaves son mucho más potentes que la notación de punto. Permiten cualquier nombre de propiedad y variables. Pero también son más engorrosos de escribir. -Entonces, la mayoría de las veces, cuando los nombres de propiedad son conocidos y simples, se utiliza el punto. Y si necesitamos algo más complejo, entonces cambiamos a corchetes. +Entonces, la mayoría de las veces, cuando los nombres de propiedad son conocidos y simples, se utiliza el punto. Y si necesitamos algo más complejo, entonces cambiamos a llaves. -## Shorthand paraa valores de propiedad +## Atajo para valores de propiedad En el código real, a menudo usamos variables existentes como valores de los nombres de propiedades. @@ -248,7 +248,7 @@ let user = makeUser("John", 30); alert(user.name); // John ``` -En el ejemplo anterior las propiedades tienen los mismos nombres que las variables. El uso de la creación de propiedades a partir de las variables es tan común que existe un *shorthand (abreviatura) para valores de propiedad* especial para acortarla. +En el ejemplo anterior las propiedades tienen los mismos nombres que las variables. El uso de variables para la creación de propiedades es tán común que existe un *atajo para valores de propiedad* especial para hacerla más corta. En lugar de `name:name`, simplemente podemos escribir `name`, tal cual: @@ -264,7 +264,7 @@ function makeUser(name, age) { } ``` -Podemos usar ambos tipos de notación en un mismo objeto, la normal y el shorthand: +Podemos usar ambos tipos de notación en un mismo objeto, la normal y el atajo: ```js let user = { @@ -315,7 +315,7 @@ obj.__proto__ = 5; // asignando un número alert(obj.__proto__); // [objeto Object] - el valor es un objeto, no funciona como se "debería" ``` -Como podemos ver en el código, se ignora la asignación a un primario `5`. +Como podemos ver en el código, se ignora la asignación de un valor primitivo `5`. Veremos la naturaleza especial de `__proto__` en los [capítulos siguientes](info:prototype-inheritance), y sugeriremos las [formas de arreglar](info:prototype-methods) tal comportamiento. @@ -347,15 +347,15 @@ alert( "age" in user ); // mostrará "true", user.age sí existe alert( "blabla" in user ); // mostará false, user.blabla no existe ``` -Nota que a la izquierda de `in` debe estar el *nombre de la propiedad* que suele ser un string citado. +Nota que a la izquierda de `in` debe estar el *nombre de la propiedad* que suele ser un string entre comillas. -Si omitimos las comillas significa una variable. Esta variable debería almacenar el nombre real que será probado. Por ejemplo: +Si omitimos las comillas significa una variable. Esta variable debería almacenar la clave real que será probado. Por ejemplo: ```js run let user = { age: 30 }; let key = "age"; -alert( *!*key*/!* in user ); // true, porque su propiedad "age" si existe dentro del objeto +alert( *!*key*/!* in user ); // true, porque su propiedad "age" sí existe dentro del objeto ``` Pero... ¿Por qué existe el operador `in`? ¿No es suficiente comparar con `undefined`? @@ -376,7 +376,7 @@ alert( "test" in obj ); //es true, ¡La propiedad sí existe! En el código anterior, la propiedad `obj.test` técnicamente existe. Entonces el operador `in` funciona correctamente. -Situaciones como esta suceden raramente ya que `undefined` no debe ser explícitamente asignado. Comunmente usamos `null` para valores "desconocidos" o "vacios". Por lo que el operdaor `in` es un invitado exótico en nuestro código. +Situaciones como esta suceden raramente ya que `undefined` no debe ser explícitamente asignado. Comúnmente usamos `null` para valores "desconocidos" o "vacíos". Por lo que el operador `in` es un invitado exótico en nuestro código. ## El bucle "for..in" @@ -387,7 +387,7 @@ La sintaxis: ```js for (key in object) { - // se ejecuta e cuerpo para cada clave entre las propiedades del objeto + // se ejecuta el cuerpo para cada clave entre las propiedades del objeto } ``` @@ -410,13 +410,13 @@ for (let key in user) { Nota que todas las construcciones "for" nos permiten declarar variables para bucle dentro del bucle, como `let key` aquí. -Además podriamos usar otros nombres de variables en lugar de `key`. Por ejemplo, `"for (let prop in obj)"` también se usa bastante. +Además podríamos usar otros nombres de variables en lugar de `key`. Por ejemplo, `"for (let prop in obj)"` también se usa bastante. ### Ordenado como un objeto -¿Los objetos son ordenados? Es decir, si creamos un bucle sobre un objeto, ¿obtenemos todas las propiedades en el mismo orden en el que se agregaron? ¿Podemos confiar en ello? +¿Los objetos están ordenados? Es decir, si creamos un bucle sobre un objeto, ¿obtenemos todas las propiedades en el mismo orden en el que se agregaron? ¿Podemos confiar en ello? -La respuesta corta es: "ordenados de una forma especial": las propiedades de enteros se ordenan, los demás aparecen en el orden de la creación. Entremos en detalle. +La respuesta corta es: "ordenados de una forma especial": las propiedades de números números enteros se ordenan, los demás aparecen en el orden de la creación. Entremos en detalle. Como ejemplo, consideremos un objeto con códigos telefónicos: @@ -443,15 +443,15 @@ Pero si ejecutamos el código, veremos una imagen totalmente diferente: - USA (1) va primero - Luego Switzerland (41) y así sucecivamente. -Los códigos telefónicos van en orden ascendente porque son enteros. Entonces vemos `1, 41, 44, 49`. +Los códigos telefónicos van en orden ascendente porque son números enteros. Entonces vemos `1, 41, 44, 49`. -````smart header="¿Propiedades de enteros? ¿Qué es eso?" -El término "propiedad de enteros" aquí significa que una cadena se puede convertir a y desde desde un entero sin nigún cambio. +````smart header="¿Propiedades de números enteros? ¿Qué es eso?" +El término "propiedad de números enteros" aquí significa que una cadena se puede convertir a y desde desde un entero sin nigún cambio. Entonces, "49" es un nombre de propiedad entero, porque cuando este se transforma a un entero y viceversa continua siendo el mismo. Pero "+49" y "1.2" no lo son: ```js run -// Math.trunc es una función incorporada que elimina la parte decimal +// Math.trunc es una función nativa que elimina la parte decimal alert( String(Math.trunc(Number("49"))) ); // "49", es igual, una propiedad entera alert( String(Math.trunc(Number("+49"))) ); // "49", no es igual "+49" ⇒ no es una propiedad entera alert( String(Math.trunc(Number("1.2"))) ); // "1", no es igual "1.2" ⇒ no es una propiedad entera @@ -509,7 +509,7 @@ Para acceder a una propiedad, podemos usar: Operadores adicionales: - Para eliminar una propiedad: `delete obj.prop`. --Para comprobar si existe una propiedad con la clave proporcionada: `"key" in obj`. +- Para comprobar si existe una propiedad con la clave proporcionada: `"key" in obj`. - Para crear bluces sobre un objeto: bucle `for (let key in obj)`. Lo que hemos estudiado en este capítulo se llama "objeto simple", o solamente `Object`. @@ -521,6 +521,6 @@ Hay muchos otros tipos de objetos en JavaScript: - `Error` para almacenar información sobre un error. - ...Y así. -Tienen sus características especiales que estudiaremos más adelante. A veces las personas dicen algo como "Tipo de matriz" o "Tipo de fecha", pero formalmente no son tipos en sí, sino que pertenecen a un tipo de datos de "objeto" simple y lo amplian a varias maneras. +Tienen sus características especiales que estudiaremos más adelante. A veces las personas dicen algo como "Tipo `array`" o "Tipo `date`", pero formalmente no son tipos en sí, sino que pertenecen a un tipo de datos de "objeto" simple y lo amplian a varias maneras. Los objetos en JavaScript son muy poderosos. Aquí acabamos de arañar la superficie de un tema que es realmente enorme. Trabajaremos estrechamente con los objetos y aprenderemos más sobre ellos en otras partes del tutorial. From 59c64aeb2d79b5744e48d3561f7dd175e6eeeea9 Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Sun, 26 Jul 2020 22:43:56 -0500 Subject: [PATCH 26/32] Update 1-js/04-object-basics/01-object/article.md Co-authored-by: joaquinelio --- 1-js/04-object-basics/01-object/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index 645b06910..a88e6ba6a 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -90,7 +90,7 @@ let user = { age: 30*!*,*/!* } ``` -Eso se llama una coma "final" o "colgante". Facilita agregar / eliminar / mover propiedades, porque todas las líneas se vuelven similares. +Eso se llama una coma "final" o "colgante". Facilita agregar, eliminar y mover propiedades, porque todas las líneas se vuelven similares. ````smart header="Los objetos con const pueden cambiarse" Toma en cuenta: un objeto declarado con `const` *puede* ser modificado. From 5ab2bdacbd175ae725358ae350687e9e9ea29833 Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Sun, 26 Jul 2020 22:44:18 -0500 Subject: [PATCH 27/32] Update 1-js/04-object-basics/01-object/article.md Co-authored-by: joaquinelio --- 1-js/04-object-basics/01-object/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index a88e6ba6a..52ccd466a 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -37,7 +37,7 @@ Una propiedad tiene una clave (también conocida como "nombre" o "identificador" En el objeto `user` hay dos propiedades: -1. La primer propiedad tiene la clave `"name"` y el valor `"John"`. +1. La primera propiedad tiene la clave `"name"` y el valor `"John"`. 2. La segunda tienen la clave `"age"` y el valor `30`. Podemos imaginar al objeto `user` resultante como un gabinete con dos archivos firmados con las etiquetas "name" y "age". From 6ee7129a3ddd5aaa9c05412d6134df62c348cae2 Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Sun, 26 Jul 2020 22:46:18 -0500 Subject: [PATCH 28/32] Update 1-js/04-object-basics/01-object/article.md Co-authored-by: joaquinelio --- 1-js/04-object-basics/01-object/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index 52ccd466a..cad0b5e5c 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -116,7 +116,7 @@ El `const` podría dar error solo si intentamos asignar `user=...` en la totalid Hay otra manera de crear objetos con propiedades constantes, las veremos después en el capítulo . ```` -## Llaves +## Corchetes La notación de punto no funciona para acceder a propiedades con claves de más de una palabra: From 07f73219ca0e28752ef3421398836b71ba108afa Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Sun, 26 Jul 2020 22:47:14 -0500 Subject: [PATCH 29/32] Update 1-js/04-object-basics/01-object/article.md Co-authored-by: joaquinelio --- 1-js/04-object-basics/01-object/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index cad0b5e5c..7e2f99c89 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -129,7 +129,7 @@ JavaScript no entiende eso. Piensa que hemos accedido a `user.likes` y entonces El punto requiere que la clave sea un identificador de variable válido. Eso implica que: no contenga espacios, no comience con un dígito y no incluya caracteres especiales (`$` y `_` sí se permiten). -Existe una "notación de llaves" alternativa que funciona con cualquier string: +Existe una "notación de corchetes" alternativa que funciona con cualquier string: ```js run let user = {}; From 26097686c85ef0558e7e024f4952c3a8bdcaa263 Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Sun, 26 Jul 2020 22:47:44 -0500 Subject: [PATCH 30/32] Update 1-js/04-object-basics/01-object/article.md Co-authored-by: joaquinelio --- 1-js/04-object-basics/01-object/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index 7e2f99c89..fa2309cd7 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -144,7 +144,7 @@ alert(user["likes birds"]); // true delete user["likes birds"]; ``` -Ahora todo está bien. Nota que el string dentro de las llaves está adecuadamente entre comillas (cualquier tipo de comillas servirían). +Ahora todo está bien. Nota que el string dentro de los corchetes está adecuadamente entre comillas (cualquier tipo de comillas servirían). Las llaves también nos proveen de una forma para obtener la clave de la propiedad como resultado de cualquier expresión como una variable -- en lugar de una cadena literal -- de la siguiente manera: From 31ea37cc23acc4fdfbbce25a7cae97b56cb0b779 Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Sun, 26 Jul 2020 22:48:29 -0500 Subject: [PATCH 31/32] Update 1-js/04-object-basics/01-object/article.md Co-authored-by: joaquinelio --- 1-js/04-object-basics/01-object/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index fa2309cd7..352ad0803 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -3,7 +3,7 @@ Como aprendimos desde el capítulo , hay ocho tipos de datos en JavaScript. Siete de ellos se denominan "primitivos", porque sus valores contienen solo un dato (sea un `string`, un número o lo que sea). -En contraste, los objetos son usados para almacenar colecciones de varios datos y entidades más complejas asociados con un nombre clave. En JavaScript, los objetos penetran casi todos los aspectos del lenguaje. Por lo tanto, debemos comprenderlos primero antes de profundizar en cualquier otro lugar. llaves +En contraste, los objetos son usados para almacenar colecciones de varios datos y entidades más complejas asociados con un nombre clave. En JavaScript, los objetos penetran casi todos los aspectos del lenguaje. Por lo tanto, debemos comprenderlos primero antes de profundizar en cualquier otro lugar. Podemos crear un objeto usando las llaves `{…}` con una lista opcional de *propiedades*. Una propiedad es un par "key:value", donde `key` es un string (también llamado "nombre clave"), y `value` puede ser cualquier cosa. P.D. Para fines prácticos de la lección, nos referiremos a este par de conceptos como "clave:valor". From 0bbfc4a19dba1997d38451a3e4e420deb6152820 Mon Sep 17 00:00:00 2001 From: Maksumi Murakami Date: Sun, 26 Jul 2020 22:51:05 -0500 Subject: [PATCH 32/32] Apply suggestions from code review Co-authored-by: joaquinelio --- 1-js/04-object-basics/01-object/article.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/1-js/04-object-basics/01-object/article.md b/1-js/04-object-basics/01-object/article.md index 352ad0803..2358c0b0b 100644 --- a/1-js/04-object-basics/01-object/article.md +++ b/1-js/04-object-basics/01-object/article.md @@ -185,7 +185,7 @@ alert( user.key ) // undefined ### Propiedades calculadas -Podemos usar llaves en un objeto literal al crear un objeto. A esto se le llama *propiedades calculadas*. +Podemos usar corchetes en un objeto literal al crear un objeto. A esto se le llama *propiedades calculadas*. Por ejemplo: @@ -203,7 +203,7 @@ alert( bag.apple ); // 5 si fruit es="apple" El significado de una propiedad calculada es simple: `[fruit]` significa que se debe tomar la clave de la propiedad `fruit`. -Entonces, si un visitante ingresa `"apple"`, `bag` se convertira en `{apple: 5}`. +Entonces, si un visitante ingresa `"apple"`, `bag` se convertirá en `{apple: 5}`. Esencialmente esto funciona igual que: ```js run @@ -216,7 +216,7 @@ bag[fruit] = 5; ...Pero luce mejor. -Podemos usar expresiones más complejas dentro de las llaves: +Podemos usar expresiones más complejas dentro de los corchetes: ```js let fruit = 'apple'; @@ -225,9 +225,9 @@ let bag = { }; ``` -Las llaves son mucho más potentes que la notación de punto. Permiten cualquier nombre de propiedad y variables. Pero también son más engorrosos de escribir. +Los corchetes son mucho más potentes que la notación de punto. Permiten cualquier nombre de propiedad y variables. Pero también son más engorrosos de escribir. -Entonces, la mayoría de las veces, cuando los nombres de propiedad son conocidos y simples, se utiliza el punto. Y si necesitamos algo más complejo, entonces cambiamos a llaves. +Entonces, la mayoría de las veces, cuando los nombres de propiedad son conocidos y simples, se utiliza el punto. Y si necesitamos algo más complejo, entonces cambiamos a corchetes. ## Atajo para valores de propiedad @@ -344,7 +344,7 @@ Por ejemplo: let user = { name: "John", age: 30 }; alert( "age" in user ); // mostrará "true", user.age sí existe -alert( "blabla" in user ); // mostará false, user.blabla no existe +alert( "blabla" in user ); // mostrará false, user.blabla no existe ``` Nota que a la izquierda de `in` debe estar el *nombre de la propiedad* que suele ser un string entre comillas.