JavaScript Reservado


41

No ECMAScript 2015, o JavaScript possui 33 palavras-chave reservadas , como break, conste new, além de 10 futuras palavras-chave reservadas , como lete await.

Sua tarefa é encadear o maior número de 1 palavras-chave reservadas distintas consecutivas 2 ao escrever o código JavaScript funcional 3 .

  1. Palavras-chave reservadas consecutivas - palavras-chave reservadas que são separadas apenas por espaços em branco e / ou parênteses e / ou chaves.
  2. Palavras-chave reservadas - quaisquer palavras-chave reservadas ou futuras reservadas a partir do ECMAScript 2015 . Palavras-chave reservadas de padrões mais antigos são excluídas. Uma lista completa de palavras-chave permitidas é fornecida abaixo.
  3. Código funcional - seu código deve ser executado (indicar seu tempo de execução, se necessário), eventualmente parar e não gerar erros de tempo de execução.

Se o seu código precisar de um tempo de execução específico, as palavras-chave reservadas usadas não deverão ser não operacionais no ambiente especificado.

Lista de palavras-chave reservadas

Pontuação e exemplos

Sua pontuação será igual ao maior número de palavras-chave reservadas distintas consecutivas.
No caso de pontuações iguais, o menor código-fonte em bytes vence. Seções e seqüências comentadas não contam para palavras-chave reservadas, mas para contagem 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;

Aplicam-se brechas padrão .


Discussão em sandbox , para quem estiver interessado.
Nit

Acho que isso pode ser mais interessante se você não permitir parênteses entre as palavras-chave.
Assistente de trigo

A nova linha é permitida?
L4m2

@ l4m2 Sim, é um espaço em branco.
Nit

1
@ l4m2 A mesma solução de 43 pontos também é possível sem novas linhas, então talvez eu simplesmente não entenda o que você está tentando fazer?
Nit

Respostas:


53

43 palavras, 603 bytes

Uhm, isso é uma brecha? Eu não tenho idéia de como diabos isso é JS legal, mas funciona e usa todas as palavras-chave.

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

3
Não está familiarizado com JS, mas ... essas palavras-chave são realmente usadas quando usadas neste contexto, ou apenas strings que têm a mesma estrutura lexical das palavras-chave e estão usando o sugar para evitar aspas?
Leushenko

1
@Leushenko Provavelmente o segundo (embora eu também não esteja muito familiarizado com o JS), pois eles se parecem com nomes de funções na maneira como são usados. Ainda assim, normalmente não deve ser possível usar essas palavras-chave como funções ou nomes de classes, mas Siguza ainda o fez, cumprindo as regras de desafio de usar apenas parênteses e colchetes. Um achado agradável para completar este desafio com todas as palavras que eu diria que, embora a maioria das outras respostas olhar mais impressionante para realmente usando as palavras-chave como palavras-chave . Ainda com +1 de mim, parece que temos um vencedor.
Kevin Cruijssen 04/04

6
@ user202729 Por que embora? Por que torná-lo muito complexo quando pode ser tão simples? O código-golfe geralmente está fazendo algo o mais curto possível, mas eu pessoalmente ainda prefiro manter a legibilidade e a simplicidade até certo ponto (eu sei, eu sei, isso não é um desafio para o código-golfe). Alguns exemplos: Eu prefiro usar -1, i+1, i-1acima ~0, -~i, ~-iquando eu posso, só porque é mais clara para ler para aqueles que não estão muito familiarizados com o código-golfe e ~ainda. Embora, é claro, eu sempre use i+~je i-~jjogue esse byte único de i-j-1e i+j+1. ;)
Kevin Cruijssen 04/04

2
Sim, eu poderia mascará-lo ainda mais e tentar diminuir a contagem de bytes ... um começo como esse if(this)return void typeof function(){} else debuggernão é difícil de conseguir, mas depois disso fica feio e rápido. E sim, isso transforma totalmente palavras-chave em identificadores - mas para alguns deles você precisa fazê-lo (por exemplo enum). Eu levei isso ao extremo, mas não é disso que se trata o código do golfe? : P
Siguza 04/04

1
@ Magic Não, fornecer o nome de um método de classe é simplesmente um contexto gramatical em que tokens literais são tratados como nomes de propriedades, mesmo que sejam palavras reservadas. Este é basicamente o mesmo, semanticamente, como fazer obj["break"] = function (){}etc.
apsillers

53

37 palavras

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

Palavras-chave não utilizadas:

  • case requer :
  • const requer =
  • export requer modo estrito
  • import requer modo estrito
  • super requer constructor

7
Admito que ri
nicael

48
Parece com o código padrão do Java, por exemplo, para calcular 1 + 2.
21818 Eric Duminil

2
@EricDuminil Essa é a verdadeira razão pela qual é chamada _Java_ Script.
Wizzwizz4

