Depuis ECMAScript 2015, JavaScript contient 33 mots clés réservés , tels que break, constetnew , ainsi que 10 futurs mots clés réservés , tels que letet await.

Votre tâche consiste à enchaîner le plus grand nombre de mots-clés réservés ¹ distincts et consécutifs ² lors de l'écriture du code JavaScript fonctionnel ³ .

1. Mots clés réservés consécutifs - mots clés réservés qui ne sont séparés que par des espaces et / ou des parenthèses et / ou des accolades.
2. Mots-clés réservés - tous les mots-clés réservés ou futurs réservés à partir de ECMAScript 2015 . Les mots clés réservés de normes plus anciennes sont exclus, une liste complète des mots clés autorisés est donnée ci-dessous.
3. Code fonctionnel - votre code doit être exécuté (indiquez votre runtime, si nécessaire), éventuellement interrompu et ne pas générer d'erreurs d'exécution.

Si votre code nécessite une exécution spécifique, les mots-clés réservés utilisés ne doivent pas être no-ops dans l'environnement donné.

Liste des mots-clés réservés

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

Scoring & exemples

Votre score sera égal au plus grand nombre de mots-clés réservés distincts et consécutifs.
Dans le cas de scores égaux, le code source le plus court en octets gagne. Les sections et les chaînes commentées ne comptent pas pour les mots clés réservés, mais pour le nombre d'octets.

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

Les failles standard s'appliquent.

43 mots, 603 octets

Uhm, est-ce une faille? Je ne sais pas du tout comment c'est légal JS, mais ça marche et ça utilise tous les mots-clés.

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 mots

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

Mots-clés non utilisés:

• case a besoin :
• const a besoin =
• export nécessite un mode strict
• import nécessite un mode strict
• super a besoin constructor

43 mots, 302 299 octets

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 mots, 185 octets

+ 1 2 mots grâce à Arnauld et +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{}:{}}

En supposant que j'ai compris le défi, cela compte pour 24 mots. Les mots sans parenthèses, crochets et espaces:

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 mots, 177 octets

Sans "true" et "false", qui ne sont apparemment pas des mots clés selon la question.

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

Mots:

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

les mots de "super" à "const"

Version golfée:

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 mots

(pas sûr de letet 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 mots, 300 octets

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

Plus lisiblement:

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

Je devais utiliser le "mot réservé comme nom de méthode" pour traiter

• case(depuis que j'avais déjà utilisé defaultavec monswtich ),
• exportet import(puisque le mode de module est toujours strict, ce qui disqualifiewith )
• super (puisqu'il doit être suivi d'un accès à la propriété ou placé dans un constructor fonction), et
• enum (qui ne peut jamais être utilisé du tout, étant un mot réservé sans utilisation grammaticalement valide)

14 15 16 Mots sans crochets ni nouvelle ligne

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

Merci Bergi pour +1

28 mots sans crochets, 234 octets

Mettre les noms d’identifiant comme noms de définition de méthode était trop évident ( pour moi du moins ), alors je cherchais la séquence la plus longue et distincte et consécutive de mots réservés et d'espaces dans un extrait de code.

J'espère que le code mort après un returnne compte pas comme une échappatoire, mais le code est toujours exécutable si les identifiants utilisés sont déclarés.

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

Cela exploite le fait que certains des futurs mots clés réservés ne sont considérés comme invalides qu'en mode strict de ES5.1 (apparemment, les moteurs ne se souciant pas de bloquer tous les mots réservés futurs de ES3, il y avait donc trop de code qui les utilisait sur le Web. )

De même, les jetons asyncet les awaitclés introduits dans ES8 ne sont considérés comme des mots-clés qu'en mode strict.