जावास्क्रिप्ट में गोल्फ के लिए युक्तियाँ

133

जावास्क्रिप्ट में गोल्फिंग के लिए आपके पास क्या सामान्य सुझाव हैं? मैं उन विचारों की तलाश कर रहा हूं, जिन्हें सामान्य रूप से गोल्फ समस्याओं को कोड करने के लिए लागू किया जा सकता है जो कि जावास्क्रिप्ट के लिए कम से कम कुछ हद तक विशिष्ट हैं (उदाहरण के लिए "टिप्पणियां हटाएं" एक उत्तर नहीं है)।

नोट: इसके अलावा ECMAScript 6 और इसके बाद के संस्करण में गोल्फ के लिए टिप्स देखें

code-golf  tips  javascript 
— mellamokb
स्रोत
मैं वास्तव में सोच रहा था, क्या यह वैश्विक (बचत var) में चर रखने की अनुमति है ? और जावास्क्रिप्ट गोल्फ कोड एक फ़ंक्शन या आउटपुट होना चाहिए सीधे कुछ? मैं ईमानदारी से सोचता हूं कि इससे बहुत फर्क पड़ सकता है।
— pimvdb
1
@primvdb: इसकी अनुमति है, लेकिन आपको सावधान रहना होगा क्योंकि यदि किसी फ़ंक्शन को कई बार कहा जाता है तो यह साइड-इफेक्ट्स का कारण बन सकता है और यह ग्लोबल वैरिएबल में हेरफेर कर रहा है, या यदि यह एक पुनरावर्ती फ़ंक्शन है।
— मेलामोकब
— इसियाह

जवाबों:

108

लूप्स के लिए फैंसी

आप गैर-मानक तरीकों से लूप के लिए मानक का उपयोग कर सकते हैं

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;

अर्धविराम से बचें

जावास्क्रिप्ट में स्वचालित अर्ध-बृहदान्त्र सम्मिलन है। इसे अक्सर और अच्छी तरह से उपयोग करें।

एक-लाइनर्स

एकल लाइनों, या मापदंडों में जितना संभव हो उतना कम करके कोष्ठक पर सहेजें:

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

-वसेस-

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

पहुंच की संख्या कई वस्तुओं को भी जोड़ सकती है। यदि आप .lengthअलग-अलग सरणियों पर 4 या अधिक बार पहुंचते हैं, तो आप स्ट्रिंग को पकड़े हुए एक ही चर का उपयोग कर सकते हैं 'length'।

— zzzzBov
स्रोत
5
c = ~~a-~~bहोना चाहिए c = ~~a+~~b। इसके अलावा, आप |0उदाहरण के लिए, पूर्णांक का उपयोग कर सकते हैं Math.random()*6|0।
— मेलमोकब
7
यह यूनरी प्लस ऑपरेटर के साथ एक स्ट्रिंग को एक संख्या तक ले जाने के लिए सस्ता है। यदि aऔर bतार हैं, तो आप +a+bसंख्या में परिवर्तित करने और उन्हें जोड़ने के लिए कर सकते हैं।
— पीटर ओल्सन
8
मैं कसम खाता हूँ कि मैं d- -bकिसी दिन अपने कोड में उपयोग करने जा रहा हूँ ...
— John Dvorak
4
+ a + b काम नहीं करता (कम से कम मेरा ...) // a = "1", b = "1", + a + b // "11" देता है
— imma
2
यदि आप एक ही ऑब्जेक्ट पर दो बार से अधिक फ़ंक्शन का उपयोग कर रहे हैं, तो "रिपीट फ़ंक्शन कॉल के लिए एरे-एक्सेस का उपयोग करें" के लिए, फ़ंक्शन को नए सदस्य को सौंपने के लिए थोड़ा कम है जैसेa.f=a.longfunctionname;a.f(b);a.f(c);a.f(d)
— मार्टिन एंडर
131

उद्धरण चिह्नों को सहेजने के लिए संख्याओं के साथ विभाजन:

