A partire da ECMAScript 2015, JavaScript ha 33 parole chiave riservate , come break, conste new, nonché 10 parole chiave riservate future , come lete await.

Il tuo compito è quello di concatenare il maggior numero di consecutive ¹ distinti parole chiave riservate ² durante la scrittura di codice funzionale JavaScript ³ .

1. Parole chiave riservate consecutive: parole chiave riservate separate solo da spazi bianchi e / o parentesi e / o parentesi graffe.
2. Parole chiave riservate - tutte le parole chiave riservate o future riservate a partire da ECMAScript 2015 . Le parole chiave riservate da standard precedenti sono escluse, di seguito è riportato un elenco completo delle parole chiave consentite.
3. Codice funzionale: il codice deve essere eseguito (indicare il runtime, se necessario), eventualmente arrestarsi e non generare errori di runtime.

Se il codice richiede un runtime specifico, le parole chiave riservate utilizzate non devono essere vietate in un determinato ambiente.

Elenco di parole chiave riservate

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

Punteggio ed esempi

Il tuo punteggio sarà uguale al maggior numero di parole chiave riservate distinte consecutive.
Nel caso di punteggi uguali, vince il codice sorgente più breve in byte. Le sezioni e le stringhe commentate non contano per le parole chiave riservate, ma contano per il conteggio dei byte.

// 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;

Si applicano scappatoie standard .

43 parole, 603 byte

Uhm, è una scappatoia? Non ho idea di come diavolo sia legale JS, ma funziona e usa ogni singola parola chiave.

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 parole

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

Parole chiave non utilizzate:

• case richiede :
• const richiede =
• export richiede una modalità rigorosa
• import richiede una modalità rigorosa
• super richiede constructor

43 parole, 302 299 byte

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 parole, 185 byte

+ 1 2 parole grazie ad Arnauld e da +1 a 12 Me21!

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

Supponendo di aver compreso la sfida, questo segna 24 parole. Le parole senza parentesi, parentesi e spazi bianchi:

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 parole, 177 byte

Senza "vero" e "falso", che apparentemente non sono parole chiave secondo la domanda.

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

Parole:

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

parole da "super" a "const"

Versione golfizzata:

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 parole

(non sono sicuro di 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 parole, 300 byte

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

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

Ho dovuto usare la "parola riservata come nome del metodo" per gestire

• case(dal momento che avevo già usato defaultcon il mio swtich),
• exporte import(poiché la modalità modulo è sempre rigorosa, il che squalifica with)
• super(poiché deve essere seguito da un accesso alla proprietà o inserito in una constructorfunzione), e
• enum (che non può mai essere usato affatto, essendo una parola riservata senza un uso grammaticalmente valido)

14 15 16 Parole senza parentesi o nuova riga

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

Grazie a Bergi per +1

28 parole senza parentesi, 234 byte

Inserire nomi identificativi come nomi di definizione del metodo era troppo ovvio ( almeno per me ), quindi stavo cercando la sequenza distinta consecutiva più lunga di parole riservate e spazi bianchi in uno snippet di codice.

Spero che il codice morto dopo a returnnon valga come una scappatoia, ma il codice è ancora eseguibile se vengono dichiarati gli identificativi utilizzati.

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

Questo sfrutta il fatto che alcune delle future parole chiave riservate sono considerate non valide solo nella modalità rigorosa di ES5.1 (apparentemente perché i motori non si sono preoccupati di bloccare tutte le future parole riservate di ES3, quindi c'era troppo codice che le usava là fuori sul web ).

Allo stesso modo, i token asynce awaitintrodotti in ES8 sono considerati parole chiave solo in modalità rigorosa.