如2015年的ECMAScript的，JavaScript有33个保留关键字，诸如break，const和new，以及10个日后保留关键字，如let和await。

您的任务是在编写功能性JavaScript代码^3的同时，将最大数量的连续^1个不同的保留关键字²链接在一起。

1. 连续保留关键字-保留关键字，仅由空格和/或括号和/或花括号分隔。
2. 保留关键字- 自ECMAScript 2015起的任何保留或将来保留的关键字。较早的标准中保留的关键字不包括在内，下面列出了允许的关键字的完整列表。
3. 功能代码-您的代码应该运行（必要时声明运行时），最终停止运行，并且不会引发任何运行时错误。

如果您的代码需要特定的运行时，则在给定环境中，使用的保留关键字不得为空。

保留关键字列表

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

计分与范例

您的分数将等于连续的最大不同保留关键字的数量。
如果分数相等，则以字节为单位的最短源代码获胜。带注释的部分和字符串不计入保留关键字，但计入字节数。

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

有标准漏洞。

43个字，603个字节

嗯，这是一个漏洞吗？我不知道这到底是什么合法的JS，但是它有效并且使用了每个关键字。

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个字

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

未使用的关键字：

• case 要求 :
• const 要求 =
• export 需要严格模式
• import 需要严格模式
• super 要求 constructor

43个词语，302个 299字节

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字，185字节

+ 1 2感谢阿尔诺的话，和+1 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{}:{}}

假设我理解了挑战，那么这个分数为24个单词。没有括号，方括号和空格的单词：

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个字，177字节

如果没有“ true”和“ false”，则根据问题显然不是关键字。

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

话：

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

从“ super”到“ const”的单词

高尔夫球版：

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个字

（不确定let和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个字，300个字节

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

更具可读性：

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

我不得不使用“保留字作为方法名称”来处理

• case（因为我已经使用default过了swtich），
• export和import（由于module-mode始终是严格的，因此不合格with）
• super（因为必须在其后进行属性访问或将其放置在constructor函数中），并且
• enum （这绝对不能使用，因为它是保留字，没有语法上的有效用法）

14 15 16单词中没有括号或换行符

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

感谢Bergi +1

28个单词，不带括号，234字节

将标识符名称作为方法定义名称太明显了（至少对我来说是如此），因此我一直在代码片段中寻找最长的连续连续的保留字和空白序列。

我希望a之后的return无效代码不会被视为漏洞，但是如果声明了使用的标识符，该代码仍然可以运行。

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

这利用了一个事实，即某些将来的保留关键字仅在ES5.1的严格模式下才被视为无效（显然是因为引擎没有费心地阻止所有ES3的将来保留字，因此在网络上使用它们的代码太多了）。

同样，ES8中引入的async和await标记仅在严格模式下被视为关键字。