Jakie masz ogólne wskazówki dotyczące gry w golfa w JavaScript? Szukam pomysłów, które można by zastosować do problemów z golfem w kodzie, które są przynajmniej w pewnym stopniu specyficzne dla JavaScript (np. „Usuń komentarze” nie jest odpowiedzią).

Uwaga: Zobacz także Porady dotyczące gry w golfa w ECMAScript 6 i nowszych

Fancy For Loops

możesz użyć standardowej pętli dla niestandardowych sposobów

for ( a; b; c )

jest zasadniczo równoważny z:

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

więc dobrą sztuczką jest napisanie kodu w whilepętli, a następnie podzielenie go na a,b,cczęści w forpętli.

Kilka przykładów , które napisałem :

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

Połącz swoje setery

Jeśli inicjujesz lub resetujesz wiele wartości, połącz wartość ze wszystkimi potrzebnymi zmiennymi:

a=b=1;

Implicit Casting

Nie sprawdzaj typów, po prostu używaj ich takimi, jakie są. parseInt()kosztuje 10postacie. Jeśli chcesz odrzucić ciąg, bądź kreatywny:

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;

Unikaj średników

JavaScript ma automatyczne wstawianie średników. Używaj go często i dobrze.

Jednowarstwowe

Zaoszczędź na nawiasach, umieszczając jak najwięcej w pojedynczych wierszach lub parametrach:

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

Operatory inkrementacji / dekrementacji

a = a - 1;
foo(a);

i

foo(a);
a = a - 1;

można łatwo przepisać jako

foo(--a);

i

foo(a--);

odpowiednio, kolejno.

Użyj thislub selfzamiast windoww kontekście globalnym

oczywiste oszczędności 2 znaków.

Użyj notacji w nawiasach, aby uzyskać dostęp do powtarzanych właściwości

Jest to z pewnością równowaga między długością nazwy nieruchomości a liczbą dostępów. Zamiast wywoływać a.longFunctionName()dwukrotnie notację kropkową, krótsze jest zapisanie nazwy i wywołanie funkcji za pomocą notacji nawiasowej:

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

-vs-

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

jest to szczególnie skuteczne w przypadku funkcji, document.getElementByIdktóre można zredukować do d[e].

Uwaga:

Przy zapisie w nawiasie 6 + name.lengthza pierwszym razem koszt to znaki. Każdy kolejny dostęp ma koszt 3znaków.

W przypadku notacji kropkowej wszystkie wejścia kosztują name.length + 1(+1 dla .) znaków.

Użyj tej metody, jeśli 6 + name.length + (3 * (accesses - 1)) < accesses * (name.length + 1).

len = długość nazwy właściwości
i = minimalny dostęp, aby skorzystać

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

Liczba dostępów może również obejmować wiele obiektów. Jeśli uzyskujesz dostęp .length4 lub więcej razy na różnych tablicach, możesz użyć tej samej zmiennej przechowującej ciąg 'length'.

Dzielenie liczbami, aby zapisać cytaty:

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

Użyj operatora przecinka, aby uniknąć nawiasów klamrowych ( dotyczy również C ):

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

Zamiast

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

który jest o jedną postać dłuższy.

Krótsze generowanie liczb losowych

Jeśli potrzebujesz losowej wartości logicznej ( 0lub 1):

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

Jeśli potrzebujesz losowej liczby całkowitej 0 <= n < 1337:

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

Działa to, ponieważ a Datejest przechowywane wewnętrznie w JavaScript jako ilość milisekund od epoki, więc new Datejest przymuszane, 123somebignumber456gdy próbujesz wykonać na nim matematykę całkowitą.

Oczywiście te „losowe” liczby naprawdę nie będą tak losowe, zwłaszcza jeśli wywołujesz je wiele razy w krótkich odstępach czasu, więc miej to na uwadze.

Możesz użyć dosłownej formy obiektu get / set, aby uniknąć używania słowa kluczowego 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)

Ten jest mniej znany i rzadziej używany, ale może być imponujący, jeśli zostanie użyty we właściwej sytuacji. Rozważ funkcję, która nie przyjmuje argumentów i zawsze zwraca inną liczbę po wywołaniu, a zwrócona liczba zostanie wykorzystana w obliczeniach:

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

Zwykle możesz skrócić tę funkcję, używając jednuliterowej nazwy zmiennej:

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

