ECMAScript'e 2015 tarihi itibariyle JavaScript vardır 33 ayrılmış anahtar gibi break, constve newyanı sıra 10 gelecekteki ayrılmış anahtar kelimeleri gibi, letve await.

Göreviniz, işlevsel JavaScript kodunu ³ yazarken art arda en fazla ¹ farklı ayrılmış anahtar kelime ^{2'yi bir} araya getirmektir .

1. Ardışık ayrılmış anahtar kelimeler - yalnızca boşluk ve / veya parantezler ve / veya küme parantezleri ile ayrılan ayrılmış anahtar kelimeler.
2. Ayrılmış anahtar kelimeler - ECMAScript 2015'ten itibaren ayrılmış veya gelecekteki ayrılmış anahtar kelimeler . Eski standartlardan ayrılmış anahtar kelimeler hariç tutulur, izin verilen anahtar kelimelerin tam listesi aşağıda verilmiştir.
3. İşlevsel kod - kodunuz çalışmalı (gerekirse çalışma zamanınızı belirtmeli), sonunda durmalı ve çalışma zamanı hatalarını atmamalı.

Kodunuz belirli bir çalışma zamanına ihtiyaç duyuyorsa, kullanılmış ayrılmış anahtar kelimeler verilen ortamda kullanılmamalıdır.

Ayrılmış anahtar kelimelerin listesi

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

Puanlama ve örnekler

Puanınız, birbirini takip eden farklı ayrılmış anahtar kelimelerin sayısına eşit olacaktır.
Eşit puan durumunda, bayt cinsinden en kısa kaynak kodu kazanır. Yorum yapılan bölümler ve dizeler, ayrılmış anahtar kelimelere sayılmaz, bayt sayma sayılır.

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

Standart boşluklar uygulanır.

43 kelime, 603 bayt

Uhm, bu bir kaçamak mı? Bunun nasıl bir yasal JS olduğu hakkında hiçbir fikrim yok, ama işe yarıyor ve her bir anahtar kelimeyi kullanıyor.

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 kelime

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

Kullanılmayan anahtar kelimeler:

• case gerektirir :
• const gerektirir =
• export sıkı mod gerektirir
• import sıkı mod gerektirir
• super gerektirir constructor

43 kelime, 302 299 bayt

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 kelime, 185 bayt

+ 1 2 kelime Arnauld sayesinde ve 12Me21 +1!

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

Zorluğu anladığımı varsayarsak, bu 24 kelimeye puan veriyor. Parantez, parantez ve beyaz boşluk içermeyen kelimeler:

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 kelime, 177 bayt

"Doğru" ve "yanlış" olmadan, görünüşe göre soruya göre anahtar kelimeler değil.

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

Kelimeler:

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" ile "const" arasındaki kelimeler

Golf versiyonu:

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 kelime

(emin değil letve 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 kelime, 300 bayt

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

Daha okunaklı:

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

Başa çıkmak için "ayrılmış kelimeyi yöntem adı olarak kullanmalıydım"

• case(Zaten defaultbenim ile kullanmıştı beri swtich),
• exportve import(modül kipi her zaman katı olduğundan diskalifiye olur with)
• super(bir mülk erişimi tarafından takip edilmesi veya bir constructorfonksiyona yerleştirilmesi gerektiğinden ) ve
• enum (hiç bir zaman kullanılamaz, dilbilgisi açısından geçerli bir kullanım olmadan ayrılmış bir kelime olarak)

14 15 16 Parantez veya satırsonu olmayan kelimeler

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

+1 için Bergi teşekkür ederiz

Parantezsiz 28 Kelime, 234 Bayt

Tanımlayıcı adlarını yöntem tanımı adları olarak koymak çok açıktı ( en azından benim için ), bu yüzden kod snippet'inde en uzun ardışık ayrılmış ayrılmış sözcük ve boşluk dizisini arıyordum.

Umarım sonra ölü kod returnbir boşluk olarak sayılmaz, ancak kullanılan tanımlayıcılar bildirilirse kod hala çalıştırılabilir durumdadır.

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

Bu, gelecekteki ayrılmış anahtar kelimelerin bazılarının yalnızca ES5.1’in katı modunda geçersiz sayıldığı gerçeğinden yararlanır (görünüşe göre motorlar , ES3’ün gelecekteki tüm ayrılmış kelimelerini engellemek için zahmete girmediğinden , web’de bunları kullanarak çok fazla kod kullanıldı. ).

Benzer şekilde, ES8'de sunulan asyncve awaitbelirteçleri yalnızca katı modda anahtar kelimeler olarak kabul edilir.