Quali consigli generali hai per giocare a golf in JavaScript? Sto cercando idee che possano essere applicate ai problemi del codice golf in generale che siano almeno in qualche modo specifiche per JavaScript (ad esempio "rimuovere i commenti" non è una risposta).

Nota: vedere anche Suggerimenti per giocare a golf in ECMAScript 6 e versioni successive

Fantasia per loop

puoi usare lo standard per loop in modi non standard

for ( a; b; c )

è sostanzialmente equivalente a:

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

quindi un buon trucco è scrivere il codice con un whileciclo e quindi dividerlo nelle a,b,cparti in un forciclo.

Un paio di esempi che ho scritto :

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

Incatena i tuoi setter

Se stai inizializzando o reimpostando più valori, concatenalo su tutte le variabili che ne hanno bisogno:

a=b=1;

Casting implicito

Non controllare i tuoi tipi, basta usarli così come sono. parseInt()costa 10personaggi. Se devi eseguire il cast di una stringa, sii 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;

Evita punti e virgola

JavaScript ha l'inserimento automatico di punti e virgola. Usalo spesso e bene.

One-liner

Risparmia tra parentesi spostando il più possibile in singole righe o parametri:

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

Operatori di incremento / decremento

a = a - 1;
foo(a);

e

foo(a);
a = a - 1;

può essere facilmente riscritto come

foo(--a);

e

foo(a--);

rispettivamente.

Utilizzare thiso selfanziché windownel contesto globale

autoesplicativo risparmio di 2 caratteri.

Utilizzare la notazione parentesi per ripetere l'accesso alle proprietà

Questo è sicuramente un atto di bilanciamento tra lunghezza del nome della proprietà e numero di accessi. Invece di chiamare a.longFunctionName()due volte con la notazione a punti, è più breve salvare il nome e chiamare la funzione tramite la notazione a parentesi:

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

-confrontarli-

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

questo è particolarmente efficace con funzioni come quelle document.getElementByIdche possono essere ridotte a d[e].

Nota:

Con la notazione parentesi, il costo è in 6 + name.lengthcaratteri la prima volta. Ogni accesso successivo ha un costo di 3caratteri.

Per la notazione punto, tutti gli accessi costano name.length + 1(+1 per i .) caratteri.

Utilizzare questo metodo se 6 + name.length + (3 * (accesses - 1)) < accesses * (name.length + 1).

len = lunghezza del nome della proprietà
i = accessi minimi per trarne vantaggio

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

Il numero di accessi può anche comprendere più oggetti. Se si accede .length4 o più volte su array diversi, è possibile utilizzare la stessa variabile che contiene la stringa 'length'.

Divisione con numeri per salvare i virgolette:

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

Utilizzare l'operatore virgola per evitare le parentesi graffe ( vale anche per C ):

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

Invece di

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

che è un personaggio più lungo.

Generazione di numeri casuali più breve

Se hai bisogno di un booleano casuale ( 0o 1):

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

Se hai bisogno di un numero intero casuale 0 <= n < 1337:

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

Ciò funziona perché a Dateviene memorizzato internamente in JavaScript come la quantità di millisecondi trascorsi da un'epoca, quindi new Dateviene forzato 123somebignumber456quando si tenta di eseguire la matematica intera su di esso.

Naturalmente, questi numeri "casuali" non saranno così casuali, specialmente se li chiami più volte in rapida successione, quindi tienilo a mente.

È possibile utilizzare la forma letterale dell'oggetto get / set per evitare di usare la parola chiave 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)

Questo è meno conosciuto e meno usato, ma può essere impressionante se usato nella giusta situazione. Considera una funzione che non accetta argomenti e restituisce sempre un numero diverso quando viene chiamata e il numero restituito verrà utilizzato in un calcolo:

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

Normalmente è possibile abbreviare questa funzione utilizzando un nome variabile a lettera singola:

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

Un modo migliore per ridurre la lunghezza è l'abuso valueOf, che consente di risparmiare 2 caratteri per invocazione. Utile se si chiama la funzione più di 5 volte:

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

