¿Qué consejos generales tienes para jugar al golf en JavaScript? Estoy buscando ideas que puedan aplicarse a los problemas de código de golf en general que sean al menos algo específicos de JavaScript (por ejemplo, "eliminar comentarios" no es una respuesta).

Nota: Consulte también Consejos para jugar golf en ECMAScript 6 y superior

Fantasía para bucles

puede usar el bucle estándar para formas no estándar

for ( a; b; c )

es esencialmente equivalente a:

a;
while ( b )
{
  ...
  c;
}

así que un buen truco es escribir su código con un whilebucle y luego dividirlo en a,b,cpartes en un forbucle.

Un par de ejemplos que he escrito :

for(x=y=n;!z;x--,y++)z=i(x)?x:i(y)?y:0
for(a=b=1;b<n;c=a+b,a=b,b=c);

Encadena a tus acomodadores

Si está inicializando o restableciendo múltiples valores, encadene el valor a todas las variables que lo necesitan:

a=b=1;

Casting implícito

No verifiques tus tipos, solo úsalos como están. parseInt()cuesta 10personajes. Si necesita expulsar de una cadena, sea creativo:

a='30';
b='10';
c = a + b; //failure
c = parseInt(a) + parseInt(b) //too long

c = -(-a-b); //try these
c = ~~a+~~b;
c = +a+ +b;
c = a- -b;

Evitar los punto y coma

JavaScript tiene inserción automática de punto y coma. Úselo a menudo y bien.

One-liners

Ahorre entre paréntesis empujando tanto como sea posible en líneas individuales o parámetros:

a( realParam1, realParam2, fizz='buzz' )

Operadores de aumento / disminución

a = a - 1;
foo(a);

y

foo(a);
a = a - 1;

puede reescribirse fácilmente como

foo(--a);

y

foo(a--);

respectivamente.

Usar thiso en selflugar de windowen contexto global

Ahorro autoexplicativo de 2 caracteres.

Use la notación de paréntesis para repetir el acceso a la propiedad

Este es definitivamente un acto de equilibrio entre la longitud del nombre de la propiedad y el número de accesos. En lugar de llamar a.longFunctionName()dos veces con notación de punto, es más corto guardar el nombre y llamar a la función mediante notación de paréntesis:

a.longFunctionName(b)
a.longFunctionName(c)
//42

-vs-

a[f='longFunctionName'](b)
a[f](c)
//34

Esto es especialmente efectivo con funciones como las document.getElementByIdque se pueden reducir a d[e].

Nota:

Con la notación de corchetes, el costo son 6 + name.lengthcaracteres la primera vez. Cada acceso posterior tiene un costo de 3caracteres.

Para la notación de puntos, todos los accesos cuestan name.length + 1(+1 para los .) caracteres.

Use este método si 6 + name.length + (3 * (accesses - 1)) < accesses * (name.length + 1).

len = longitud del nombre de la propiedad
i = accesos mínimos para aprovechar

len | i 
========
1   | ∞ 
2   | ∞ 
3   | 7 
4   | 4 
5   | 3 
6   | 3 
7   | 3 
8+  | 2 

El número de accesos también puede abarcar múltiples objetos. Si accede .length4 o más veces en diferentes matrices, puede usar la misma variable que contiene la cadena 'length'.

División con números para guardar las comillas:

"alpha,bravo,charlie".split(",") // before
"alpha0bravo0charlie".split(0)   // after

Use el operador de coma para evitar llaves (también se aplica a C ):

if(i<10)m+=5,n-=3;

En lugar de

if(i<10){m+=5;n-=3}

que es un personaje más largo.

Generación de números aleatorios más corta

Si necesita un booleano aleatorio ( 0o 1):

new Date&1 // equivalent to Math.random()<0.5

Si necesita un entero aleatorio 0 <= n < 1337:

new Date%1337 // equivalent to Math.floor(Math.random()*1337))

Esto funciona porque a Datese almacena internamente en JavaScript como la cantidad de milisegundos desde una época, por lo que new Datese está coaccionando 123somebignumber456cuando intentas hacer matemáticas enteras en él.

