El estándar ECMAScript 6 agregó muchas características nuevas al lenguaje JavaScript, incluida una nueva notación de función de flecha .

Su tarea es escribir un transpilador básico de ES6 a ES5. Dado solo una función de flecha ES6 como entrada, genera su contraparte compatible con ES5.

¡Es código golf ! ¡Que gane el programa más corto en bytes!

Los basicos

Una función de flecha se ve así:

(a, b, c) => { return a + b - c }

Y su expresión de función ES5 equivalente se ve así:

function(a, b, c) { return a + b - c }

En general, puede copiar el cuerpo de la función (todo entre llaves) literalmente.

Declaración de devolución implícita

En lugar de un cuerpo con llaves, se puede usar una sola expresión; El resultado de esta expresión se devuelve.

(a, b, c) => a + b - c

function(a, b, c) { return a + b - c }

Otro ejemplo:

(a, b, c) => (a + 1, b - 2 * c / 3)

function(a, b, c) { return (a + 1, b - 2 * c / 3) }

Una vez más, puede simplemente copiar la expresión literalmente, ¡PERO tenga cuidado de no generar un salto de línea entre esta y la returnpalabra clave para evitar la inserción automática de punto y coma!

Un argumento

Los paréntesis son opcionales si se proporciona un argumento.

foo => { return foo + 'bar' }

function(foo) { return foo + 'bar' }

Espacio en blanco

Finalmente, debe poder tener en cuenta cualquier número de caracteres de espacio en blanco (espacio, tabulación, nueva línea) antes o después de paréntesis, variables, comas, llaves y la flecha *.

 ( o   ,  O
     , _    )=>{

    return                                     "Please don't write code like this."
}

Si decide conservar o no los espacios en blanco en la salida, depende de usted. Guárdelos, elimínelos o agregue el suyo, ¡solo asegúrese de que sea un código válido!

_{* Es técnicamente ilegal que aparezca una flecha inmediatamente después de un salto de línea, pero dudo que este hecho pueda ayudarlo. :)}

Una forma rápida de validar su salida:

Ingrese var foo = <your output>; foo()a la consola de su navegador. Si no se queja, probablemente esté en el camino correcto.

Más reglas para los magos:

• La entrada es una función de flecha ES6 sintácticamente válida.
• Supongamos que el cuerpo de la función es compatible con ES5 (y no hace referencia this, super, arguments, etc). Esto también significa que la función nunca contendrá otra función de flecha (pero no puede suponer que "=>" nunca ocurrirá dentro del cuerpo).
• Los nombres de las variables solo consistirán en letras latinas básicas $y _.
• No es necesario que transpile las funciones de ES6 que no están enumeradas anteriormente (parámetros predeterminados, operador de descanso, desestructuración, etc.).
• El espacio después de una returndeclaración es opcional si es seguido por (, [o {.
• No es estrictamente necesario hacer coincidir exactamente mis casos de prueba: puede modificar el código tanto como lo necesite si ayuda a reducir su recuento de bytes. Realmente, siempre que produzca una expresión de función ES5 sintácticamente válida y funcionalmente equivalente, ¡es dorado!

JavaScript (ES6), 123 110 100 97 bytes

Guardado 3 bytes gracias a @Neil

s=>s.replace(/\(?(.*?)\)?\s*=>\s*([^]*)/,(_,a,b)=>`function(${a})${b[0]=='{'?b:`{return ${b}}`}`)

Asume que la entrada es una función de flecha sintácticamente válida y nada más. Maneja correctamente el caso a =>\na, aunque no lo manejo no es más corto por lo que puedo decir.

Salida cuando el código se ejecuta a través de sí mismo:

function(s){return s.replace(/\(?(.*?)\)?\s*=>\s*([^]*)/,(_,a,b)=>`function(${a})${b[0]=='{'?b:`{return ${b}}`}`)}

Puedo guardar 9 bytes con un formato posiblemente no válido:

s=>s.replace(/\(?(.*?)\)?\s*=>\s*({?)([^]*?)}?$/,(_,a,z,b)=>Function(a,z?b:'return '+b))

Salida por sí mismo:

function anonymous(s) {
return s.replace(/\(?([^=)]*)\)?\s*=>\s*({?)([^]*?)}?$/,(_,a,z,b)=>Function(a,z?b:'return '+b))
}

(Específicamente, esto function anonymouses lo que me preocupa).

Retina, 86 80 79 bytes

^ ([^ (] *?) =
($ 1) =
s (`\ s * $

> \ s * (. * [^}]) $
> {return $ 1}
) `(. *?) => (. *)
función $ 1 $ 2

Pruébalo en línea!

Salvó un byte gracias a Neil

Guardado 6 bytes con ayuda de ETHproductions

Editar: se corrigió la posibilidad de nuevas líneas en el cuerpo de la función.

Solución de 75 bytes asumiendo que la entrada no contendrá §: ¡ Pruébelo en línea!

PHP, 112 bytes

preg_match("#\(??(.*)\)?=>(\{?)(.*$)#U",$argn,$m);echo"function($m[1])",trim($b=$m[3])[0]=="{"?$b:"{return $b}";

toma entrada de STDIN; corre con-R