ในฐานะของ ECMAScript 2015 JavaScript มี33 คำหลักที่สงวนไว้เช่นbreak, constและnewเช่นเดียวกับ10 คำหลักที่สงวนไว้ในอนาคตเช่นและletawait

งานของคุณคือการเข้าด้วยกันจำนวนมากที่สุดของติดต่อกัน¹คำหลักที่สงวนไว้แตกต่างกัน²ในขณะที่เขียนโค้ด JavaScript ทำงาน3

1. คำหลักที่สงวนไว้อย่างต่อเนื่อง - คำหลักที่สงวนไว้ซึ่งคั่นด้วยช่องว่างและ / หรือวงเล็บและ / หรือเครื่องหมายปีกกาเท่านั้น
2. คำหลักสงวน - ใด ๆลิขสิทธิ์หรือสงวนไว้ในอนาคตเป็นคำหลักของ ECMAScript 2015 ไม่รวมคำหลักที่สงวนไว้จากมาตรฐานที่เก่ากว่ารายการคำหลักที่อนุญาตทั้งหมดได้รับด้านล่าง
3. รหัสการทำงาน - รหัสของคุณควรทำงาน (ระบุเวลาทำงานของคุณหากจำเป็น) ในที่สุดก็หยุดและไม่ทิ้งข้อผิดพลาด runtime ใด ๆ

หากรหัสของคุณต้องการรันไทม์เฉพาะคำหลักที่สงวนไว้จะต้องไม่เป็นแบบไม่มีตัวเลือกในสภาพแวดล้อมที่กำหนด

รายการคำหลักที่สงวนไว้

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 คำขอบคุณ Arnauld และ +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 ไบต์

ไม่มี "จริง" และ "เท็จ" ซึ่งดูเหมือนจะไม่ใช่คำหลักตามคำถาม

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"

รุ่น Golfed:

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

ขอบคุณ 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 ทั้งหมดดังนั้นจึงมีรหัสมากเกินไป )

ในทำนองเดียวกันasyncและawaitโทเค็นที่นำมาใช้ใน ES8 จะถือว่าเป็นคำหลักในโหมดเข้มงวดเท่านั้น