A partir de ECMAScript 2015, JavaScript tiene 33 palabras clave reservadas , como break, consty new, así como 10 palabras clave reservadas futuras , como lety await.

Su tarea es encadenar el mayor número de ¹ palabras clave reservadas distintas consecutivas ² mientras escribe el código JavaScript funcional ³ .

1. Palabras clave reservadas consecutivas: palabras clave reservadas que están separadas solo por espacios en blanco y / o paréntesis y / o llaves.
2. Palabras clave reservadas: cualquier palabra clave reservada o futura reservada a partir de ECMAScript 2015 . Se excluyen las palabras clave reservadas de estándares anteriores, a continuación se ofrece una lista completa de palabras clave permitidas.
3. Código funcional: su código debe ejecutarse (indique su tiempo de ejecución, si es necesario), finalmente detenerse y no arrojar ningún error de tiempo de ejecución.

Si su código necesita un tiempo de ejecución específico, las palabras clave reservadas utilizadas no deben ser no operativas en el entorno dado.

Lista de palabras clave reservadas

await
break
case
catch
class
const
continue
debugger
default
delete
do
else
enum
export
extends
finally
for
function
if
implements
import
in
instanceof
interface
let
new
package
private
protected
public
return
static
super
switch
this
throw
try
typeof
var
void
while
with
yield

Puntuación y ejemplos

Su puntaje será igual al mayor número de palabras clave reservadas distintas consecutivas.
En el caso de puntajes iguales, gana el código fuente más corto en bytes. Las secciones y cadenas comentadas no cuentan para palabras clave reservadas, sino que cuentan para el recuento de bytes.

// score: 3
if (true) 0; else throw function() {}
             ^------------------^
// score: 2
let foo = typeof typeof void typeof void 0;
                             ^---------^
// score: 0
/* typeof default debugger */

// score: 0, doesn't halt or debugger is no-op, depending on the environment
debugger;

Se aplican lagunas estándar .

43 palabras, 603 bytes

Uhm, ¿es esto una escapatoria? No tengo idea de cómo demonios es legal JS, pero funciona y utiliza cada palabra clave.

new (class await
{
    break(){}
    case(){}
    catch(){}
    const(){}
    continue(){}
    debugger(){}
    default(){}
    delete(){}
    do(){}
    else(){}
    enum(){}
    export(){}
    extends(){}
    finally(){}
    for(){}
    function(){}
    if(){}
    implements(){}
    import(){}
    in(){}
    instanceof(){}
    interface(){}
    let(){}
    package(){}
    private(){}
    protected(){}
    public(){}
    return(){}
    static(){}
    super(){}
    switch(){}
    this(){}
    throw(){}
    try(){}
    typeof(){}
    var(){}
    void(){}
    while(){}
    with(){}
    yield(){}
})

37 palabras

if (void this) {
  do {
    with (protected)
      for (public in private)
        typeof static instanceof new (function implements() {
          var let
          try {
            throw (class extends {} {})
          } catch (package) {
            yield
          } finally {
            debugger
          }
          return
        })()
    continue
    break
  } while (interface)
} else {
  switch (delete await) { default : 42 }
}

Palabras clave no utilizadas:

• case requiere :
• const requiere =
• export requiere modo estricto
• import requiere modo estricto
• super requiere constructor

43 palabras, 302 299 bytes

switch(void function(){for(const interface in public)do with(package)try{break}catch(private){if(typeof
this)throw yield static instanceof new class extends await{case(){return}super(){debugger}import(){}export(){}enum(){}}
else continue}finally{delete let}while(protected)var implements}){default:}

21 24 26 palabras, 185 bytes

+ 1 2 palabras gracias a Arnauld, y +1 a 12Me21!

void(function(){do{with({})if(typeof true in this)throw{}instanceof new(class extends{}{})
else return delete{}
try{break}finally{yield}
continue
}while(false)})()
switch({}){case{}:{}}

