Począwszy od 2015 ECMAScript, JavaScript posiada 33 zarezerwowanych słów kluczowych , takich jak break, consti new, jak również 10 przyszłych zastrzeżone słowa kluczowe , jak leti await.

Twoim zadaniem jest zebranie największej liczby następujących po sobie ¹ odrębnych zastrzeżonych słów kluczowych ² podczas pisania funkcjonalnego kodu JavaScript ³ .

1. Kolejne zastrzeżone słowa kluczowe - zastrzeżone słowa kluczowe, które są oddzielone tylko białymi spacjami i / lub nawiasami i / lub nawiasami klamrowymi.
2. Zastrzeżone słowa kluczowe - wszelkie zastrzeżone lub przyszłe zastrzeżone słowa kluczowe według ECMAScript 2015 . Zastrzeżone słowa kluczowe ze starszych standardów są wykluczone, pełna lista dozwolonych słów kluczowych znajduje się poniżej.
3. Kod funkcjonalny - twój kod powinien się uruchomić (w razie potrzeby podaj swój środowisko uruchomieniowe), ostatecznie się zatrzymaj i nie generuj żadnych błędów środowiska uruchomieniowego.

Jeśli kod wymaga określonego środowiska wykonawczego, użyte zastrzeżone słowa kluczowe nie mogą być blokadami w danym środowisku.

Lista zastrzeżonych słów kluczowych

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

Punktacja i przykłady

Twój wynik będzie równy największej liczbie kolejnych odrębnych zarezerwowanych słów kluczowych.
W przypadku równych wyników wygrywa najkrótszy kod źródłowy w bajtach. Komentowane sekcje i ciągi znaków nie liczą się do zarezerwowanych słów kluczowych, ale liczą się do liczby bajtów.

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

Obowiązują standardowe luki .

43 słowa, 603 bajty

Uhm, czy to jest luka? Nie mam pojęcia, jak, u diabła, jest to legalne JS, ale działa i używa każdego słowa kluczowego.

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 słów

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

Nieużywane słowa kluczowe:

• case wymaga :
• const wymaga =
• export wymaga trybu ścisłego
• import wymaga trybu ścisłego
• super wymaga constructor

43 słowa, 302 299 bajtów

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 słów, 185 bajtów

+ 1 2 słowa dzięki Arnauldowi i +1 do 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{}:{}}

Zakładając, że zrozumiałem wyzwanie, otrzymuję 24 słowa. Słowa bez nawiasów, nawiasów i białych znaków:

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 słowa, 177 bajtów

Bez „prawda” i „fałsz”, które według pytania nie są słowami kluczowymi.

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

Słowa:

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

słowa od „super” do „const”

Wersja golfowa:

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 słów

(nie jestem pewien leti 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 słowa, 300 bajtów

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

Bardziej czytelnie:

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

Musiałem użyć „słowa zarezerwowanego jako nazwy metody”, aby sobie z tym poradzić

• case(ponieważ już użyłem defaultz moim swtich),
• exportoraz import(ponieważ tryb modułu jest zawsze ścisły, co dyskwalifikuje with)
• super(ponieważ musi nastąpić dostęp do właściwości lub umieszczenie w constructorfunkcji), oraz
• enum (który nigdy nie może być użyty, ponieważ jest słowem zastrzeżonym bez użycia poprawnego gramatycznie)

14 15 16 Słowa bez nawiasów ani nowej linii

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

Dziękujemy Bergi za +1

28 słów bez nawiasów, 234 bajtów

Umieszczenie nazw identyfikatorów jako nazw definicji metod było zbyt oczywiste ( przynajmniej dla mnie ), więc szukałem najdłuższej z kolei wyraźnej sekwencji zarezerwowanych słów i białych znaków we fragmencie kodu.

Mam nadzieję, że martwy kod po a returnnie liczy się jako luka, ale kod nadal jest uruchamialny, jeśli użyte identyfikatory zostaną zadeklarowane.

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

Wykorzystuje to fakt, że niektóre przyszłe zastrzeżone słowa kluczowe są uważane za niepoprawne tylko w trybie ścisłym ES5.1 (najwyraźniej dlatego, że silniki nie zadały sobie trudu, aby zablokować wszystkie przyszłe zastrzeżone słowa ES3, więc za dużo kodu używało ich tam w Internecie ).

Podobnie tokeny asynci awaitwprowadzone w ES8 są uważane za słowa kluczowe tylko w trybie ścisłym.