Approfittando degli operatori di corto circuito

Piuttosto che ifdichiarazioni lunghe o l'utilizzo di operatori ternari, è possibile utilizzare &&e ||abbreviare il codice. Per esempio:

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

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

può diventare

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

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

L' ||operatore viene spesso utilizzato in questo modo per impostare i valori predefiniti:

evt = evt || window.event;

È lo stesso della scrittura

if (!evt)
    evt = window.event;

Creazione di stringhe ripetitive utilizzando Array

Se vuoi inizializzare una lunga stringa di un particolare carattere, puoi farlo creando un array con una lunghezza di n + 1 , dove n è il numero di volte in cui desideri ripetere il carattere:

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

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

Maggiore è la stringa, maggiore è il risparmio.

Analisi dei numeri

Utilizzare +e ~operatori invece di parseFloat()o parseInt()quando si unisce un tipo di stringa che è solo un numero a un tipo di numero:

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

Diffidare però, altri tipi possono essere coalizzati con questi operatori (ad esempio, truediventerebbe 1) una stringa vuota o una stringa contenente solo uno spazio bianco diventerebbe 0. Ciò potrebbe essere utile in determinate circostanze, tuttavia.

Inizializza di nascosto la variabile nella richiesta () per ottenere l'input dell'utente

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

invece di usare

n=prompt();i=5;

Come effetto collaterale, visualizza il valore di input nella finestra del prompt mentre si salva 1 carattere.

Combina nidificato per loop:

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

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

Esempio con valori diversi per 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)

Scorciatoie Unicode

Se usi un inferno di una proprietà incorporata in una grande sfida di golf puoi alias ogni proprietà con un equivalente di un personaggio:

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

Dopo aver eseguito il codice sopra puoi usarlo in questo modo:
"foo".Č(/.*/,'bar') // replaces foo with bar

Questo costa 118 byte, quindi potrebbe non essere utile in determinate situazioni

Potrebbe dipendere dal browser e non sono sicuro che sia più breve with(Array){join(foo),...}o che definisca le variabili come proprietà usate, with(Array){j=join,m=map...}ma vale comunque la pena menzionarle.

    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         

La conversione di un whileloop in un forloop è spesso equivalente:

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

Ma il secondo modulo può avere un'inizializzazione variabile combinata:

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

Si noti che il secondo modulo è più corto di un carattere rispetto al primo modulo.

Abuso di eccezione

nel caso in cui i letterali stringa / carattere siano vietati, è possibile utilizzare un blocco catch catch:

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

ora è struguale"something"

se sono necessarie più stringhe, è possibile concatenarle con un numero (ad es. zeri)

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

ora è arruguale["something", "foo", "bar", " is not defined"]

Se stai inizializzando una variabile 1in ogni iterazione di un ciclo (ad esempio, reimpostando una variabile in un ciclo esterno per un ciclo interno), come il seguente (dalla mia risposta a questa domanda ):

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

Poiché il risultato di una condizione come j++<=nè 1ogni volta che è vero, puoi semplicemente assegnare la condizione direttamente alla variabile (perché quando diventa falso, il ciclo smetterà di essere eseguito e non avrà più importanza):

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

Di solito puoi salvare 2 caratteri usando questo metodo. Saluti @ugorenper l'idea nei commenti a quella risposta.

Per un altro esempio, ho anche applicato questo trucco alla mia risposta qui con l'espressione w=r=++c<S.lengthnel mio ciclo esterno, salvando un totale di 4 caratteri.

Se è possibile accettare script specifici di Spidermonkey (per ora), è possibile utilizzare le funzioni freccia ECMAScript 6 . Invece di scrivere codice come il seguente.

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

Puoi accorciarlo in questo modo.

a.map(x=>x*2)

Se è necessario verificare la presenza di NaN, non utilizzare isNaN(x), ma utilizzare x!=x, che è più breve e funziona anche.

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