Por supuesto, estos números "aleatorios" realmente no serán tan aleatorios, especialmente si los llamas varias veces seguidas, así que tenlo en cuenta.

Puede usar la forma literal del objeto get / set para evitar usar la palabra clave function.

var obj = {
  get f(){
    console.log("just accessing this variable runs this code");
    return "this is actually a function";
  },
  set f(v){
    console.log("you can do whatever you want in here, passed: " + v);
  }
};

1 && obj.f; // runs obj.[[get f]]
obj.f = Infinity; // runs obj.[[set f]](Infinity)

Este es menos conocido y menos utilizado, pero puede ser impresionante si se usa en la situación correcta. Considere una función que no toma argumentos y siempre devuelve un número diferente cuando se llama, y ​​el número devuelto se usará en un cálculo:

var a = [ 
    Math.random()*12|0,
    Math.random()*11|0,
    Math.random()*10|0,
    /* etc... */ 
];

Normalmente puede acortar esta función usando un nombre de variable de una letra:

var r=Math.random,a=[r()*12|0,r()*11|0,r()*10|0,r()*9|0,r()*8|0,r()*7|0,r()*6|0,r()*5|0];

Una mejor manera de reducir la longitud es abusando valueOf, lo que le permite guardar 2 caracteres por invocación. Útil si llama a la función más de 5 veces:

var r={valueOf:Math.random},a=[r*12|0,r*11|0,r*10|0,r*9|0r*8|0,r*7|0,r*6|0,r*5|0];

Aprovechando los operadores de cortocircuito

En lugar de largas ifdeclaraciones o el uso de operadores ternarios, puede utilizar &&y ||acortar su código. Por ejemplo:

var match = RegExp('[?&]' + name + '=([^&]*)').exec(window.location.search);

return match ? decodeURIComponent(match[1].replace(/\+/g, ' ')) : null;

puede llegar a ser

var match = RegExp('[?&]' + name + '=([^&]*)').exec(window.location.search);

return match && decodeURIComponent(match[1].replace(/\+/g, ' '));

El ||operador se usa a menudo de esta manera para establecer valores predeterminados:

evt = evt || window.event;

Esto es lo mismo que escribir

if (!evt)
    evt = window.event;

Crear cadenas repetitivas usando Array

Si desea inicializar una cadena larga de un carácter en particular, puede hacerlo creando una matriz con una longitud de n + 1 , donde n es el número de veces que desea repetir el carácter:

// Create a string with 30 spaces
str = "                              ";

// or
str = Array(31).join(" ");

Cuanto más grande es la cuerda, mayor es el ahorro.

Analizando números

Use +y ~operadores en lugar de parseFloat()o parseInt()al fusionar un tipo de cadena que es solo un número con un tipo de número:

var num = "12.6";
parseFloat(num) === +num;  // + is 10 characters shorter than parseFloat()

var num2 = "12"
parseInt(num2) === +num2;   // + is 8 characters shorter than parseInt()

var num3 = "12.6"
parseInt(num3) === ~~num3;  // ~~ is 7 characters shorter than parseInt()

var num4 = "12.6"
parseInt(num4) === num4|0;  // |0 is 7 characters shorter than parseInt()

Sin embargo, tenga cuidado, otros tipos pueden fusionarse con estos operadores (por ejemplo, truese convertirían 1) en una cadena vacía o se convertiría en una cadena que contiene solo un espacio en blanco 0. Sin embargo, esto podría ser útil en ciertas circunstancias.

Introducir la inicialización de la variable en la llamada prompt () para obtener la entrada del usuario

n=prompt(i=5);     // sets i=5 at the same time as getting user input

En lugar de usar

n=prompt();i=5;

Como efecto secundario, muestra el valor de entrada en la ventana de solicitud al guardar 1 carácter.

Combinar anidados para bucles:

// before:
for(i=5;i--;)for(j=5;j--;)dosomething(i,j)

// after:
for(i=25;i--;)dosomething(0|i/5,i%5)

Ejemplo con diferentes valores para i/ j:

// before:
for(i=4;i--;)for(j=7;j--;)dosomething(i,j)

// after:
for(i=28;i--;)dosomething(0|i/7,i%7)

Atajos Unicode