5
@EricDuminil Isso não é tão simples quanto 1 + 2. O valor completo desse código é a resposta para a questão final da vida, do universo e de tudo. Isso é complexo . :)
TSH

2
Isto é simplesmente maravilhoso.
Pedro A

30

43 palavras, 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:}

Lowerbound teórico 277 (cada duas palavras separadas por um byte)
l4m2

Bom trabalho, atualmente só falta enum.
Nit

10

21 24 26 palavras, 185 bytes

+ 1 2 palavras graças a Arnauld e +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{}:{}}

Assumindo que entendi o desafio, isso marca 24 palavras. As palavras sem parênteses, colchetes e espaço em branco:

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

Sem "verdadeiro" e "falso", que aparentemente não são palavras-chave de acordo com a pergunta.

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

Palavras:

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

(I acidentalmente apagou meu comentário em vez de editá-lo, o conteúdo foram: "você pode usar delete {} no lugar de verdadeiro / falso, acho que (e apenas retornar nada")
12Me21

Ah sim. Não prestei muita atenção a essa regra.
Arnauld

você pode colocar case ... :ou default:no final (uma vez que :não é permitido entre palavras-chave)
12Me21 04/04

Ou você pode terminar com for(let _;0;);+2 palavras (mas não pode casemais usar ).
Arnauld

switch({}){case{}:{}}=> switch({}){case{}:;}? Não sei se ;é por vezes necessário
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
 }:
}

palavras de "super" para "const"

Versão Golfed:

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

Agora é hora do golfe?
L4m2

Estou recebendo Uncaught SyntaxError: Unexpected token deletequando tento executar sua resposta no meu console Javascript no Google Chrome. Como posso testar se sua solução é válida?
precisa saber é o seguinte

@Ferrybig Eu uso o Firefox e funciona bem. Não consigo instalar nova versão do Chrome por causa do sistema
l4m2

Eu recebo esse erro no FirefoxSyntaxError: yield expression is only valid in generators
TheChetan 8/18

Eu uso ff 52.7.2
l4m2

4

21 palavras

(não tenho certeza lete 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;
}

, =e ;não são permitidos como separadores.
usar o seguinte comando

2
Eles não estão sendo contadas
soktinpk

3

43 palavras, 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}}

Mais facilmente:

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

Eu tive que usar a "palavra reservada como nome do método" para lidar com

  • case(já que eu já tinha usado defaultcom o meu swtich),
  • exporte import(como o modo de módulo é sempre rigoroso, o que desqualifica with)
  • super(já que deve ser seguido por um acesso à propriedade ou colocado em uma constructorfunção), e
  • enum (que nunca pode ser usada, sendo uma palavra reservada sem uso gramaticalmente válido)

Meus 39 mostra solução superpode aparecer no início sem nome, mas muito caro
l4m2

3

14 15 16 Palavras sem colchetes ou nova linha

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

Obrigado Bergi por +1


Você pode torná-lo uma função de gerador e lançar um yield?
Bergi

Eu tentei descobrir o que isso faz, mas minha cabeça começou a girar. Você poderia postar uma explicação?
Philipp

Estou ficando Uncaught SyntaxError: Unexpected token newquando eu colar dentro da minha consola javascript
Ferrybig

1
@Ferrybig, substitua functionpor function*, para que seja reconhecido como um gerador.
guest-418

2

28 palavras sem colchetes, 234 bytes

Colocar nomes de identificadores como nomes de definição de método era muito óbvio ( pelo menos para mim ), então eu estava procurando a sequência distinta consecutiva mais longa de palavras reservadas e espaços em branco em um trecho de código.

Espero que o código morto após a returnnão conte como brecha, mas o código ainda possa ser executado se os identificadores usados ​​forem declarados.

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

Isso explora o fato de que algumas das futuras palavras-chave reservadas são consideradas inválidas apenas no modo estrito do ES5.1 (aparentemente porque os mecanismos não se deram ao trabalho de bloquear todas as futuras palavras reservadas do ES3, portanto havia muito código usando-as na Web) )

Da mesma forma, os tokens asynce awaitintroduzidos no ES8 são considerados apenas palavras-chave no modo estrito.


Pode breake continueestá aí?
L4m2

Quando eu chamo a função, recebo Uncaught SyntaxError: Undefined label 'implements', sua resposta requer um tempo de execução específico?
Nit

@Nit Opa, na verdade eu não chamei, apenas verifiquei se é sintaticamente permitido (e depois prosaicismo otimizado: D).
Bergi

@ l4m2 Oh, você está certo, eles não podem, mas é um erro de tempo de execução, então eu não percebi :-( Precisava de um pouco de reordenação arbitrária para funcionar (e um bloco com o rótulo).
Bergi

De @Bergi No Firefox que erro de sintaxe no tio NodeJS-lo de tempo de execução
l4m2
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.