JavaScript reservado

41

A partir de ECMAScript 2015, JavaScript tiene 33 palabras clave reservadas , como break, consty new, así como 10 palabras clave reservadas futuras , como lety await.

Su tarea es encadenar el mayor número de 1 palabras clave reservadas distintas consecutivas 2 mientras escribe el código JavaScript funcional 3 .

  1. Palabras clave reservadas consecutivas: palabras clave reservadas que están separadas solo por espacios en blanco y / o paréntesis y / o llaves.
  2. Palabras clave reservadas: cualquier palabra clave reservada o futura reservada a partir de ECMAScript 2015 . Se excluyen las palabras clave reservadas de estándares anteriores, a continuación se ofrece una lista completa de palabras clave permitidas.
  3. Código funcional: su código debe ejecutarse (indique su tiempo de ejecución, si es necesario), finalmente detenerse y no arrojar ningún error de tiempo de ejecución.

Si su código necesita un tiempo de ejecución específico, las palabras clave reservadas utilizadas no deben ser no operativas en el entorno dado.

Lista de palabras clave reservadas

Puntuación y ejemplos

Su puntaje será igual al mayor número de palabras clave reservadas distintas consecutivas.
En el caso de puntajes iguales, gana el código fuente más corto en bytes. Las secciones y cadenas comentadas no cuentan para palabras clave reservadas, sino que cuentan para el recuento de bytes.

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

Se aplican lagunas estándar .

Liendre
fuente
Discusión de sandbox , para aquellos que estén interesados.
Nit
Creo que esto podría ser más interesante si no permitiera paréntesis entre las palabras clave.
Wheat Wizard
¿Se permite nueva línea?
l4m2
@ l4m2 Sí, es un espacio en blanco.
Nit
1
@ l4m2 La misma solución de 43 puntos también es posible sin líneas nuevas, así que ¿quizás no entiendo el punto que está tratando de hacer?
Nit

Respuestas:

53

43 palabras, 603 bytes

Uhm, ¿es esto una escapatoria? No tengo idea de cómo demonios es legal JS, pero funciona y utiliza cada palabra clave.

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(){}
})
Siguza
fuente
3
No estoy tan familiarizado con JS, pero ... ¿son realmente palabras clave cuando se usan en este contexto, o simplemente cadenas que tienen la misma estructura léxica que las palabras clave y están usando azúcar para evitar comillas?
Leushenko
1
@Leushenko Probablemente el segundo (aunque tampoco estoy muy familiarizado con JS), ya que parecen nombres de funciones en la forma en que se usan. Aún así, normalmente no debería ser posible usar estas palabras clave como funciones o nombres de clase, pero Siguza aún lo hizo, mientras cumplía con las reglas de desafío de solo usar paréntesis y corchetes. Un buen hallazgo para completar este desafío con todas las palabras que diría, a pesar de que la mayoría de las otras respuestas parecen más impresionantes para usar realmente las palabras clave como palabras clave . Todavía +1 de mí, parece que tenemos un ganador.
Kevin Cruijssen
66
@ user202729 ¿Por qué sin embargo? ¿Por qué hacer que parezca demasiado complejo cuando se puede hacer tan simple? El golf de código generalmente hace algo lo más corto posible, pero personalmente prefiero mantener la legibilidad y la simplicidad en cierta medida (lo sé, lo sé, este no es un desafío de golf de código). Algunos ejemplos: Yo prefiero usar -1, i+1, i-1arriba ~0, -~i, ~-icuando puedo, simplemente porque es más fáciles de interpretar para aquellos que no están muy familiarizados con el código de golf y ~todavía. Aunque, por supuesto, siempre usaré i+~jy i-~jpara golf ese solo byte de i-j-1y i+j+1. ;)
Kevin Cruijssen
2
Sí, podría mezclarlo aún más y tratar de que el byte cuente hacia atrás ... un comienzo como el if(this)return void typeof function(){} else debuggerque no es difícil de encontrar, pero después de eso se pone feo rápidamente. Y sí, esto resulta totalmente las palabras clave en los identificadores - pero para algunos de ellos que tienen a fin de ser capaces de utilizarlos (por ejemplo enum). Lo llevé al extremo, pero ¿no es eso de lo que se trata el golf de código? : P
Siguza
1
@Magic No, proporcionar el nombre de un método de clase es simplemente un contexto gramatical donde los tokens literales se tratan como nombres de propiedad, incluso si son palabras reservadas. Esto es básicamente lo mismo, semánticamente, como hacer, obj["break"] = function (){}etc.
apsillers
53

37 palabras

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

Palabras clave no utilizadas:

  • case requiere :
  • const requiere =
  • export requiere modo estricto
  • import requiere modo estricto
  • super requiere constructor
tsh
fuente
77
Admito que me reí
nicael
48
Parece el típico código repetitivo de Java, por ejemplo, para calcular 1 + 2.
Eric Duminil
2
@EricDuminil Esta es la verdadera razón por la que se llama _Java_ Script.
wizzwizz4
55
@EricDuminil Eso no es tan simple como 1 + 2. El valor completo de este código es la respuesta a la última pregunta de la vida, el universo y todo. Eso es compleja . :)
tsh
2
Esto es simplemente maravilloso.
Pedro A
30

