update js default arguments

Author: fjcalzado

02-languages/02-apuntes/01-javascript/102 data structures.js

@@ -1,7 +1,7 @@
 ///-- OBJETOS ************************************************************************************
 
 /*
-Datos estructurados siguiendo el formato clave-valor.
+Los objetos representan datos estructurados siguiendo el formato clave-valor.
 A cada clave o alias lo llamamos propiedad.
 */
 
@@ -122,19 +122,36 @@ collection.forEach(function (item) {
 
 // 2. for(...)
 for (let i = 0; i < collection.length; i++) {
-  console.log(collection[i]); // "hey", "ho", "let's go", "yay", (x95) undefined, "oops!"
+  console.log(collection[i]); // "hey", "ho", "let's go", "yay", "nice", empty x 95, "oops!"
 }
 
 // 3. for..of (azúcar sintáctico para objetos iterables)
 for (const item of collection) {
-  console.log(item); // "hey", "ho", "let's go", "yay", (x95) undefined, "oops!"
+  console.log(item); // "hey", "ho", "let's go", "yay", "nice", empty x 95, "oops!"
 }
 
 // Un string, por ejemplo, implementa el patrón iterable y puede ser recorrido con for..of
 for (const char of "javi") {
   console.log(char); // "j", "a", "v", "i"
 }
 
+// Eliminado elementos de un array.
+
+// Tenemos varias formas según entendamos que es para nosotros "eliminar".
+// Por un lado, contamos con un método de los arrays llamado pop para extraer el último elemento:
+collection.pop(); // returns "oops!"
+console.log(collection); // "hey", "ho", "let's go", "yay", "nice", empty x 95,
+
+// También podemos asignar 'undefined' a cualquier índice como forma 'blanda' de borrado. Esto
+// sería más bien un 'reset' de esa posición, ya que la posición seguirá existiendo;
+collection[0] = undefined;
+console.log(collection); // undefined, "ho", "let's go", "yay", "nice", empty x 95,
+
+// Aunque lo más recomendable, la forma real de borrar es usando 'splice', que devuelve la secuencia
+// borrada y muta el array:
+collection.splice(1, 2); // returns ["ho", "let's go"] => lo que hemos eliminado
+console.log(collection); // undefined, "yay", "nice", empty x 95,
+
 // Comparando arrays
 // ⚠ Los arrays son objetos y por tanto implementan la misma comparación que éstos:
 const collection = [3];

02-languages/02-apuntes/01-javascript/107 default arguments.js

@@ -11,37 +11,37 @@ greet(undefined); // "Hello, Unknown"
 greet(null); // "Hello, null"
 
 // Se pueden aplicar valores por defecto a variables asignadas por destructuring
-const logName = ({ name = "Unknown" }) => console.log(name);
-logName({ age: 24 }); // "Unknown"
-logName({ name: "Carl" }); // "Carl"
-logName({}); // "Unknown"
+const greet = ({ name = "Unknown" }) => console.log("Hello, " + name);
+greet({ age: 24 }); // "Hello, Unknown"
+greet({ name: "Carl" }); // "Hello, Carl"
+greet({}); // "Hello, Unknown"
 
 // PREGUNTA: Pero ¿que creeis que pasaría si llamo a la función sin argumento?
 // ¿o con argumento null?
 
-logName(); // ⚠ Si no inicializamos el parametro a {} esto daría TypeError.
+greet(); // ⚠ Si no inicializamos el parametro a {} esto daría TypeError.
 
 // Para evitar esos errores tenemos que inicializar también el argumento completo como objeto
 // vacío, no solo su propiedad name.
-const logName = ({ name = "Unknown" } = {}) => console.log(name);
+const greet = ({ name = "Unknown" } = {}) => console.log("Hello, " + name);
 
-logName(); // Unknown. Ahora si!
+greet(); // Hello, Unknown. Ahora si!
 
 // Este sería el único caso todavía problemático.
 // Al ser null un objeto no se toma la inicialización por defecto, el problema es que no se puede
 // hacer destructuring sobre null.
-logName(null); // ⚠ Uncaught TypeError.
+greet(null); // ⚠ Uncaught TypeError.
 
 // No obstante, ahora que ya conocemos el destructuring y el operador nullish coalescing, tenemos
 // una alternativa igual de elegante y concisa. La solución para cubrirnos todos los casos sería
 // la siguiente:
-const logName = user => {
+const greet = user => {
   const { name = "Unknown" } = user ?? {};
-  console.log(name);
+  console.log("Hello, " + name);
 }
-logName({}); // "Unknown"
-logName(); // "Unknown"
-logName(null); // "Unknown"
+greet({}); // "Hello, Unknown"
+greet(); // "Hello, Unknown"
+greet(null); // "Hello, Unknown"
 
 // Ejemplo con arrays:
 const sumDice = ([d1 = 0, d2 = 0] = []) => d1 + d2;