"alpha,bravo,charlie".split(",") // before
"alpha0bravo0charlie".split(0)   // after
— ajax333221
स्रोत
2
यह काम करता है, और मैंने इसे कई अंकों के लिए उपयोग किया है।
— इशीआ मीडोज
12
योग्य यह वास्तव में बहुत रचनात्मक है
— NiCk न्यूमैन
9
ES6 में इससे कोई फर्क नहीं पड़ता, आप बस कर सकते हैं.split`...`
— डेविड आर्किबाल्ड
"alpha,bravo,charlie".split`,`
— कामिल Kiełczewski
56

ब्रेस से बचने के लिए अल्पविराम ऑपरेटर का उपयोग करें ( सी पर भी लागू होता है ):

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

के बजाय

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

जो एक वर्ण लंबा है।

— mellamokb
स्रोत
2
क्या पहले नमूने के अंत में अर्धविराम आवश्यक है?
— wjl
4
@wjlafrance: यह केवल एक-लाइनर के अंत में आवश्यक नहीं होगा।
— मेलमोकब
48

छोटे यादृच्छिक संख्या पीढ़ी

यदि आपको एक यादृच्छिक बूलियन ( 0या 1) चाहिए:

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

यदि आपको एक यादृच्छिक पूर्णांक चाहिए 0 <= n < 1337:

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

यह काम करता है क्योंकि एक Dateयुग में मिलीसेकंड की मात्रा के रूप में जावास्क्रिप्ट में आंतरिक रूप से संग्रहीत किया जाता है, इसलिए जब आप इस पर पूर्णांक गणित करने की कोशिश new Dateकरते हैं , तो इसमें जोर दिया 123somebignumber456जाता है।

बेशक, ये "यादृच्छिक" नंबर वास्तव में यादृच्छिक नहीं होंगे, खासकर यदि आप उन्हें त्वरित उत्तराधिकार में कई बार कॉल करते हैं, तो ध्यान रखें।

— Doorknob
स्रोत
1
पढ़ने के दौरान इस उत्तर को याद रखें अधिक झूठ बोलने वाले प्रोग्रामर समय के बारे में विश्वास करते हैं : “21। यदि आप एक दूसरे के बगल में दो तारीख ऑब्जेक्ट बनाते हैं, तो वे उसी समय का प्रतिनिधित्व करेंगे। (एक शानदार हाइजेनबग जनरेटर) ” ।
— सेबेस्टियन साइमन
39

आप कीवर्ड का उपयोग करने से बचने के लिए प्राप्त / सेट के ऑब्जेक्ट शाब्दिक रूप का उपयोग कर सकते हैं 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)
गेट्टर / सेटर भाग वास्तव में सहायक था। thx
— gion_13
1
वास्तव में, इससे भी बेहतर एक वस्तु विधि है, यदि आप केवल इसका उपयोग करते हैं <= 2 बार। दूसरी ओर, एरो फ़ंक्शंस पात्रों को काटने में बहुत बेहतर होते हैं, क्योंकि वे लगभग एक ही उद्देश्य से काम करते हैं, और गोल्फ कोड में कक्षाएं शायद ही कभी उपयोगी होती हैं।
— इसियाह
यदि समर्थन महत्वपूर्ण है तो एफ़एक्स फ़ंक्शन एफएक्स में समर्थित नहीं हैं। ie11
— जिम वोल्फ
35