Suponiendo que entendí el desafío, esto suma 24 palabras. Las palabras sin paréntesis, corchetes y espacios en blanco:

void function do with if typeof true in this throw instanceof new class extends else return delete try break finally yield continue while false switch case

24 palabras, 177 bytes

Sin "verdadero" y "falso", que aparentemente no son palabras clave según la pregunta.

void(function(){do{with({})if(typeof{}in this)throw{}instanceof new(class extends{}{})
else return{}
try{break}finally{yield}
continue
}while(delete{})})()
switch({}){case{}:{}}

Palabras:

void function do with if typeof in this throw instanceof new class extends else return try break finally yield continue while delete switch case

38 39

class await {}
class g extends await {
 constructor() {
  super()
 }
}
switch ({}) {
 case function(){
  for (let in public)
  do with(package){
   try{break}catch(private){
   if(typeof this)
    throw static instanceof new (class extends await {})
   else{continue}}finally{debugger}
  }while(void protected)
  var implements
  return 
  yield delete interface
  const a=0
 }:
}

palabras de "super" a "const"

Versión de golf:

class e{}class g extends e{constructor(){super()}}switch({}){case
function(){for(let in public)do with(package)try{break}catch(private){if(typeof
this)throw static instanceof new(class extends await{})
else{continue}}finally{debugger}while(void protected)
var implements
return 
yield delete interface
const a=0}:}

21 palabras

(no estoy seguro lety await)

var await=String, let=String;
switch (await) {
    case void typeof new await instanceof let in (function()
{do{try{return this
if((class extends{}{})){}else{break}}finally{(delete {})}}while(false)})():break;
}

43 palabras, 300 bytes

with(this)try{let protected}catch(package){if(delete yield)for(const interface in typeof public)do{throw implements instanceof private}while(static)else debugger}finally{switch(void new class extends function(){return}{export(){var await}import(){break}super(){continue}enum(){}case(){}}){default:0}}

Más legible:

with(this)
    try {
        let protected
    } catch(package){
        if(delete yield)
            for(const interface in typeof public)
                do {
                    throw implements instanceof private
                } while(static)
        else
            debugger
    } finally {
        switch(
          void new class extends function(){return} {
              export(){var await}
              import(){break}
              super(){continue}
              enum(){}
              case(){}
          }
        ){
            default:0
        }
    }

Tuve que usar la "palabra reservada como nombre del método" para tratar

• case(ya que ya lo había usado defaultcon mi swtich),
• exporty import(dado que el modo módulo siempre es estricto, lo que descalifica with)
• super(ya que debe ir seguido de un acceso a la propiedad o colocado en una constructorfunción), y
• enum (que nunca se puede usar en absoluto, siendo una palabra reservada sin uso gramaticalmente válido)

14 15 16 Palabras sin corchetes o nueva línea

!function(){if(0);else do throw yield new public in void typeof this instanceof class await extends function async(){}{};while(0)}

Gracias Bergi por +1

28 palabras sin corchetes, 234 bytes

Poner nombres de identificadores como nombres de definición de método era demasiado obvio ( al menos para mí ), por lo que estaba buscando la secuencia distinta consecutiva más larga de palabras reservadas y espacios en blanco en un fragmento de código.

Espero que el código muerto después de un returnno cuente como un vacío legal, pero el código aún se puede ejecutar si se declaran los identificadores utilizados.

function*_(){implements:{
let private
var public
return yield typeof static
delete protected
throw new interface in package
break implements
debugger
void this instanceof class await extends function async(){}{}
do
continue
while(0)}}

Esto explota el hecho de que algunas de las futuras palabras clave reservadas solo se consideran inválidas en el modo estricto de ES5.1 (aparentemente porque los motores no se molestaron en bloquear todas las futuras palabras reservadas de ES3, por lo que había demasiado código usándolas en la web )

Del mismo modo, los tokens asyncy awaitintroducidos en ES8 solo se consideran palabras clave en modo estricto.