No ECMAScript 2015, o JavaScript possui 33 palavras-chave reservadas , como break, conste new, além de 10 futuras palavras-chave reservadas , como lete await.

Sua tarefa é encadear o maior número de ¹ palavras-chave reservadas distintas consecutivas ² ao escrever o código JavaScript funcional ³ .

1. Palavras-chave reservadas consecutivas - palavras-chave reservadas que são separadas apenas por espaços em branco e / ou parênteses e / ou chaves.
2. Palavras-chave reservadas - quaisquer palavras-chave reservadas ou futuras reservadas a partir do ECMAScript 2015 . Palavras-chave reservadas de padrões mais antigos são excluídas. Uma lista completa de palavras-chave permitidas é fornecida abaixo.
3. Código funcional - seu código deve ser executado (indicar seu tempo de execução, se necessário), eventualmente parar e não gerar erros de tempo de execução.

Se o seu código precisar de um tempo de execução específico, as palavras-chave reservadas usadas não deverão ser não operacionais no ambiente especificado.

Lista de palavras-chave 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

Pontuação e exemplos

Sua pontuação será igual ao maior número de palavras-chave reservadas distintas consecutivas.
No caso de pontuações iguais, o menor código-fonte em bytes vence. Seções e seqüências comentadas não contam para palavras-chave reservadas, mas para contagem 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;

Aplicam-se brechas padrão .

43 palavras, 603 bytes

Uhm, isso é uma brecha? Eu não tenho idéia de como diabos isso é JS legal, mas funciona e usa todas as palavras-chave.

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 palavras

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 }
}

Palavras-chave não utilizadas:

• case requer :
• const requer =
• export requer modo estrito
• import requer modo estrito
• super requer constructor

43 palavras, 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 palavras, 185 bytes

+ 1 2 palavras graças a Arnauld e +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{}:{}}

Assumindo que entendi o desafio, isso marca 24 palavras. As palavras sem parênteses, colchetes e espaço em branco:

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 palavras, 177 bytes

Sem "verdadeiro" e "falso", que aparentemente não são palavras-chave de acordo com a pergunta.

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

Palavras:

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
 }:
}

palavras de "super" para "const"

Versão Golfed:

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 palavras

(não tenho certeza lete 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 palavras, 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}}

Mais facilmente:

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
        }
    }

Eu tive que usar a "palavra reservada como nome do método" para lidar com

• case(já que eu já tinha usado defaultcom o meu swtich),
• exporte import(como o modo de módulo é sempre rigoroso, o que desqualifica with)
• super(já que deve ser seguido por um acesso à propriedade ou colocado em uma constructorfunção), e
• enum (que nunca pode ser usada, sendo uma palavra reservada sem uso gramaticalmente válido)

14 15 16 Palavras sem colchetes ou nova linha

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

Obrigado Bergi por +1

28 palavras sem colchetes, 234 bytes

Colocar nomes de identificadores como nomes de definição de método era muito óbvio ( pelo menos para mim ), então eu estava procurando a sequência distinta consecutiva mais longa de palavras reservadas e espaços em branco em um trecho de código.

Espero que o código morto após a returnnão conte como brecha, mas o código ainda possa ser executado se os identificadores usados ​​forem declarados.

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)}}

Isso explora o fato de que algumas das futuras palavras-chave reservadas são consideradas inválidas apenas no modo estrito do ES5.1 (aparentemente porque os mecanismos não se deram ao trabalho de bloquear todas as futuras palavras reservadas do ES3, portanto havia muito código usando-as na Web) )

Da mesma forma, os tokens asynce awaitintroduzidos no ES8 são considerados apenas palavras-chave no modo estrito.