Lepszym sposobem na zmniejszenie długości jest nadużycie valueOf, co daje oszczędność 2 znaków na każde wywołanie. Przydatne, jeśli wywołasz funkcję więcej niż 5 razy:

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

Wykorzystanie operatorów zwarć

Zamiast długich ifinstrukcji lub operatorów trójskładnikowych możesz użyć &&i ||skrócić swój kod. Na przykład:

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

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

może zostać

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

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

||Operator jest często używany w ten sposób do ustawiania wartości domyślnych:

evt = evt || window.event;

To jest tak samo jak pisanie

if (!evt)
    evt = window.event;

Tworzenie powtarzających się ciągów za pomocą Array

Jeśli chcesz zainicjować długi ciąg określonego znaku, możesz to zrobić, tworząc tablicę o długości n + 1 , gdzie n jest liczbą powtórzeń znaku:

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

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

Im większy ciąg, tym większa oszczędność.

Parsowanie liczb

Użyj operatorów +i ~zamiast parseFloat()lub parseInt()podczas koalescencji typu ciągu, który jest tylko liczbą do typu liczby:

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

Uważaj jednak, inne typy mogą być łączone z tymi operatorami (na przykład truemogłyby stać się 1) pustym łańcuchem lub łańcuchem zawierającym tylko białe znaki 0. Może to jednak być przydatne w pewnych okolicznościach.

Podejmij inicjalizację zmiennej do wywołania prompt () w celu uzyskania danych wejściowych od użytkownika

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

zamiast używać

n=prompt();i=5;

Jako efekt uboczny wyświetla wartość wejściową w oknie zachęty, zapisując 1 znak.

Połącz zagnieżdżone dla pętli:

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

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

Przykład z różnymi wartościami 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)

Skróty Unicode

Jeśli używasz piekielnie wbudowanej nieruchomości podczas dużego wyzwania golfowego, możesz aliasować każdą właściwość do ekwiwalentu jednej postaci:

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

Po wykonaniu powyższego kodu możesz go użyć w następujący sposób:
"foo".Č(/.*/,'bar') // replaces foo with bar

Kosztuje to 118 bajtów, więc może nie być przydatne w niektórych sytuacjach

Może być zależny od przeglądarki i nie jestem pewien, czy jest krótszy with(Array){join(foo),...}lub definiuje zmienne jako używane właściwości, with(Array){j=join,m=map...}ale nadal warto o tym wspomnieć.

    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         

Przekształcanie whilepętli w forpętlę jest często równoważne:

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

Ale druga forma może mieć zmienną inicjalizację połączoną:

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

Zauważ, że druga forma jest o jeden znak krótsza niż pierwsza forma.

Nadużywanie wyjątków

w przypadku, gdy literały łańcuchowe / znakowe są zabronione, możesz użyć bloku try catch:

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

teraz strjest równy"something"

jeśli potrzeba więcej ciągów, możesz połączyć go łańcuchem z liczbą (np. zerami)

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

teraz arrjest równy["something", "foo", "bar", " is not defined"]

Jeśli inicjujesz zmienną 1w każdej iteracji pętli (na przykład resetujesz zmienną w zewnętrznej pętli dla wewnętrznej pętli), wykonaj następujące czynności (z mojej odpowiedzi na to pytanie ):

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

Ponieważ wynikiem warunku podobnego j++<=njest 1zawsze, gdy jest on prawdziwy, możesz po prostu przypisać warunek bezpośrednio do zmiennej (ponieważ gdy stanie się fałszem, pętla przestanie działać i nie będzie już miała znaczenia):

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

Za pomocą tej metody można zwykle zapisać 2 znaki . Odnosi się @ugorendo pomysłu w komentarzach do tej odpowiedzi.

W innym przykładzie zastosowałem tę sztuczkę do mojej odpowiedzi tutaj z wyrażeniem w=r=++c<S.lengthw mojej zewnętrznej pętli for, oszczędzając w sumie 4 znaki.

Jeśli możesz zaakceptować określone skrypty Spidermonkey (na razie), możesz użyć funkcji strzałek ECMAScript 6 . Zamiast pisać kod jak poniżej.

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

Możesz to skrócić w ten sposób.

a.map(x=>x*2)

Jeśli potrzebujesz sprawdzić NaN, nie używaj isNaN(x), ale używaj x!=x, który jest krótszy i działa.

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