43 palabras, 302 299 bytes

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:}
l4m2
fuente
277 teóricamente inferior (cada dos palabras separadas por un byte)
l4m2
Buen trabajo, actualmente solo te falta enum.
Nit
10

21 24 26 palabras, 185 bytes

+ 1 2 palabras gracias a Arnauld, y +1 a 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{}:{}}

Suponiendo que entendí el desafío, esto suma 24 palabras. Las palabras sin paréntesis, corchetes y espacios en blanco:

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 palabras, 177 bytes

Sin "verdadero" y "falso", que aparentemente no son palabras clave según la pregunta.

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

Palabras:

void function do with if typeof in this throw instanceof new class extends else return try break finally yield continue while delete switch case
Conor O'Brien
fuente
(Accidentalmente eliminé mi comentario en lugar de editarlo, el contenido era: "puede usar eliminar {} en lugar de verdadero / falso, pensar (y simplemente no devolver nada")
12Me21
Ah, sí. No le presté mucha atención a esa regla.
Arnauld
puede poner case ... :o default:al final (ya :que no está permitido entre palabras clave)
12Me21
Ot puedes terminar con for(let _;0;);+2 palabras (pero ya no puedes usar case).
Arnauld
switch({}){case{}:{}}=> switch({}){case{}:;}? No sé si a ;veces es necesario
l4m2
6

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

palabras de "super" a "const"

Versión de 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}:}
l4m2
fuente
¿Es hora de jugar golf?
l4m2
Recibo Uncaught SyntaxError: Unexpected token deletecuando intento ejecutar su respuesta en mi consola Javascript en Google Chrome, ¿cómo puedo probar si su solución es válida?
Ferrybig
@Ferrybig Uso Firefox y funciona bien. No puedo instalar la nueva versión de Chrome debido al sistema
l4m2
Recibo este error en FirefoxSyntaxError: yield expression is only valid in generators
TheChetan
Uso ff 52.7.2
l4m2
4

21 palabras

(no estoy seguro lety 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;
}
soktinpk
fuente
, =y ;no están permitidos como separadores.
user202729
2
No se están contando
soktinpk
3

43 palabras, 300 bytes

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

Más legible:

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

Tuve que usar la "palabra reservada como nombre del método" para tratar

  • case(ya que ya lo había usado defaultcon mi swtich),
  • exporty import(dado que el modo módulo siempre es estricto, lo que descalifica with)
  • super(ya que debe ir seguido de un acceso a la propiedad o colocado en una constructorfunción), y
  • enum (que nunca se puede usar en absoluto, siendo una palabra reservada sin uso gramaticalmente válido)
apsillers
fuente
Mis 39 programas de solución superpueden aparecer al principio sin ser un nombre, pero son demasiado caros
l4m2 el
3

14 15 16 Palabras sin corchetes o nueva línea

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

Gracias Bergi por +1

l4m2
fuente
¿Puedes convertirlo en una función de generador y agregar un yield?
Bergi
Traté de averiguar qué hace esto, pero mi cabeza comenzó a girar. ¿Podría publicar una explicación?
Philipp
Me Uncaught SyntaxError: Unexpected token new
sale cuando pego
1
@Ferrybig, reemplace functioncon function*, por lo que será reconocido como un generador.
invitado-418
2

28 palabras sin corchetes, 234 bytes

Poner nombres de identificadores como nombres de definición de método era demasiado obvio ( al menos para mí ), por lo que estaba buscando la secuencia distinta consecutiva más larga de palabras reservadas y espacios en blanco en un fragmento de código.

Espero que el código muerto después de un returnno cuente como un vacío legal, pero el código aún se puede ejecutar si se declaran los identificadores utilizados.

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

Esto explota el hecho de que algunas de las futuras palabras clave reservadas solo se consideran inválidas en el modo estricto de ES5.1 (aparentemente porque los motores no se molestaron en bloquear todas las futuras palabras reservadas de ES3, por lo que había demasiado código usándolas en la web )

Del mismo modo, los tokens asyncy awaitintroducidos en ES8 solo se consideran palabras clave en modo estricto.

Bergi
fuente
¿Puede breaky continueestar allí?
l4m2
Cuando llamo a la función, obtengo Uncaught SyntaxError: Undefined label 'implements', ¿su respuesta requiere un tiempo de ejecución específico?
Nit
@Nit Oops, en realidad no lo llamé, solo verifiqué si está sintácticamente permitido (y luego optimicé el prosaicismo: D).
Bergi
@ l4m2 Oh, tienes razón, no pueden, pero es un error de tiempo de ejecución, así que no me di cuenta :-( Necesitaba un poco de reordenamiento arbitrario para funcionar (y un bloque con la etiqueta).
Bergi
@Bergi En Firefox es un error de sintaxis en tio nodejs es tiempo de ejecución
l4m2