यह कम ज्ञात और कम इस्तेमाल किया जाता है, लेकिन अगर सही स्थिति में उपयोग किया जाता है तो यह प्रभावशाली हो सकता है। एक ऐसे फ़ंक्शन पर विचार करें जो कोई तर्क नहीं लेता है और हमेशा कॉल किए जाने पर एक अलग संख्या लौटाता है, और लौटे नंबर का उपयोग गणना में किया जाएगा:

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];
— एंडी ई
स्रोत
8
या, आप इसे इनमें से किसी भी तरह कर सकते हैं: let a=[5,6,7,8,9,10,11,12].map(x=>x*Math.random()|0)या let a=Array(7).map((_,i)=>i*Math.random()|0+5), क्रमशः 36 या 42 बाइट्स सहेजे गए।
— इशीया मीडोज
क्या इसे बदलना r()या कम करना संभव है ?
— NiCk न्यूमैन
3
r={valueOf:Math.random}यह सिर्फ प्रतिभा है: D
— ETHproductions
1
@ इस्याह, ठीक है, अब आप ऐसा कर सकते हैं :
— एंडी ई
32

शॉर्ट-सर्किट ऑपरेटरों का लाभ उठाते हुए

लंबे 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। हालांकि, यह कुछ परिस्थितियों में उपयोगी हो सकता है।

— एंडी ई
स्रोत
6
एरे का उपयोग करते हुए दोहराए जाने वाले तार बनाने के लिए - उस बारे में नहीं सोचा था।
— मेलमोकब
4
दोहराए जाने वाले तार बनाने के लिए, ES6 में आप उपयोग कर सकते हैंstr.repeat(count)
— उड़ोल
26

उपयोगकर्ता इनपुट प्राप्त करने के लिए प्रॉम्प्ट () कॉल में चर चर आरंभ

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

के बजाय का उपयोग करने का

n=prompt();i=5;

साइड-इफ़ेक्ट के रूप में, यह 1 कैरेक्टर को सेव करते हुए प्रॉम्प्ट विंडो में इनपुट वैल्यू को प्रदर्शित करता है।

— mellamokb
स्रोत
12
यह किसी भी फ़ंक्शन के लिए भी लागू किया जा सकता है जो तर्क स्वीकार नहीं करता है।
— केसी चू
3
यहां तक ​​कि जब फ़ंक्शन तर्कों को स्वीकार करता है तो यह उपयोगी हो सकता है, जैसे कि [1,2,3].join('',i=5)उन मामलों में जहां यह ब्रेसिज़ की एक जोड़ी को बचाता है।
— डॉकमैक्स
3
@ डॉकमैक्स: आप इसके लिए अल्पविराम ऑपरेटर का उपयोग कर सकते हैं - i=5,[1,2,3].join()।
— कोनराड बोरोस्की
@GlitchMr: मैं कर सकता था, लेकिन यह किसी भी पात्र को नहीं बचाता है। मैं सहमत हूं कि अधिकांश समय क्लीनर होगा। मुझे लगता है कि अभी भी ऐसे मामले हो सकते हैं, जहां मेरे आदेश से एक चार को बचाया जा सकता है, हालांकि मैं इस समय एक के साथ नहीं आ सकता (और मैं अच्छी तरह से गलत हो सकता हूं)।
— डॉकमैक्स
@ डॉकमैक्स केवल अगर आप एएसआई का लाभ ले रहे हैं।
— ईशाय मीडोज
24

छोरों के लिए संयुक्त नेस्ट:

// 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)
— केए वेरेंस
स्रोत
(मैंने संपादित किया है) मामूली टाइपो, लेकिन बहुत चालाक! ध्यान दें कि यह केवल एक ही लंबाई के नेस्टेड छोरों पर काम करेगा (जब तक कि मैं गलत नहीं हूं)।
— कैमिलो मार्टिन
1
@CamiloMartin नहीं, छोरों को समान लंबाई की होने की आवश्यकता नहीं है। पुनरावृत्तियों की जिसके परिणामस्वरूप संख्या है i*jऔर विभाजन / मापांक ऑपरेटरों की व्यक्तिगत मूल्यों को पुनः प्राप्त iऔर j।
— शांत मन
@ user113215 तुम सही हो, कमाल! :) मैंने एक उदाहरण शामिल करने के लिए उत्तर संपादित किया है।
— कैमिलो मार्टिन
23

यूनिकोड शॉर्टकट

