Pada ECMAScript 2015, JavaScript memiliki 33 kata kunci yang dipesan , seperti break, constdan new, serta 10 kata kunci yang disimpan di masa mendatang , seperti letdan await.

Tugas Anda adalah untuk menyatukan jumlah terbesar dari ¹ kata kunci khusus ² berturut-turut yang berbeda saat menulis kode JavaScript fungsional ³ .

1. Kata kunci yang dipesan secara berurutan - kata kunci yang dipesan hanya dipisahkan oleh spasi putih dan / atau tanda kurung dan / atau kurung kurawal.
2. Kata kunci yang dicadangkan - kata kunci yang dicadangkan atau dicadangkan di masa mendatang pada ECMAScript 2015 . Kata kunci yang dilindungi undang-undang dari standar yang lebih lama dikecualikan, daftar lengkap kata kunci yang diizinkan diberikan di bawah ini.
3. Kode fungsional - kode Anda harus dijalankan (nyatakan runtime Anda, jika perlu), akhirnya berhenti, dan tidak menimbulkan kesalahan runtime.

Jika kode Anda memerlukan runtime tertentu, kata kunci yang digunakan tidak boleh kosong di lingkungan yang diberikan.

Daftar kata kunci yang dipesan

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

Penilaian & contoh

Skor Anda akan sama dengan jumlah terbesar kata kunci khusus yang dipesan berturut-turut.
Dalam kasus skor yang sama, kode sumber terpendek dalam byte menang. Bagian dan string yang dikomentari tidak diperhitungkan dalam kata kunci yang dipesan, tetapi dihitung terhadap jumlah 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;

Celah standar berlaku.

43 kata, 603 byte

Uhm, apakah ini celah? Saya tidak tahu bagaimana ini JS legal, tetapi berfungsi dan menggunakan setiap kata kunci.

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 kata

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

Kata kunci tidak digunakan:

• case membutuhkan :
• const membutuhkan =
• export membutuhkan mode ketat
• import membutuhkan mode ketat
• super membutuhkan constructor

43 kata, 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 kata, 185 byte

+1 1 kata berkat Arnauld, dan +1 hingga 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{}:{}}

Dengan asumsi saya mengerti tantangannya, skor ini 24 kata. Kata-kata tanpa tanda kurung, tanda kurung, dan spasi putih:

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 kata, 177 byte

Tanpa "benar" dan "salah", yang tampaknya bukan kata kunci sesuai dengan pertanyaan.

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

Kata-kata:

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

kata-kata dari "super" ke "const"

Versi golf:

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 kata

(tidak yakin tentang letdan 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 kata, 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}}

Lebih mudah dibaca:

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

Saya harus menggunakan "kata yang dicadangkan sebagai nama metode" untuk menangani

• case(Karena saya sudah menggunakan defaultdengan saya swtich),
• exportdan import(karena modul-mode selalu ketat, yang mendiskualifikasi with)
• super(karena itu harus diikuti oleh akses properti atau ditempatkan dalam suatu constructorfungsi), dan
• enum (yang tidak pernah bisa digunakan sama sekali, menjadi kata yang dilindungi tanpa penggunaan tata bahasa yang valid)

14 15 16 Kata tanpa tanda kurung atau baris baru

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

Terima kasih Bergi untuk +1

28 Kata tanpa tanda kurung, 234 Bytes

Menempatkan nama pengenal sebagai nama definisi metode terlalu jelas ( bagi saya setidaknya ), jadi saya mencari urutan berbeda terpanjang berturut-turut dari kata-kata yang disediakan dan spasi putih dalam potongan kode.

Saya harap kode mati setelah a returntidak dihitung sebagai celah, tetapi kode tersebut masih dapat dijalankan jika pengidentifikasi yang digunakan dinyatakan.

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

Ini mengeksploitasi fakta bahwa beberapa kata kunci cadangan masa depan hanya dianggap tidak valid dalam mode ketat ES5.1 (tampaknya karena mesin tidak repot-repot untuk memblokir semua kata-kata ES3 masa depan yang dilindungi sehingga ada terlalu banyak kode menggunakan mereka di luar sana di web ).

Demikian pula, token asyncdan yang awaitdiperkenalkan di ES8 hanya dianggap sebagai kata kunci dalam mode ketat.