Veamos qué está pasando en esta línea:

 duplication[x]++ || (duplication[x]=1)

1. duplication[x]++ , first duplication[x] verificará si la duplication tiene algún valor de x , si es así, realizará la duplication[x]++ lo contrario, no estará definido para moverse a la otra parte de or condición

2. duplication[x]=1 , esta es una asignación simple, asignará el valor 1, duplication[x] y esto creará una clave si no existe en el objeto de duplication

Ahora, si ejecuta el siguiente script y verifica el registro de la consola para cada bucle, le dará una idea clara de lo que realmente está sucediendo.

 const game = { score: "4:0", scored: ["Lewandowski", "Gnarby", "Lewandowski", "Hummels"], }; const duplication = {}; let index = 0; for (let x of game.scored) { console.log( `INDEX : ${index} ` , x , duplication[x] ? 'FOUND , INCREMENT CURRENT VALUE WITH ++' : 'NOT FOUND, SO ASSIGN VALUE 1' ); duplication[x]++ || (duplication[x]=1) console.log( `INDEX : ${index} \n` , duplication); index++; } console.log( 'FINAL OBJECT \n' , duplication);

Los nombres de variables no descriptivos realmente no ayudan a explicar la situación. Comencemos reescribiendo el código con nombres de variables más descriptivos.

 const game = { score: "4:0", scored: ["Lewandowski", "Gnarby", "Lewandowski", "Hummels"], }; const goals = {}; for (const player of game.scored) { goals[player]++ || (goals[player] = 1); } console.log(goals);

goals[player]++ incrementa los goals del player en 1 y devuelve el valor anterior. Lo complicado de los goals[player]++ es que el player podría no estar presente en los goals todavía. En cuyo caso se devuelve undefined (que es falso). Debido a que el valor es falso, se ejecutará el segundo operando del operador OR. (goals[player] = 1) establecerá los goals para el player en 1 .

Básicamente, el código cuenta la frecuencia con la que un nombre específico está presente en la matriz game.scored . La presencia de un nombre simboliza un objetivo hecho por ellos.

Una forma menos críptica de escribir un código similar sería:

 const goals = {}; for (const player of game.scored) { if (player in goals) { goals[player] += 1; // add 1 to the current score } else { goals[player] = 1; // no score present so use 1 } }

Sin embargo, generalmente prefiero establecer un valor predeterminado, de esta manera no tiene que dividir la lógica en dos acciones:

 const goals = {}; for (const player of game.scored) { goals[player] ||= 0; // assign 0 if the current value is falsy goals[player] += 1; // add 1 to the current value }

Tenga en cuenta que ||= es bastante nuevo, si escribe JavaScript para un navegador más antiguo, puede usar lo siguiente en su lugar:

 if (!goals[player]) goals[player] = 0;

la primera parte de

 duplication[x]++ || (duplication[x] = 1) ^^^^^^^^^^^^^^^^

tiene cuatro partes:

1. una duplication variable con
2. un descriptor de acceso de propiedad x en notación de paréntesis
3. un operador de incremento de postfijo ++ y
4. una expresión para el OR lógico || operador.

La segunda parte devuelve undefined en la primera llamada con una propiedad desconocida.

El intento de incrementar este valor devuelve NaN , debido a la siguiente operación de duplication[x] = duplication[x] + 1 . El resultado es un valor falso .

Esto obliga a la expresión a evaluar la parte derecha del OR lógico.

Y debido a que la parte de la izquierda tiene una expresión, primero debe evaluarse con un operador de agrupación () . Ahora tiene lugar la asignación y el resultado de 1 se devuelve al OR.