यदि आप एक बड़ी गोल्फ की चुनौती में एक अंतर्निहित संपत्ति के नरक का उपयोग करते हैं, तो आप प्रत्येक संपत्ति को एक वर्ण के बराबर कर सकते हैं:

[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
— Bebe
स्रोत
मैं Google क्रोम का उपयोग कर रहा हूं, और ये सभी अपरिभाषित दे रहे हैं।
— सुपरजेडी २२४
यह तो बहुत फ़ायरफ़ॉक्स विशिष्ट होना चाहिए। असुविधा के लिए खेद है।
— बेबे
ये सभी विशेष पात्र क्यों हैं? सिर्फ मुद्रण योग्य ASCII का उपयोग क्यों न करें? (टाइप करने में आसान, अधिक विश्वसनीय, और गोल्फ के लिए केवल 1 बाइट)
— 20
यह वास्तव में काम नहीं करता है Mathक्योंकि इसमें कोई .prototypeविशेषता नहीं है । Mathहालाँकि, मैं इसे ११४ बाइट के स्निपेट में शामिल करने में कामयाब रहा , जो इन सभी को सिंगल-बाइट लेटर्स को असाइन करता है। आप इसे यहाँ पा सकते हैं ।
— ETHproductions
1
आप इन सभी संपत्तियों को सीमा तक ले जाने की कीमत पर 106 बाइट्स के लिए मेरे समाधान को भी गोल्फ कर सकते हैं À- ÿजो अभी भी आईएसओ-8859-1 एन्कोडिंग में प्रत्येक 1 बाइट है (जो जेएस समर्थन करता है)। फ़ायरफ़ॉक्स 50 में, यह दुर्भाग्य से .localeCompareविधि डालता है ×, लेकिन यह आमतौर पर एक मुद्दा नहीं होना चाहिए। स्रोत
— ETHproductions 21
22

whileलूप को एक लूप में forबदलना अक्सर समतुल्य होता है:

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

लेकिन दूसरे फॉर्म में वैरिएबल इनिशियलाइज़ेशन हो सकता है:

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

ध्यान दें कि दूसरा रूप पहले रूप से छोटा एक वर्ण है।

— mellamokb
स्रोत
6
या, और भी बेहतर, बस छोरों के लिए उपयोग करें। वास्तव में ऐसा कोई मामला नहीं है जहां लूप के लिए बड़े कोड का उपयोग किया जाए, जहां तक ​​मैंने अनुभव किया है।
— ईशाय मीडोज
22

अपवाद गाली देना

यदि स्ट्रिंग / वर्ण लिटरल निषिद्ध हैं, तो आप एक ट्रायल कैच ब्लॉक का उपयोग कर सकते हैं:

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

— Bebe
स्रोत
18

यदि आप 1लूप के प्रत्येक पुनरावृत्ति में एक वैरिएबल को प्रारंभ कर रहे हैं (उदाहरण के लिए, एक आंतरिक लूप के लिए एक बाहरी लूप में एक चर को रीसेट करना), तो निम्न की तरह ( इस प्रश्न के उत्तर से ):

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

की तरह एक शर्त के परिणाम के बाद से j++<=nहै 1जब भी अपने असली, तुम बस शर्त सीधे चर करने के लिए दे सकते हैं (क्योंकि जब यह गलत हो जाता है, पाश नहीं करेगी बात को क्रियान्वित बंद करो और होगा):

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 में लूप के लिए अपने बाहरी में अभिव्यक्ति के साथ लागू किया , कुल 4 वर्णों को सहेजा।

— mellamokb
स्रोत
18

यदि आप Spidermonkey (अभी के लिए) विशिष्ट स्क्रिप्ट स्वीकार कर सकते हैं, तो आप ECMAScript 6 एरो फ़ंक्शंस का उपयोग कर सकते हैं । निम्नलिखित की तरह लेखन कोड का प्रसार।

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

आप इसे इस तरह से छोटा कर सकते हैं।

a.map(x=>x*2)
— कोनराड बोरोस्की
स्रोत
17

अगर आपको NaN की जांच करने की आवश्यकता है, तो उपयोग न करें isNaN(x), लेकिन उपयोग करें x!=x, जो छोटा है और काम भी करता है।

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

ध्यान दें कि यह केवल अगर काम करता है typeof(x) === "number"; यदि यह उदाहरण के लिए एक स्ट्रिंग है, isNaN("string")रिटर्न true, लेकिन "string" != "string"रिटर्न false। यह इंगित करने के लिए साइओस को धन्यवाद!

— ProgramFOX
स्रोत
2
कि इस quirk का एक प्रतिभाशाली उपयोग है। +1
— ETHproductions
चेतावनी: ये हमेशा समतुल्य नहीं होते हैं: isNaN("string")रिटर्न true, जबकि "string"!="string"रिटर्न false(जाहिर है)
— Cycece
@Cyoce अच्छा बिंदु, धन्यवाद! मैंने अपना उत्तर संपादित किया।
— प्रोग्रामफॉक्स
कई मामलों में, आप यहां तक ​​जा सकते हैं if(!x){, यदि आप NaNस्पष्ट रूप से पता लगा रहे हैं ।
— होहमनफैन
1
xसंख्या के लिए कास्टिंग +x!=+x, इसे इसके बराबर बनाता है isNaN(x), फिर भी 2 अक्षर छोटे हैं। फिर, +"string"!=+"string"सच लौटाता है।
— टॉमस लैंगकास
15

एरियर राशि / उत्पाद / भागफल

ES5 : 17 बाइट्स

eval(a.join('+'))

ES6 : 15 बाइट्स

eval(a.join`+`)

बेशक +, आप किसी भी चीज़ के लिए स्वैप कर सकते हैं, जैसे, *उत्पाद के लिए या /भागफल के लिए।

— जॉर्ज रीथ
स्रोत
14

किसी नंबर को शून्य की ओर गोल करने के लिए एक बिटवाइज़ ऑपरेशन का उपयोग करें:

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

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

(स्रोत: रैंडम पासा टिपिंग )

ऑपरेटर पूर्वता निर्धारित करता है जो आपके कार्यक्रम में कम होगा।

— कृपया उठो
स्रोत
2
यह भी एक पूर्णांक में एक स्ट्रिंग इनपुट coalesce करने के लिए इस्तेमाल किया जा सकता है, यानी n=prompt()|0।
— मेलामोकब
1
बिटवाइज भी गणित की तुलना में सुपर फास्ट है। फ़्लोर: jsperf.com/floor-vs-bitwise
— vsync
@vsync: अजीब। मुझे math.floor Chrome 11.0.696.77 पर बिटवाइज़ के रूप में दोगुना तेज़ होने के लिए मिलता है।
— मेलमोकब
बहुत अजीब। मेरे लिए वे क्रोम में कम या ज्यादा समान गति और सुपर फास्ट हैं, लेकिन FF में क्रोम की तुलना में बिटवाइज़ बहुत तेज़ है, और Math.floorबहुत धीमी गति से है..ज्यादा नहीं उपयोग किया जाना चाहिए।
— vsync
वर्तमान एफएक्स में टिप्पणियों को अप-टू-डेट रखने के लिए, वे दोनों तेज और समान हैं। ऐसा नहीं है कि यह आसपास के कोड की तुलना में पहली जगह में अड़चन होने की संभावना है ...
— FireFly
14

लूपिंग टिप I

उपयोग किए गए अंतिम समय में 1बदलकर लूपिंग करने iपर आप चरित्र को बचा सकते हैं :

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

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

नोट:-- भी काम करता है (लेकिन अनंत लूपिंग से बचने के लिए लूप को संशोधित करें)

लूपिंग टिप II

ऐसे कुछ परिदृश्य हैं, जहां आप बढ़ रहे ऑपरेटर और मूल्यों के साथ खेलकर एक चरित्र को बचा सकते हैं:

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

नोट: उदाहरण के लिए आपको ध्यान देने की आवश्यकता है 0 to -1। और 9 to 10, 99 to 100, जब तक आप चरित्र को बचाने का एक तरीका नहीं ढूंढ लेते, तब तक खेलते रहें

— ajax333221
स्रोत
13

पूर्णांक की तुलना करते समय या ^इसके बजाय का उपयोग करें!===

//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
— टॉमस लैंगकास
स्रोत
2
वैकल्पिक रूप से, आप केवल पूर्णांकों के -बजाय उपयोग कर सकते !=हैं; उदाहरण के लिए, के n!=1?a:bबराबर होगाn-1?a:b
— vrugtehagel
10

कुछ ध्यान देने योग्य बात यह है कि आप कुछ बाइट्स में शून्य के स्थान पर एक स्ट्रिंग का उपयोग यहां और वहां लूप में कुछ बाइट्स को बचाने के लिए कर सकते हैं:

s='';for(i=0;i++<9;)s+=i
for(i=s='';i++<9;)s+=i
// s="123456789", i=10
— डोम हेस्टिंग्स
स्रोत
1
मैंने पहले कंसोल में "" कोशिश की कि क्या यह काम करेगा, निश्चित रूप से यह पहले एक चर में होना चाहिए। धन्यवाद!
— वर्तन
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
— एंटोनियो अल्मेडा
स्रोत
10

गोलाई

मुझे पता है कि विकल्प 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
ध्यान दें कि 0|x+1यदि आप जिस छत को ढूंढना चाहते हैं, वह केवल 1 को जोड़ता है, तो पहले से ही पूर्णांक है। ए (ज्यादातर) सुरक्षित विकल्प है 0|x+1-1e9, लेकिन यह केवल तीन बाइट्स छोटा है।
— ETHproductions
@ETHproductions क्या आपका मतलब यह नहीं है 0|x+1-1e-9?
— मामा फन रोल
उफ़, हाँ। यह बात बताने के लिए धन्यवाद। (किसी कारण से, मैं @ (आपका उपयोगकर्ता नाम) नहीं कर सकता ...)
— ETHproductions
शायद इसलिए कि मेरे उपयोगकर्ता नाम चार्ट उलटे हैं :)
— मामा फन रोल
1
छत के लिए, x%1?-~x:x(9 अक्षर) एक बेहतर विकल्प है। हालांकि, फर्श विकल्प की तरह 0|xऔर ~~x, यह केवल सकारात्मक संख्याओं के लिए काम करता है।
— टॉमस लैंगकास
9

उन मामलों में जहां आप दो नंबर के बीच चुने जाने के लिए टर्नरी ऑपरेटर का उपयोग कर रहे हैं , और सशर्त या तो एक बूलियन या संख्या है 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)

