Какие общие советы у вас есть для игры в гольф на JavaScript? Я ищу идеи, которые могут быть применены к проблемам с гольфом в коде, которые, по крайней мере, несколько специфичны для JavaScript (например, «удалить комментарии» - это не ответ).

Примечание. См. Также Советы по игре в гольф в ECMAScript 6 и выше.

Fancy For Loops

Вы можете использовать стандарт для цикла нестандартными способами

for ( a; b; c )

по существу эквивалентно:

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

так что хороший трюк - написать код с whileциклом, а затем разбить его на a,b,cчасти в forцикле.

Несколько примеров, которые я написал :

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

Цепи ваши сеттеры

Если вы инициализируете или сбрасываете несколько значений, объедините их во все переменные, которые в нем нуждаются:

a=b=1;

Неявное кастинг

Не проверяйте свои типы, просто используйте их как есть. parseInt()стоит 10персонажей. Если вам нужно изгнать из строки, будьте изобретательны:

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;

Избегайте точек с запятой

JavaScript имеет автоматическую вставку точек с запятой. Используйте это часто и хорошо.

Однострочники

Сохраните в скобках, запихивая как можно больше в отдельные строки или параметры:

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

Операторы приращения / убывания

a = a - 1;
foo(a);

а также

foo(a);
a = a - 1;

может быть легко переписан как

foo(--a);

а также

foo(a--);

соответственно.

Использовать thisили selfвместо windowв глобальном контексте

Само собой разумеющееся 2 символа сбережений.

Используйте скобочные обозначения для повторного доступа к свойствам

Это определенно баланс между длиной имени свойства и количеством обращений. Вместо того, чтобы a.longFunctionName()дважды вызывать с точечной нотацией, короче сохранить имя и вызвать функцию через скобочную нотацию:

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

vs-

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

это особенно эффективно с такими функциями, document.getElementByIdкоторые можно уменьшить до d[e].

Примечание:

В скобках обозначены 6 + name.lengthсимволы в первый раз. Каждый последующий доступ имеет стоимость 3символов.

Для точечной нотации все обращения стоят name.length + 1(+1 для .) символов.

Используйте этот метод, если 6 + name.length + (3 * (accesses - 1)) < accesses * (name.length + 1).

len = длина имени свойства
i = минимальный доступ для использования

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

Количество доступов также может охватывать несколько объектов. Если вы используете .length4 или более раз для разных массивов, вы можете использовать одну и ту же переменную, содержащую строку 'length'.

Разделение по номерам для сохранения кавычек:

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

Используйте оператор запятой, чтобы избежать скобок (также относится к C ):

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

Вместо

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

который на один символ длиннее.

Короче генерация случайных чисел

Если вам нужен случайный логический ( 0или 1):

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

Если вам нужно случайное целое число 0 <= n < 1337:

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

Это работает, потому что a Dateхранится внутри JavaScript в виде количества миллисекунд с начала эпохи, поэтому на new Dateнего навязывают, 123somebignumber456когда вы пытаетесь выполнить с ним целочисленную математику.

Конечно, эти «случайные» числа на самом деле не будут такими случайными, особенно если вы вызываете их несколько раз подряд, так что имейте это в виду.

Вы можете использовать объектную буквальную форму get / set, чтобы избежать использования ключевого слова 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)

Это менее известный и менее используемый, но может быть впечатляющим, если используется в правильной ситуации. Рассмотрим функцию, которая не принимает аргументов и всегда возвращает другое число при вызове, и возвращенное число будет использовано в вычислении:

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

Обычно вы можете сократить эту функцию, используя однобуквенное имя переменной:

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

Лучший способ уменьшить длину - злоупотреблять valueOf, что дает вам экономию 2 символов за вызов. Полезно, если вы вызываете функцию более 5 раз:

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

Использование преимуществ операторов короткого замыкания

Вместо длинных ifоператоров или использования троичных операторов вы можете использовать &&и ||сократить свой код. Например:

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

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

может стать

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

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

||Оператор часто используется таким образом , для установки по умолчанию:

evt = evt || window.event;

Это так же, как написание

if (!evt)
    evt = window.event;

Создание повторяющихся строк с использованием массива

Если вы хотите инициализировать длинную строку определенного символа, вы можете сделать это, создав массив длиной n + 1 , где n - количество повторений символа:

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

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

Чем больше строка, тем больше экономия.

Разбор чисел

Используйте +и ~операторы вместо parseFloat()или parseInt()при объединении строкового типа, который является просто числом, к числовому типу:

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

Будьте осторожны, другие типы могут объединяться с этими операторами (например, trueстать 1) пустой строкой или строкой, содержащей только пробел 0. Это может быть полезно в определенных обстоятельствах, однако.

Вставить инициализацию переменной в вызов prompt () для получения пользовательского ввода

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

Вместо того, чтобы использовать

n=prompt();i=5;

Как побочный эффект, он отображает входное значение в окне подсказки, сохраняя при этом 1 символ.

Объединить вложенные в петли:

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

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

Пример с разными значениями для 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)

Юникод ярлыки

Если вы используете чертовски встроенную собственность на большом соревновании по гольфу, вы можете присвоить псевдониму каждую собственность эквиваленту одного символа:

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

После выполнения кода выше вы можете использовать его следующим образом:
"foo".Č(/.*/,'bar') // replaces foo with bar

Это стоит 118 байт, поэтому в некоторых ситуациях это может оказаться бесполезным.