Si utiliza una gran propiedad incorporada en un gran desafío de golf, puede asignar un alias a cada propiedad con un equivalente de un personaje:

[Math,Number,S=String,Array].map(b=>
    Object.getOwnPropertyNames(b).map((p,i)=>
        b.prototype[S.fromCharCode(i+248)]=b[p]
    )
)

Después de ejecutar el código anterior, puede usarlo así:
"foo".Č(/.*/,'bar') // replaces foo with bar

Esto cuesta 118 bytes, por lo que podría no ser útil en ciertas situaciones

Puede depender del navegador y no estoy seguro de si es más corto with(Array){join(foo),...}o define variables como propiedades utilizadas, with(Array){j=join,m=map...}pero vale la pena mencionarlo.

    Math        Number              String              Array

ø   toSource    prototype           prototype           prototype
ù   abs         NaN                 quote               join
ú   acos        POSITIVE_INFINITY   substring           reverse
û   asin        NEGATIVE_INFINITY   toLowerCase         sort
ü   atan        MAX_VALUE           toUpperCase         push
ý   atan2       MIN_VALUE           charAt              pop
þ   ceil        MAX_SAFE_INTEGER    charCodeAt          shift
ÿ   clz32       MIN_SAFE_INTEGER    contains            unshift
Ā   cos         EPSILON             indexOf             splice
ā   exp         isFinite            lastIndexOf         concat
Ă   floor       isInteger           startsWith          slice
ă   imul        isNaN               endsWith            filter
Ą   fround      toInteger           trim                isArray
ą   log         parseFloat          trimLeft            lastIndexOf
Ć   max         parseInt            trimRight           indexOf
ć   min         length              toLocaleLowerCase   forEach
Ĉ   pow         name                toLocaleUpperCase   map
ĉ   random      arguments           normalize           every
Ċ   round       caller              match               some
ċ   sin                             search              reduce
Č   sqrt                            replace             reduceRight
č   tan                             split   
Ď   log10                           substr  
ď   log2                            concat  
Đ   log1p                           slice   
đ   expm1                           fromCharCode    
Ē   cosh                            fromCodePoint   
ē   sinh                            localeCompare   
Ĕ   tanh                            length  
ĕ   acosh                           name    
Ė   asinh                           arguments   
ė   atanh                           caller  
Ę   hypot           
ę   trunc           
Ě   sign            
ě   cbrt            
Ĝ   E           
ĝ   LOG2E           
Ğ   LOG10E          
ğ   LN2         
Ġ   LN10            
ġ   PI          
Ģ   SQRT2           
ģ   SQRT1_2         

Convertir un whilebucle en un forbucle suele ser equivalente:

while(i--);
for(;i--;);

Pero la segunda forma puede tener una inicialización variable combinada:

i=10;while(i--);
for(i=10;i--;);

Observe que la segunda forma tiene un carácter más corto que la primera forma.

Abuso de excepción

en caso de que se prohíban los literales de cadena / caracteres, puede usar un bloque try catch:

try{something0}catch(e){str=e.message.split(0)[0]}

ahora stres igual"something"

Si se necesitan más cadenas, puede encadenarlo con un número (por ejemplo, ceros)

try{something0foo0bar0}catch(e){arr=e.message.split(0)}

ahora arres igual["something", "foo", "bar", " is not defined"]

Si está inicializando una variable 1en cada iteración de un bucle (por ejemplo, restableciendo una variable en un bucle externo para un bucle interno), como el siguiente (de mi respuesta a esta pregunta ):

for(j=n-2;p=1,j++<=n;r|=p)for(i=1;++i<j;)p=j%i?p:0;
          ^^^^

Dado que el resultado de una condición como j++<=nes 1siempre que sea ​​verdadera, solo puede asignar la condición directamente a la variable (porque cuando se vuelve falsa, el ciclo dejará de ejecutarse y ya no importará):

for(j=n-2;p=j++<=n;r|=p)for(i=1;++i<j;)p=j%i?p:0;
          ^^^^^^^^

Por lo general, puede guardar 2 caracteres con este método. Saludos a @ugorenla idea en los comentarios a esa respuesta.