Nota che funziona solo se typeof(x) === "number"; se ad esempio è una stringa, isNaN("string")restituisce true, ma "string" != "string"restituisce false. Grazie a Cyoce per averlo segnalato!

Somma matrice / prodotto / quoziente

ES5 : 17 byte

eval(a.join('+'))

ES6 : 15 byte

eval(a.join`+`)

Ovviamente puoi scambiarlo +con tutto quello che vuoi, ad es. *Per prodotto o /per quoziente.

Utilizzare un'operazione bit a bit per arrotondare un numero verso zero:

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

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

(Fonte: ribaltamento casuale dei dadi )

La precedenza dell'operatore determina quale sarà più breve nel programma.

Consiglio ad anello I

Puoi salvare il 1personaggio durante il loop modificando il'ultima volta utilizzata:

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

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

Nota: funziona --anche con (ma modifica il loop di conseguenza per evitare loop infiniti)

Punta ad anello II

Esistono alcuni scenari in cui è possibile salvare un personaggio giocando con l'operatore e i valori incrementali:

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

Nota: è necessario prestare attenzione, ad esempio 0 to -1. e 9 to 10, 99 to 100, quindi, gioca fino a trovare un modo per salvare il personaggio

Utilizzare ^invece di !=o ==quando si confronta con un numero intero

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

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

Sostituisci le chiamate alle funzioni matematiche integrate con espressioni più brevi

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

Una cosa degna di nota è che in alcuni casi è possibile utilizzare una stringa al posto di zero per salvare un paio di byte qua e là nei loop:

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

Molto semplice, anche così, nessuno l'aveva menzionato.

Se stai usando Math.min()o Math.max()puoi salvare 6 caratteri in questo modo:

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

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

Arrotondamento

So che Math.floor()sono state pubblicate delle alternative , ma per quanto riguarda le altre?

Pavimentazione:

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

Arrotondamento:

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

Soffitto:

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

Nei casi in cui stai utilizzando l'operatore ternario per scegliere tra due numeri e il condizionale è un valore booleano o un numero 1 or 0 , puoi invece eseguire operazioni matematiche:

(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: In aggiunta a questo, è necessario rimuovere il superfluo 0-, +0, +-etc.

Nota2: esiste un caso isolato in cui (x) !== (x?1:0), come xdeve essere typeof === "number"perché funzioni. Tuttavia, nel caso in cui (-x)funzioni bene.

Nota 3: Nel caso in cui non trovi risparmi, utilizza semplicemente il primo(x?y:z)

In precedenza pensavo che il metodo B non potesse mai battere A, tuttavia esistono eccezioni:

(x?97:100) //original

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

Ho creato un progetto github che ci semplifica ( demo jsFiddle )

tl; dr: usa le funzionalità ES6!

Funzioni freccia

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

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

Abuso letterale

Il campione recente: controlla se "c"è maiuscolo o minuscolo, non importa se non lettera

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

Come confrontare un numero con l'aiuto di come i numeri si trasformano in booleani:

Se hai intenzione di verificare se qualcosa è uguale a un numero positivo , puoi sottrarre tale importo e invertire ciò che era all'interno dei blocchi ife 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();
}

E nel caso in cui si desideri confrontare un numero negativo (* diverso da -1), è sufficiente aggiungere questo numero invece di sottrarre.

* bene, puoi sicuramente usarlo x.indexOf(y) + 1, ma nel caso speciale -1hai la possibilità di usarlo ~x.indexOf(y)invece.

Usa la funzione "chiusure" non standard di Mozilla per salvare molti personaggi in uno script che deve funzionare solo nei motori SpiderMonkey / Firefox o Rhino. Per esempio,

function foo(){return bar}

diventa

function foo()bar

Vedi la pagina Stack Overflow per ulteriori trucchi.

Usa if(~a.indexOf(b))invece diif(a.indexOf(b)!=-1)

Invece di scrivere truepuoi usare !0.

Trasformarsi in un booleano :

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

Nota: Questo cambia 0, "", false, null, undefinede NaNper false(tutto il resto a true)