ECMAScript를 2015 년으로, 자바 스크립트가 33 개 예약 된 키워드 등, break, const및 new뿐만 아니라 10 개 앞으로 예약 된 키워드 등, let와 await.

귀하의 작업은 기능적인 JavaScript 코드 ³ 을 작성하면서 가장 많은 수의 연속 된 ¹ 개의 고유 예약 키워드 ^{2를 연결} 하는 것 입니다.

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 바이트

Arnauld 덕분에 + 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(모듈 모드는 항상 엄격하기 때문에 어떤 자격을 상실 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)}

KEUMHEE L 님, 감사합니다.

대괄호없는 28 단어, 234 바이트

식별자 정의를 메소드 정의 이름으로 사용하는 것이 너무 분명했습니다 ( 적어도 나에게는 ). 그래서 코드 스 니펫에서 예약어와 공백의 가장 긴 연속적인 고유 시퀀스를 찾고있었습니다.

죽은 코드 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토큰은 엄격 모드의 키워드로만 간주됩니다.