पहले मैंने सोचा था कि बी कभी ए को हरा नहीं सकता है, हालांकि अपवाद मौजूद हैं:

(x?97:100) //original

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

मैंने एक github प्रोजेक्ट बनाया, जो हमारे लिए सरलीकरण करता है ( jsFiddle डेमो )

— mellamokb
स्रोत
@ ajax333221 void 0(यह एक फ़ंक्शन नहीं है, लेकिन एक कीवर्ड है) एक मूल्य नहीं है, यह केवल रिटर्न करता है undefined।
— कैमिलो मार्टिन 12
@CamiloMartin आप सही हैं, मैं भी अब इस उत्तर में बिंदु देख रहा हूं, हालांकि aकाम करने के लिए 1 या 0 होना चाहिए
— ajax333221
@ ajax333221 हां, वास्तव में मेरे लिए कोड गोल्फिंग के बारे में मजेदार बात यह है कि सबसे अच्छी चालें केवल उस विशेष चीज के लिए काम करती हैं जो आप कर रहे हैं, और एक कोने के समाधान के साथ इन मामलों में से एक को खोजने के लिए बहुत चालाक लगता है: डी बाय। इस तरह, आपको टिप्पणियों को हटाने की आवश्यकता नहीं है ...
— कैमिलो मार्टिन
9

