Che cosa significa ReturnIfAbrupt nella bozza ES6?

Question

Attualmente sto implementando alcuni spessori per la bozza ES6. Mi chiedo se qualcuno possa dirmi cosa significa ReturnIfAbrupt. Per esempio, la mia implementazione per Number.toInt (che chiamate interne [[ToInteger]] è la seguente:.

if (!('toInt' in Number)) 
    Object.defineProperty(Number, 'toInt', { 

     value: function toInt(value) { 
      // ECMA-262 Ed. 6, 9-27-12. 9.1.4 

      // 1. Let number be the result of calling ToNumber on the input argument. 
      var number = Number(value); 

      // 2. ReturnIfAbrupt(number). 
      // ? 

      // 3. If number is NaN, return +0. 
      if (number != number) return 0; 

      // 4. If number is +0, -0, +Infinity, or -Infinity, return number. 
      if (number == 0 || 1/number == 0) return number; 

      // 5. Return the result of computing sign(number) * floor(abs(number)). 
      return (n < 0 ? -1 : 1) * Math.floor(Math.abs(number)); 

     }, 

     writable: true, 
     configurable: true 

    }); 

Fase 2 è ReturnIfAbrupt(number) Noterete ho attualmente // ? per questo passo, perché io non sono sicuro di cosa fare cosa. significa quando si dice ReturnIfAbrupt(...)?

ho letto la sezione sulla ReturnIfAbrupt nel progetto, ma non riesco a capire cosa fare per la fase 2, cosa mettere al posto del // ? nel codice di cui sopra.

Dalla mia lettura, potrebbe essere che nulla dovrebbe essere fatto, e il passo ReturnIfAbrupt significa semplicemente lasciare che qualsiasi errore che si è verificato in ToNumber si propaghi, uscendo dalla funzione. Tuttavia, ciò sembra eccessivamente prolisso, come direi che potrebbe non dirlo. Inoltre, non mi sembra che lo ToNumber possa persino generare un errore. Qualcuno potrebbe confermare o aiutarmi a capire il vero significato?

Answer 1

ReturnIfAbrupt fa riferimento a un completamento brusco. Un record di completamento contiene un tipo e il valore associato ad esso. Un completamento normale sarebbe qualcosa come il valore risultante di un'espressione. Un completamento di ritorno da una funzione è il solito completamento previsto oltre a un normale completamento. Qualsiasi altro tipo di completamento è brusco. Questo è buttare, rompere, continuare.

if (isCompletionRecord(v)) { 
    if (isAbruptCompletion(v)) { 
    return v; 
    } else { 
    v = v.value; 
    } 
} 

Implementandolo come sei, ciò che comporterebbe è il wrapping della funzione in un tentativo di cattura. Un valore generato sarebbe un completamento brusco. Questo non è qualcosa che si vede a livello di JS, tuttavia, è per implementare il flusso di controllo e i trasferimenti di controllo non locali a livello del motore.

Ho implementato gran parte delle specifiche ES6 in una macchina virtuale JS che può anche aiutare a far luce su di esso, ecco ToInteger: https://github.com/Benvie/continuum/blob/master/lib/continuum.js#L516

function ToInteger(argument){ 
    if (argument && typeof argument === OBJECT && argument.IsCompletion) { 
    if (argument.IsAbruptCompletion) { 
     return argument; 
    } 
    argument = argument.value; 
    } 
    return ToNumber(argument) | 0; 
}