Zauważ, że działa to tylko, jeśli typeof(x) === "number"; jeśli jest to na przykład ciąg znaków, isNaN("string")zwraca true, ale "string" != "string"zwraca false. Dziękujemy Cyoce za zwrócenie na to uwagi!

Suma tablicowa / produkt / iloraz

ES5 : 17 bajtów

eval(a.join('+'))

ES6 : 15 bajtów

eval(a.join`+`)

Oczywiście możesz zamienić +na dowolne, np. *Na produkt lub /iloraz.

Użyj operacji bitowej, aby zaokrąglić liczbę w kierunku zera:

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

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

(Źródło: Losowe przechylanie kości )

Priorytet operatora określa, który program będzie krótszy.

Looping Tip I

Możesz zapisać 1postać podczas zapętlania, zmieniając iostatnio używane:

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

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

Uwaga: działa --również z (ale odpowiednio zmodyfikuj pętlę, aby uniknąć nieskończonego zapętlenia)

Looping Tip II

Istnieją pewne scenariusze, w których można zapisać jedną postać, grając z operatorem i wartościami:

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

Uwaga: na przykład musisz zwrócić uwagę 0 to -1. i 9 to 10, 99 to 100, więc baw się, aż znajdziesz sposób na uratowanie postaci

Użyj ^zamiast !=lub ==podczas porównywania z liczbą całkowitą

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

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

Zastąp wywołania wbudowanych funkcji matematycznych krótszymi wyrażeniami

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

Warto zauważyć, że w niektórych przypadkach można użyć ciągu zamiast zera, aby zapisać kilka bajtów tu i tam w pętlach:

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

Mimo to bardzo prosty, nikt o tym nie wspominał.

Jeśli używasz Math.min()lub Math.max()możesz zapisać 6 znaków, robiąc to:

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

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

Zaokrąglanie

Wiem, że Math.floor()opublikowano alternatywy , ale co z pozostałymi?

Posadzka:

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

Zaokrąglanie:

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

Sufit:

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

W przypadkach, gdy używasz operatora trójskładnikowego do wybierania między dwiema liczbami , a warunek jest albo wartością logiczną, albo liczbą 1 or 0 , możesz zamiast tego wykonać operacje matematyczne:

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

Uwaga: Poza tym, trzeba będzie usunąć zbędne 0-, +0, +-itd.

Uwaga 2: istnieje izolowany przypadek, w którym (x) !== (x?1:0), jak xtrzeba , musi typeof === "number"działać. Jednak w przypadku (-x)tego działa dobrze.

Uwaga 3: Jeśli nie znajdziesz oszczędności, po prostu skorzystaj z pierwszej(x?y:z)

Wcześniej myślałem, że metoda B nigdy nie pokona A, jednak istnieją wyjątki:

(x?97:100) //original

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

Stworzyłem projekt github, który upraszcza dla nas ( demo jsFiddle )

tl; dr: Użyj funkcji ES6!

Funkcje strzałek

Dokument: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/arrow_functions
Przykład:

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

Nadużycie literałów

Ostatnia próbka: Sprawdź, czy "c"wielkie lub małe litery, nie ma znaczenia, jeśli nie litera

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

Jak porównać liczbę za pomocą tego, jak liczby zamieniają się w logiczne:

Jeśli zamierzasz sprawdzić, czy coś jest równe liczbie dodatniej , możesz odjąć tę kwotę i odwrócić to, co było w blokach ifi 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();
}

A jeśli chcesz porównać z liczbą ujemną (* inną niż -1), po prostu musisz dodać tę liczbę zamiast odejmować.

* cóż, z pewnością możesz użyć x.indexOf(y) + 1, ale w szczególnym przypadku -1masz możliwość korzystania ~x.indexOf(y)zamiast niego.

Użyj niestandardowej funkcji „zamykania wyrażeń” Mozilli, aby zapisać wiele znaków w skrypcie, który musi działać tylko w silnikach SpiderMonkey / Firefox lub Rhino. Na przykład,

function foo(){return bar}

staje się

function foo()bar

Zobacz stronę Przepełnienie stosu, aby uzyskać więcej takich sztuczek.

Użyj if(~a.indexOf(b))zamiastif(a.indexOf(b)!=-1)

Zamiast pisać truemożesz użyć !0.

Przekształcanie w wartość logiczną :

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

Uwaga: To zmienia 0, "", false, null, undefinedi NaNna false(wszystko inne true)