Para otro ejemplo, también apliqué este truco a mi respuesta aquí con la expresión w=r=++c<S.lengthen mi bucle for externo, guardando un total de 4 caracteres.

Si puede aceptar scripts específicos de Spidermonkey (por ahora), puede usar las funciones de flecha de ECMAScript 6 . En lugar de escribir código como el siguiente.

a.map(function(x){return x*2}) // function? return?

Puedes acortarlo así.

a.map(x=>x*2)

Si necesita verificar NaN, no lo use isNaN(x), pero use x!=x, que es más corto y también funciona.

if(isNaN(x)){
if(x!=x){

Tenga en cuenta que esto solo funciona si typeof(x) === "number"; si es una cadena, por ejemplo, isNaN("string")devuelve true, pero "string" != "string"devuelve false. ¡Gracias a Cyoce por señalar esto!

Suma de matrices / producto / cociente

ES5 : 17 bytes

eval(a.join('+'))

ES6 : 15 bytes

eval(a.join`+`)

Por supuesto, puede cambiarlo +por lo que desee, por ejemplo, *por producto o /por cociente.

Use una operación bit a bit para redondear un número hacia cero:

// do this
T=Math.random()*6+1|0

// or do this
T=~~(Math.random()*6+1)

(Fuente: propinas al azar )

La precedencia del operador determina cuál será más corto en su programa.

Sugerencia de bucle I

Puede guardar el 1carácter cuando se repite cambiando ila última vez que se usó:

//not so god
for(i=0;i<3;i++){
  alert(i);
}

//best
for(i=0;i<3;){
  alert(i++);
}

Nota: también funciona con --(pero modifique el bucle en consecuencia para evitar bucles infinitos)

Punta de bucle II

Hay ciertos escenarios en los que puedes guardar un personaje jugando con el operador y los valores incrementales:

for(i=0;i++<9;)
for(i=0;++i<10;)

Nota: debe prestar atención cuando, por ejemplo 0 to -1. y 9 to 10, 99 to 100, así que juega hasta que encuentres una manera de salvar al personaje

Usar en ^lugar de !=o ==cuando se compara con un número entero

//x!=3?a:b
  x^3?a:b

//x==3?a:b
  x^3?b:a

Reemplazar llamadas a funciones matemáticas incorporadas con expresiones más cortas

//Math.ceil(n)
  n%1?-~n:n

//Math.floor(n)
  ~~n
  0|n

//Math.abs(n)
  n<0?-n:n

//Math.round(n)
  n+.5|0

//Math.min(x,y)
  x<y?x:y

//Math.max(x,y)
  y<x?x:y

Algo que vale la pena señalar es que puede usar una cadena en lugar de cero en algunos casos para guardar un par de bytes aquí y allá en bucles:

s='';for(i=0;i++<9;)s+=i
for(i=s='';i++<9;)s+=i
// s="123456789", i=10

Muy simple, aun así, nadie lo había mencionado.

Si está utilizando Math.min()o Math.max()puede guardar 6 caracteres haciendo esto:

Math.min(a,b)  // 13 chars
a<b?a:b        //  7 chars

Math.max(a,b)
a>b?a:b

Redondeo

Sé que Math.floor()se han publicado alternativas , pero ¿qué pasa con los demás?

Piso:

Math.floor(x) //before
0|x           //after

Redondeo:

Math.round(x) //before
0|x+.5        //after

Techo:

Math.ceil(x) //before
x%1?-~x:x    //after - credits to @Tomas Langkaas

En los casos en que está utilizando el operador ternario para elegir entre dos números , y el condicional es un booleano o un número 1 or 0 , puede realizar operaciones matemáticas en su lugar:

(x ? num1 : num2) conclusions:

    1)if num1 equals num2, there ARE savings
    2)if num1 is (+1) or (-1) than num2, there ARE savings
    3)if either num1 or num2 equals to 0, there ARE savings
    4)it is MORE LIKELY to find greater savings on num1>num2 instead of num1<num2
    5)in method (*A) and (*B), savings are NOT GUARANTEED

    a)num1>num2
        i)(num1==(num2+1))
            ex1: (x?5:4) to (x+4)
            ex2: (x?8:7) to (x+7)
        ii)num2==0
            ex1: (x?3:0) to (x*3)
            ex2: (x?7:0) to (x*7)
        iii)
            (*A) or (*B) //one might be shorter

    b)num1<num2
        i)((num1+1)==num2)
            ex1: (x?4:5) to (5-x)
            ex2: (x?7:8) to (8-x)
        ii)num1==0
            ex1: (x?0:3) to (!x*3)
            ex2: (x?0:7) to (!x*7)
        iii)
            (*A) or (*B) //one might be shorter

    c)num1==num2
        i)
            ex1: (x?5:5) to (5)
            ex2: (x?-3:-3) to (-3)

    (*A) use ((x*(num1-num2))+num2)
        ex1: (x?8:4)   to ((x*4)+4)
        ex2: (x?4:8)   to ((x*-4)+8)

        ex3: (x?6:-4)  to ((x*10)-4)
        ex4: (x?-4:6)  to ((x*-10)+6)

        ex5: (x?4:-6)  to ((x*10)-6)
        ex6: (x?-6:4)  to ((x*-10)+4)

        ex7: (x?-5:-9) to ((x*4)-9)
        ex8: (x?-9:-5) to ((x*-4)-5)

    (*B) use ((!x*(num2-num1))+num1)
        ex1: (x?8:4)   to ((!x*-4)+8)
        ex2: (x?4:8)   to ((!x*4)+4)

        ex3: (x?6:-4)  to ((!x*-10)+6)
        ex4: (x?-4:6)  to ((!x*10)-4))

        ex5: (x?4:-6)  to ((!x*-10)+4)
        ex6: (x?-6:4)  to ((!x*10)-6)

        ex7: (x?-5:-9) to ((!x*-4)-5)
        ex8: (x?-9:-5) to ((!x*4)-9)