Это может зависеть от браузера, и я не уверен, что он короче with(Array){join(foo),...}или определяет переменные как используемые свойства, with(Array){j=join,m=map...}но все же стоит упомянуть.

    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         

Преобразование whileцикла в forцикл часто эквивалентно:

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

Но вторая форма может иметь объединенную инициализацию переменной:

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

Обратите внимание, что вторая форма на один символ короче первой.

Исключение злоупотребляет

если строковые / символьные литералы запрещены, вы можете использовать блок try catch:

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

теперь strравняется"something"

если нужно больше строк, вы можете связать их числом (например, нулями)

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

теперь arrравняется["something", "foo", "bar", " is not defined"]

Если вы инициализируете переменную 1в каждой итерации цикла (например, сбрасываете переменную во внешнем цикле для внутреннего цикла), как показано ниже (из моего ответа на этот вопрос ):

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

Поскольку результатом условия like j++<=nявляется 1всякий раз, когда оно имеет значение true, вы можете просто назначить условие непосредственно переменной (поскольку, когда оно становится ложным, цикл прекращает выполнение и больше не имеет значения):

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

Обычно вы можете сохранить 2 символа, используя этот метод. С уважением к @ugorenидее в комментариях к этому ответу.

В качестве другого примера я также применил этот трюк к своему ответу здесь с выражением w=r=++c<S.lengthво внешнем цикле for, сохранив всего 4 символа.

Если вы можете принять специальные сценарии Spidermonkey (на данный момент), вы можете использовать функции стрелок ECMAScript 6 . Вместо написания кода, как показано ниже.

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

Вы можете сократить это, как это.

a.map(x=>x*2)

Если вам нужно проверить NaN, не используйте isNaN(x), но используйте x!=x, который короче и также работает.

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

Обратите внимание, что это работает только если typeof(x) === "number"; если это строка, например, isNaN("string")возвращает true, но "string" != "string"возвращает false. Спасибо Cyoce за указание на это!

Сумма массива / продукт / частное

ES5 : 17 байт

eval(a.join('+'))

ES6 : 15 байт

eval(a.join`+`)

Конечно, вы можете поменять их +на что угодно, например, *на продукт или /частное.

Используйте побитовую операцию, чтобы округлить число до нуля:

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

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

(Источник: Случайная игра в кости )

Приоритет оператора определяет, что будет короче в вашей программе.

Looping Tip I

Вы можете сохранить 1символ при зацикливании, изменив iна последний использованный:

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

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

Примечание: работает --также (но измените цикл соответственно, чтобы избежать бесконечного цикла)

Looping Tip II

Есть определенные сценарии, в которых вы можете сохранить один символ, играя с инкрементным оператором и значениями:

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

Примечание: нужно обратить внимание, когда, например 0 to -1. и 9 to 10, 99 to 100, так что поиграйте, пока не найдете способ сохранить персонажа

Использовать ^вместо !=или ==при сравнении с целым числом

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

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

Замените вызовы встроенных математических функций более короткими выражениями.

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

Стоит отметить, что в некоторых случаях вы можете использовать строку вместо нуля, чтобы сохранить несколько байтов здесь и там в циклах:

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

Очень простой, даже так, никто не упомянул об этом.

Если вы используете Math.min()или Math.max()можете сохранить 6 символов, сделав это:

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

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

округление

Я знаю, что альтернативы Math.floor()были опубликованы, но как насчет других?

Напольное покрытие:

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

Округление:

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

Потолок:

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

В тех случаях, когда вы используете троичный оператор для выбора между двумя числами , а условным условием является либо логическое значение, либо число 1 or 0 , вы можете вместо этого выполнять математические операции:

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

Примечание: В дополнение к этому, вам нужно будет удалить ненужные 0-, +0, и +-т.д.

Примечание 2: есть единичный случай, когда (x) !== (x?1:0), как это xдолжно быть, typeof === "number"для его работы. Однако в случае с (-x)этим все работает просто отлично.

Примечание 3: Если вы не нашли сбережения, просто используйте первый(x?y:z)

Ранее я думал, что метод B никогда не сможет победить A, однако существуют исключения:

(x?97:100) //original

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

Я создал проект GitHub, который делает упрощение для нас ( демонстрация jsFiddle )

tl; dr: использовать функции ES6!

Функции стрелок

Документ: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/arrow_functions
Пример:

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

Злоупотреблять литералами

Недавний пример: проверьте, "c"есть ли прописные или строчные буквы, не имеет значения, если не буква

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

Как сравнить число с помощью того, как числа превращаются в логические значения:

Если вы собираетесь проверить , если что - то равно положительное число , вы можете вычесть эту сумму и обратную , что было внутри ifи 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();
}

И в случае, если вы хотите сравнить с отрицательным числом (* отличным от -1), вам просто нужно добавить это число вместо вычитания.

* ну, вы, конечно, можете использовать x.indexOf(y) + 1, но в особом случае у -1вас есть возможность использовать ~x.indexOf(y)вместо этого.

Используйте нестандартную функцию «закрытия выражений» в Mozilla, чтобы сохранить множество символов в скрипте, который должен работать только в движках SpiderMonkey / Firefox или Rhino. Например,

function foo(){return bar}

становится

function foo()bar

См. Страницу переполнения стека для большего количества таких уловок.

Используйте if(~a.indexOf(b))вместоif(a.indexOf(b)!=-1)

Вместо написания trueвы можете использовать !0.

Преобразование в логическое значение :

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

Примечание: Это изменение 0, "", false, null, undefinedи NaNк false(все остальное true)