tl; डॉ: ES6 सुविधाओं का उपयोग करें!

तीर कार्य

डॉक्टर: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/arrow_functions
उदाहरण:

s = x => x*x
// s = function (x) {
//   return x * x;
// }
— फ्लोरेंट
स्रोत
तीर कार्यों का उल्लेख पहले से ही 13 अक्टूबर 13 को 15:42 बजे किया गया था । पर वो for.. ofमस्त है। यहां तक कि तुलना में कम for each.. in।
— मैनटवर्क
2
सरणी बोध वाक्यविन्यास गलत प्रतीत होता है। प्रलेखन के अनुसार अजगर में जैसा होना चाहिए b = [s(x) for (x of a)]:।
— मैनटवर्क
@manatwork उपरोक्त नमूने Traceur के REPL
— Florent
ट्रेसुर के बारे में कोई विचार नहीं है, लेकिन आपने ईसीएमएस्क्रिप्ट का उल्लेख किया और मोज़िला प्रलेखन की ओर इशारा किया। और सरणी समझ उनमें से किसी में भी नहीं लगती है जैसे आपने इसे लिखा था।
— मैनटवर्क
1
एरियर की समझ वास्तव में बीच में खींची गई थी।
— इशायाह मीडोज
9

गाली देना शाब्दिक

