Alguien me puede explicar lo que es la bandera "LeftFirst" de Boole se han definido en la especificación ECMAScript

Kevin:

¿Puede alguien me explique lo que es el LeftFirstindicador booleano? al leer la especificación EcmaScript acerca [relacionales-operadores] ( https://tc39.es/ecma262/#sec-relational-operators "definición-operadores relacionales en ECMAScript") y Resumen relacional Comparación he encontrado algo así como la LeftFirstbandera booleana que sea se convierte trueo false, pero no sé lo que es el uso de la misma y por lo que está ahí alguien me puede explicar con claridad cuál es el propósito de la LeftFirstbandera booleana y por qué se usa en la memoria la explicación que han dado no es mucho más clara que quiere saber lo que es el uso de la misma la leftFirstbandera booleana y por qué se utiliza?

TJ Crowder:

Como se anotó, es una de las entradas al algoritmo Resumen Comparación relacional . Su único propósito es determinar que operando el algoritmo de comparación se pasa a ToPrimitive primero, el de la izquierda ( leftFirst = true) o el de la derecha ( leftFirst = false). La razón es que el extracto relacional Comparación siempre hace una <comparación, pero que también se usa en la evaluación de >expresiones (con los operandos invertidos). Por eso, cuando el manejo de una >, que necesita ser contada a utilizar ToPrimitive en la mano derecha operando en primer lugar.

Se puede ver utilizado en el primer paso del algoritmo:

1. Si el LeftFirst bandera es cierto , entonces
   • Deje px ser? ToPrimitive ( x , Número pista).
   • Deje py sea? ToPrimitive ( y , Número pista).
2. Si no,
   NOTA: El orden de evaluación debe ser invertida para preservar izquierda a derecha evaluación.
   • Deje py sea? ToPrimitive ( y , Número pista).
   • Deje px ser? ToPrimitive ( x , Número pista).

También en la descripción:

La bandera se utiliza para controlar el orden en que se realizan las operaciones con efectos secundarios potencialmente visibles sobre x y y . Es necesario porque especifica ECMAScript de izquierda a derecha evaluación de expresiones.

Por ejemplo, si nos fijamos en los <y >las operaciones , la <operación hace:

5. Deje que r sea el resultado de realizar Abstract Relational Comparación lval <rval .

Que utiliza el valor predeterminado de leftFirst , que es true. Así lvalse pasa a través ToPrimitive antes rval.

Sin embargo, la >operación hace:

5. Deje que r sea el resultado de realizar Abstract Relational Comparación rval < lval con LeftFirst igual a falsa .

Observe que lo hace rval < lval, no lval > rval. Pero utiliza leftFirst = falseporque es importante que el derecho operando pasar a través ToPrimitive antes de que el operando de la izquierda, ya que la operación real es lval > rval, por lo que lvalse debe pasar a través ToPrimitive primero.

---

En un comentario que has dicho:

Muchas gracias llegué a saber por qué, si <el operador es LeftFirst trueentonces ¿por qué <=también no es LeftFirst truey por qué, si >el operador es LeftFirst falseel >=operador también no esLeftFirst false

Es, definitivamente, un poco confuso. La razón de que <y <=no coinciden (y >, y >=no coinciden) es que las <=/ >=los operadores de invertir el resultado de la comparación abstracta Relacional (ARC). Entonces:

• lval < rval hace:

  let r = ARC(lval < rval, leftFirst = true);
  return r === undefined ? false : r; // Returns what ARC returned (but
                                      // turns `undefined` into `false`)
  

• lval <= rval hace

  let r = ARC(rval < lval, leftFirst = false);
  return r === undefined ? true : !r; // Returns the *inverse* of what ARC
                                      // returned (and turns `undefined`
                                      // into `true`)
  

• lval > rval hace:

  let r = ARC(rval < lval, leftFirst = false);
  return r === undefined ? false : r; // Returns what ARC returned (but
                                      // turns `undefined` into `false`)
  

• lval >= rval hace:

  let r = ARC(lval < rval, leftFirst = true);
  return r === undefined ? true : !r; // Returns the *inverse* of what ARC
                                      // returned (and turns `undefined`
                                      // into `true`)
  

---

Una nota final, consideremos esto:

const obj = {
    get lval() {
        console.log("obj.lval was evaluated");
        return {
            valueOf() {
                console.log("lval was passed through ToPrimitive");
                return 42;
            }
        };
    },
    get rval() {
        console.log("obj.rval was evaluated");
        return {
            valueOf() {
                console.log("rval was passed through ToPrimitive");
                return 24;
            }
        };
    }
};

console.log("Using >");
const result1 = obj.lval > obj.rval;
// "obj.lval was evaluated"
// "obj.rval was evaluated"
// "lval was passed through ToPrimitive"
// "rval was passed through ToPrimitive"
console.log(result1);
// true

console.log("Using <");
const result2 = obj.lval < obj.rval;
// "obj.lval was evaluated"
// "obj.rval was evaluated"
// "lval was passed through ToPrimitive"
// "rval was passed through ToPrimitive"
console.log(result2);
// false

.as-console-wrapper {
    max-height: 100% !important;
}

La salida que se ve desde que es la siguiente:

Usando> obj.lval se evaluó obj.rval se evaluó lval se pasó a través ToPrimitive rval se pasó a través ToPrimitive verdadera usando

Esto es lo que sucede a crear esa salida para >:

1. El obj.lval > obj.rvalse evalúa la expresión
2. El > algoritmo de operador es ejecutado:
   1. Se evalúa lval = obj.lval(pasos 1 y 2), que provoca la "obj.lval was evaluated"salida
   2. Se evalúa rval = obj.rval(pasos 3 y 4), que provoca la "obj.rval was evaluated"salida
   3. Se llama ARC (Paso 5): ARC(obj.rval < obj.lval, leftFirst = false)
      1. ARC recieves obj.rvalcomo xy obj.lvalcomo sey
      2. ARC ve leftFirst = falsey así lo hace:
         • py = ToPrimitive(y)(2.b Paso), que hace que la "lval was passed through ToPrimitive"salida
         • px = ToPrimitive(x)(2.c Paso), que hace que la "rval was passed through ToPrimitive"salida
      3. vuelve ARC false
3. El >automatismo invierte el valor y la rentabilidad de retorno de ARCtrue

Esto es lo que sucede para crear la salida posterior para <:

1. El obj.lval < obj.rvalse evalúa la expresión
2. El < algoritmo de operador es ejecutado:
   1. Se evalúa lval = obj.lval(pasos 1 y 2), que provoca la "obj.lval was evaluated"salida
   2. Se evalúa rval = obj.rval(pasos 3 y 4), que provoca la "obj.rval was evaluated"salida
   3. Se llama ARC (Paso 5): ARC(obj.lval < obj.rval)(por defecto es true) leftFirst
      1. ARC recieves obj.lvalcomo xy obj.rvalcomo sey
      2. ARC ve leftFirst = truey así lo hace:
         • px = ToPrimitive(x)(1.a Paso), que hace que la "lval was passed through ToPrimitive"salida
         • py = ToPrimitive(y)(1.b Paso), que hace que la "rval was passed through ToPrimitive"salida
      3. vuelve ARC false
3. El <operador devuelve el valor de retorno de ARC,false