Ab ECMAScript 2015 ist Javascript 33 reservierte Schlüsselwörter , wie break, constund new, sowie 10 Zukunft reservierte Schlüsselwörter , wie letund await.

Ihre Aufgabe ist es, die größte Anzahl von aufeinanderfolgenden ¹ verschiedenen reservierten Schlüsselwörtern ^{2 zu} verketten, während Sie funktionalen JavaScript-Code ³ schreiben .

1. Aufeinanderfolgende reservierte Schlüsselwörter - reservierte Schlüsselwörter, die nur durch Leerzeichen und / oder Klammern und / oder geschweifte Klammern getrennt sind.
2. Reservierte Schlüsselwörter - alle reservierten oder zukünftigen reservierten Schlüsselwörter ab ECMAScript 2015 . Reservierte Schlüsselwörter aus älteren Standards sind ausgeschlossen. Eine vollständige Liste der zulässigen Schlüsselwörter finden Sie weiter unten.
3. Funktionscode - Ihr Code sollte ausgeführt werden (geben Sie ggf. Ihre Laufzeit an), möglicherweise angehalten werden und keine Laufzeitfehler verursachen.

Wenn Ihr Code eine bestimmte Laufzeit benötigt, dürfen die verwendeten reservierten Schlüsselwörter in der angegebenen Umgebung keine No-Ops sein.

Liste der reservierten Schlüsselwörter

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

Wertung & Beispiele

Ihre Punktzahl entspricht der größten Anzahl aufeinanderfolgender reservierter Keywords.
Bei gleicher Punktzahl gewinnt der kürzeste Quellcode in Bytes. Kommentierte Abschnitte und Zeichenfolgen werden nicht für reservierte Schlüsselwörter, sondern für die Bytezahl gezählt.

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

Es gelten Standardlücken .

43 Wörter, 603 Bytes

Ähm, ist das eine Lücke? Ich habe keine Ahnung, wie zum Teufel das legal ist JS, aber es funktioniert und es verwendet jedes einzelne Keyword.

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 Wörter

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

Nicht verwendete Schlüsselwörter:

• case erfordert :
• const erfordert =
• export erfordert strengen Modus
• import erfordert strengen Modus
• super erfordert constructor

43 Wörter, 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 Wörter, 185 Bytes

+ 1 2 Wörter danke an Arnauld und +1 bis 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{}:{}}

Vorausgesetzt, ich habe die Herausforderung verstanden, ergibt dies 24 Wörter. Die Wörter ohne Klammern, Klammern und Leerzeichen:

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 Wörter, 177 Bytes

Ohne "wahr" und "falsch", die laut Fragestellung anscheinend keine Schlagworte sind.

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

Wörter:

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

Wörter von "super" bis "const"

Golf Version:

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 Wörter

(nicht sicher über letund 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 Wörter, 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}}

Besser lesbar:

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

Ich musste das "reservierte Wort als Methodenname" verwenden, um damit umzugehen

• case(da ich defaultmit meinem schon benutzt hatte swtich),
• exportund import(da der Modulmodus immer streng ist, was disqualifiziert with)
• super(da es von einem Eigenschaftszugriff gefolgt oder in eine constructorFunktion eingefügt werden muss) und
• enum (was niemals verwendet werden kann, da es sich um ein reserviertes Wort ohne grammatikalisch gültige Verwendung handelt)

14 15 16 Wörter ohne Klammern oder Zeilenvorschub

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

Danke Bergi für +1

28 Wörter ohne Klammern, 234 Bytes

Das Eingeben von Bezeichnernamen als Methodendefinitionsnamen war zu offensichtlich ( zumindest für mich ), daher suchte ich nach der längsten fortlaufenden eindeutigen Folge von reservierten Wörtern und Leerzeichen in einem Code-Snippet.

Ich hoffe, dass toter Code nach a returnnicht als Schlupfloch zählt, aber der Code ist noch lauffähig, wenn die verwendeten Bezeichner deklariert werden.

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

Dies nutzt die Tatsache aus, dass einige der zukünftigen reservierten Schlüsselwörter nur im strikten Modus von ES5.1 als ungültig angesehen werden (anscheinend, weil die Suchmaschinen nicht alle zukünftigen reservierten Wörter von ES3 blockierten, sodass es im Web zu viel Code gab, der sie verwendet ).

Ebenso werden die in ES8 eingeführten Token asyncund awaitnur im strikten Modus als Schlüsselwörter betrachtet.