Kể từ ECMAScript 2015, JavaScript có 33 từ khóa dành riêng , chẳng hạn như break, constvà new, cũng như 10 từ khóa dành riêng trong tương lai , chẳng hạn như letvà await.

Nhiệm vụ của bạn là xâu chuỗi số lượng lớn nhất của ¹ từ khóa dành riêng ² liên tiếp trong khi viết mã JavaScript chức năng ³ .

1. Các từ khóa dành riêng liên tiếp - các từ khóa dành riêng chỉ được phân tách bằng khoảng trắng và / hoặc dấu ngoặc đơn và / hoặc dấu ngoặc nhọn.
2. Từ khóa dành riêng - bất kỳ từ khóa dành riêng hoặc tương lai dành riêng trong ECMAScript 2015 . Các từ khóa dành riêng từ các tiêu chuẩn cũ hơn được loại trừ, một danh sách đầy đủ các từ khóa được phép được đưa ra dưới đây.
3. Mã chức năng - mã của bạn sẽ chạy (nêu thời gian chạy của bạn, nếu cần), cuối cùng tạm dừng và không ném bất kỳ lỗi thời gian chạy nào.

Nếu mã của bạn cần một thời gian chạy cụ thể, các từ khóa dành riêng được sử dụng không được là không có trong môi trường cụ thể.

Danh sách các từ khóa dành riêng

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

Ghi điểm & ví dụ

Điểm của bạn sẽ bằng với số lượng lớn nhất các từ khóa dành riêng liên tiếp.
Trong trường hợp điểm số bằng nhau, mã nguồn ngắn nhất tính bằng byte sẽ thắng. Các phần và chuỗi được nhận xét không được tính vào các từ khóa dành riêng, nhưng được tính vào số byte.

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

Tiêu chuẩn áp dụng.

43 từ, 603 byte

Uhm, đây có phải là một lỗ hổng? Tôi không biết cái quái này là hợp pháp như thế nào, nhưng nó hoạt động và nó sử dụng mọi từ khóa.

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 từ

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

Từ khóa không được sử dụng:

• case đòi hỏi :
• const đòi hỏi =
• export yêu cầu chế độ nghiêm ngặt
• import yêu cầu chế độ nghiêm ngặt
• super đòi hỏi constructor

43 từ, 302 299 byte

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 từ, 185 byte

+ 1 2 từ nhờ Arnauld và +1 đến 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{}:{}}

Giả sử tôi hiểu thử thách, điều này ghi được 24 từ. Các từ không có dấu ngoặc đơn, ngoặc và khoảng trắng:

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 từ, 177 byte

Không có "đúng" và "sai", rõ ràng không phải là từ khóa theo câu hỏi.

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

Từ ngữ:

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

từ "siêu" đến "const"

Phiên bản chơi gôn:

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 từ

(không chắc chắn về letvà 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 từ, 300 byte

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

Dễ đọc hơn:

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

Tôi đã phải sử dụng "từ dành riêng làm tên phương thức" để đối phó

• case(vì tôi đã sử dụng defaultvới swtich),
• exportvà import(vì chế độ mô-đun luôn nghiêm ngặt, không đủ tiêu chuẩn with)
• super(vì nó phải được theo sau bởi quyền truy cập thuộc tính hoặc được đặt trong constructorhàm) và
• enum (không bao giờ có thể được sử dụng, là một từ dành riêng không có sử dụng hợp lệ về mặt ngữ pháp)

14 15 16 Từ không có dấu ngoặc hoặc dòng mới

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

Cảm ơn Bergi vì +1

28 từ không có dấu ngoặc, 234 byte

Đặt tên định danh làm tên định nghĩa phương thức là quá rõ ràng ( ít nhất là đối với tôi ), vì vậy tôi đang tìm kiếm chuỗi từ riêng biệt và khoảng trắng riêng biệt dài nhất trong một đoạn mã.

Tôi hy vọng mã chết sau khi returnkhông được coi là lỗ hổng, nhưng mã vẫn có thể chạy được nếu các mã định danh được sử dụng được khai báo.

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

Điều này khai thác thực tế là một số từ khóa dành riêng trong tương lai chỉ bị coi là không hợp lệ trong chế độ nghiêm ngặt của ES5.1 (rõ ràng vì các công cụ không bận tâm chặn tất cả các từ dành riêng trong tương lai của ES3 nên có quá nhiều mã sử dụng chúng trên web ).

Tương tự, mã thông báo asyncvà awaitmã thông báo được giới thiệu trong ES8 chỉ được coi là từ khóa ở chế độ nghiêm ngặt.