Nota: Además de esto, se tendrá que eliminar lo innecesario 0-, +0, +-etc.

Nota 2: hay un caso aislado donde (x) !== (x?1:0), como xdebe ser typeof === "number"para que funcione. Sin embargo, en el caso de (-x)que funcione bien.

Nota 3: en caso de que no encuentre ahorros, simplemente use el primero(x?y:z)

Anteriormente pensé que el método B nunca podría vencer a A, sin embargo, existen excepciones:

(x?97:100) //original

(-3*x+100)
(3*!x+97)

Creé un proyecto github que nos simplifica ( demo jsFiddle )

tl; dr: ¡ Usa las funciones de ES6!

Funciones de flecha

Doc: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/arrow_functions
Ejemplo:

s = x => x*x
// s = function (x) {
//   return x * x;
// }

Abusar de literales

La muestra reciente: compruebe si "c"es mayúscula o minúscula, no importa si no es letra

"c"<{} // returns false, lower case
"C"<{} // returns true, upper case

Cómo comparar un número con la ayuda de cómo los números se convierten en booleanos:

Si va a verificar si algo es igual a un número positivo , puede restar esa cantidad e invertir lo que estaba dentro de los bloques ify else:

//simplified examples:
x==3?"y":"n"; <- 13 Chars
x-3?"n":"y"; <- 12 Chars

//expanded examples:
if(x==3){
    yes();
}else{
    no();
}

if(x-3){
    no();
}else{
    yes();
}

Y en caso de que desee comparar con un número negativo (* diferente a -1), simplemente necesita sumar este número en lugar de restar.

* bueno, seguramente puedes usarlo x.indexOf(y) + 1, pero en el caso especial de -1que tengas la oportunidad de usarlo ~x.indexOf(y).

Utilice la función no estándar de "cierres de expresiones" de Mozilla para guardar muchos caracteres en un script que solo necesita funcionar en los motores SpiderMonkey / Firefox o Rhino. Por ejemplo,

function foo(){return bar}

se convierte

function foo()bar

Ver la página de desbordamiento de pila para más trucos.

Usar en if(~a.indexOf(b))lugar deif(a.indexOf(b)!=-1)

En lugar de escribir truepuedes usar !0.

Transformando a un booleano :

if(b){b=true}else{b=false}
b=b?true:false;
b=b?!0:!1;
b=!!b;

Nota: Esto cambia 0, "", false, null, undefinedy NaNparafalse (todo lo demás a true)