हालिया नमूना: चेक करें कि क्या "c"अपरकेस या लोअरकेस है, कोई पत्र नहीं होने पर कोई फर्क नहीं पड़ता

"c"<{} // returns false, lower case
"C"<{} // returns true, upper case
— l4m2
स्रोत
3
यह कैसे काम करता है?
— गायों ने
2
@Cowsquack String({}) देता है "[object Object]"।
— डेनिस
8

संख्याओं की तुलना बूलियन्स में कैसे करें, इसकी मदद से संख्या की तुलना कैसे करें:

यदि आप जांचने जा रहे हैं कि क्या कुछ सकारात्मक संख्या के बराबर है , तो आप उस राशि को घटा सकते हैं और जो अंदर 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)।

— ajax333221
स्रोत
8

एक स्क्रिप्ट में कई पात्रों को बचाने के लिए मोज़िला की गैर-मानक "अभिव्यक्ति क्लोजर क्लोजर" सुविधा का उपयोग करें, जिसे केवल स्पाइडरमंकी / फ़ायरफ़ॉक्स या राइनो इंजन में काम करने की आवश्यकता है। उदाहरण के लिए,

function foo(){return bar}

हो जाता है

function foo()bar

इस तरह के और ट्रिक्स के लिए स्टैक ओवरफ्लो पेज देखें ।

— कृपया उठो
स्रोत
2
यह जावास्क्रिप्ट नहीं है। यह एक अंतरिक्ष स्टेशन है !!!
— थॉमस एडिंग
1
बचाव के लिए ECMAScript 6! ->bar
— Ry-
5
ECMAScript 6:, let foo = () => bar;ऊपर दिए गए गोल्फ कोड से विडंबना की तुलना में कम है।
— ईशाय मीडोज
1
ECMAScript 6:, foo=_=>barऔर भी छोटा।
— ETHproductions
वह लिंक टूट गया है।
— Cycece
8

लिखने के बजाय trueआप उपयोग कर सकते हैं !0।

— वोले वनीलेब्रेट लुत्ज़
स्रोत
4
इसी तरह, के !1लिए false।
— जेम्स एम। ले।
10
अभी तक बेहतर, का उपयोग 1करने के लिए trueऔर 0के लिए false, जब तक आप वास्तव में शाब्दिक मूल्यों की जरूरत है।
— ETHproductions
8

एक बूलियन में बदलना :

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

नोट: यह बदलता है 0, "", false, null, undefinedऔर NaNकरने के लिए false(करने के लिए सब कुछ true)

— ajax333221
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.