for..of transform when targetting ES6< [Compiler option]

Search Terms

for..of, downlevelIteration, transform, optimization, compiler option

Suggestion

Option for transforming for..of when targetting ES6 and above.

Background

Based on my investigation, for..of loops are slower than the traditional for loops (see the result: https://github.com/aminya/TypeScript-optimization)

It is pretty funny that when I target ES5, TypeScript converts for..of to the traditional loops, which makes the code faster, but I cannot do this when I target anything above ES6.

I noticed that there is "downlevelIteration" which does the opposite of what I want.

Use Cases

It enhances the performance but allows to write readable code.

Examples

// for - of
  let sum = 0
  for (const a of arr) {
    sum += a
  }

// should be transformed to:
// Traditional
  let sum = 0
  for (let i = 0, l = arr.length; i < l; ++i) {
    sum += arr[i]
  }

// or
  let sum = 0
  for (let i = 0, l = arr.length; i < l; ++i) {
    let a = arr[i]
    sum += a
  }

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

Comienza revisando la transformación existente de for..of y la opción del compilador downlevelIteration; después, compara la salida generada para objetivos ES5 y ES6 o posteriores. El issue no indica archivos ni tests; para darlo por terminado se necesitarían una opción definida, una transformación que preserve el comportamiento y cobertura para los casos de bucles sobre arrays mostrados.