जैद श्मिट, थॉमस फुच्स और डस्टिन डियाज़ - जो लोग जावास्क्रिप्ट समुदाय में काफी प्रसिद्ध हैं, उन्हें हाल ही में एक नया मनोरंजन मिला - उपयोगी बातें जो एक ट्वीट से बड़ी नहीं हैं, अर्थात् 140 बाइट्स। उन्होंने एक डोमेन भी पंजीकृत किया है - 140byt.es , जहां सभी को सुपर-कॉम्पैक्ट फ़ंक्शन लिखने में अपना हाथ आजमाने के लिए आमंत्रित किया गया है।

स्वाभाविक रूप से, स्रोत के आकार को कम करने के लिए सभी सबसे परिष्कृत तरीकों और तकनीकों का उपयोग किया जाता है। उनके पास युक्तियों के साथ एक विकी पृष्ठ है, जिसे मैंने अनुवाद करने का निर्णय लिया है।

मुझे तुरंत यह कहना होगा कि इस तरह से संसाधित कोड की पठनीयता शून्य हो जाती है, इसलिए यह केवल उन मामलों में इन ट्रिक का उपयोग करने के लायक है जब आकार वास्तव में सबसे ऊपर है। उदाहरण के लिए, JS1k प्रतियोगिता में भाग लेते समय।

So.

तर्क

वर्णमाला क्रम में एकल-अक्षर स्थिति संबंधी तर्कों का उपयोग करें

चूंकि फ़ंक्शन तर्क संभव के रूप में कम होने चाहिए, और सबसे अधिक संभावना है कि रन टाइम पर कई बार उपयोग किया जाता है, उन्हें स्थिति के संदर्भ में विचार करना और उन्हें वर्णमाला क्रम में नाम देना आसान है, बजाय उन्हें कोई सार्थक नाम देने के।

function(t,d,v,i,f){...} //  function(a,b,c,d,e){...} //  

लंबाई के बजाय तर्कों की जाँच करें

आप एक तर्क के लिए जाँच करने के लिए उपयोग कर सकते हैं।

 arguments.length>1||(cb=alert) //  1 in arguments||(cb=alert) //  

चर

var बजाय "अतिरिक्त" तर्क का उपयोग करें

आप var साथ एक चर घोषित करने के बजाय फ़ंक्शन में एक अतिरिक्त तर्क निर्दिष्ट करके कुछ बाइट्स बचा सकते हैं:

 function(a){var b=1;...} //  function(a,b){b=1;...} //  

कई बार चर का उपयोग करें

 setTimeout(function(){for(var i=10;i--;)... }, a) //  setTimeout(function(){for(a=10;a--;)... }, a) //  

जहाँ संभव हो वहाँ असाइनमेंट का उपयोग करें

चूंकि असाइनमेंट ऑपरेटर असाइन किया गया मान लौटाता है, आप एक ही समय में असाइनमेंट और सत्यापन का उपयोग कर सकते हैं:

 a=this.localStorage;if(a){...} //  if(a=this.localStorage){...} //  

चर को स्वैप करने के लिए एक सरणी का उपयोग करें

सरणी का उपयोग अस्थायी भंडारण के रूप में किया जा सकता है, ताकि अतिरिक्त चर घोषित न किया जा सके।

 var a=1,b=2,c;c=a;a=b;b=c //  var a=1,b=2;a=[b,b=a][0] //  

जोड़ते समय कास्टिंग का उपयोग करें

जेएस में टाइप रूपांतरण बहुत ही अजीब काम करता है और बग के सबसे आम स्रोत में से एक है। हालांकि, कोड आकार को कम करने के लिए इसका उपयोग विभिन्न दिलचस्प तरीकों से किया जा सकता है।
उदाहरण के लिए, एक पबसब कार्यान्वयन में , जेड श्मिट ने एक नकारात्मक संख्या के साथ एक चर को घटाया, और फिर इसे स्ट्रिंग में जोड़ दिया, "somestring-123" जैसा कुछ।
उसके बाद, मैंने स्रोत स्ट्रिंग प्राप्त करने के लिए .split('-') कहीं और किया।

चक्र

लूप के शरीर को कम करें

अक्सर, आप शर्तों के अंदर सभी तर्क को लागू कर सकते हैं और चक्र के शरीर पर बचा सकते हैं।
इस दृष्टिकोण का एक अच्छा उदाहरण टाइमएगो फ़ंक्शन में देखा जा सकता है।

जबकि इसके बजाय का उपयोग करें

for और while आम तौर पर बाइट्स की एक ही राशि लेते हैं, लेकिन अधिक नियंत्रण और अधिक असाइनमेंट संभावनाओं के for अनुमति देता है।

 while(i--){...} //  for(;i--;){...} //  i=10;while(i--){...} //  for(i=10;i--;){...} //  

"सत्य" सरणियों पर तेज़ पुनरावृत्ति का उपयोग करें

यदि आपके पास एक ऐसा सरणी है जिसके सदस्य सभी सच होने के लिए जाने जाते हैं, तो आप एक छोटे लूप प्रविष्टि का उपयोग कर सकते हैं:

 for(a=[1,2,3,4,5],l=a.length,i=0;i<l;i++){b=a[i];...} //  for(a=[1,2,3,4,5],i=0;b=a[i++];){...} //  

ऑब्जेक्ट कुंजियों को प्राप्त करने के लिए असाइनमेंट के साथ for..in उपयोग करें

 a=[];for(b in window)a.push(window[b]) //  a=[];i=0;for(a[i++]in window); //  

ऑपरेटरों

ऑपरेटर प्राथमिकता जानें

यह ज्ञान कोष्ठक पर बहुत कुछ बचाने में मदद कर सकता है।
आप मोज़िला वेबसाइट पर इस लेख को खोजकर शुरू कर सकते हैं।

~ C indexOf उपयोग करें

 hasAnF="This sentence has an f.".indexOf("f")>=0 //  hasAnF=~"This sentence has an f.".indexOf("f") //  

ब्लॉक के बजाय क्रमिक रूप से कथनों को निष्पादित करने के लिए अल्पविराम का उपयोग करें

 with(document){open();write("hello");close()} //  with(document)open(),write("hello"),close() //  

undefined लिखने के लिए छोटे तरीकों का उपयोग करें

undefined बजाय undefined आप []._ या void 0 उपयोग कर सकते हैं।
""._ , 1.._ और [][0] , लेकिन वे बहुत धीमे हैं ।

ऑपरेटरों से पहले वैकल्पिक स्थान निकालें

कभी-कभी ऑपरेटरों द्वारा दर्द रहित स्थान को हटाया जा सकता है।

 typeof [] //  typeof[] //  

संख्या

उपयोग ~~ या 0| Math.floor बजाय

 rand10=Math.floor(Math.random()*10) //  rand10=0|Math.random()*10 //  

बड़े गोल संख्या के लिए घातीय प्रारूप का उपयोग करें

 million=1000000 //  million=1e6 //  

बड़े बाइनरी नंबर के लिए बिट शिफ्ट का उपयोग करें

 color=0x100000 //  color=1<<20 //  

Infinity बजाय 1/0 उपयोग करें

यह छोटा है। इसके अलावा, शून्य से विभाजित करना हमेशा मजेदार होता है।

 [Infinity,-Infinity] //  [1/0,-1/0] //  

शून्य के मिथ्यात्व का उपयोग करें

संख्याओं की तुलना करने के बजाय, मूल्य को शून्य से कम करने और इसकी सच्चाई की जांच करने के लिए कभी-कभी इसे कम किया जाता है।

 a==1||console.log("not one") //  ~-a&&console.log("not one") //  

किसी भी मान को एक से बदलने के लिए ~ का उपयोग करें

यूनी माइनस के साथ संयोजन में, यह संभव बनाता है, उदाहरण के लिए, किसी भी चर को बढ़ाने के लिए जो अभी तक परिभाषित नहीं किया गया है।

 // i = undefined i=i||0;i++ //  i=-~i //  

पंक्तियां

शून्य के साथ रेखाएं तोड़ें

यदि आप शून्य को सीमांकक के रूप में उपयोग करते हैं, तो split विधि का उपयोग करके तारों को split करते समय आप दो बाइट्स बचा सकते हैं:

 'alpha,bravo,charlie'.split(',') //  'alpha0bravo0charlie'.split(0) //  

ब्राउज़र विधि link उपयोग करें

ब्राउज़रों की पंक्तियों में एक तथाकथित-प्रसिद्ध link पद्धति है जो HTML लिंक बनाती है।

 html="<a href='"+url+"'>"+text+"</a>" //  html=text.link(url) //  

लाइनों के माध्यम से पुनरावृति करने के लिए replace और exec तरीकों का उपयोग करें

ये विधियाँ आपको एक फ़ंक्शन को दूसरे तर्क के रूप में पारित करने की अनुमति देती हैं। यह लाइन पर सुविधाजनक पुनरावृत्ति के लिए इस्तेमाल किया जा सकता है।
उपयोग के उदाहरण: टेम्प्लेट और यूयूआईडी ।

सरल तार बनाने के लिए सरणियों का उपयोग करें।

 for(a="",i=32;i--;)a+=0 //  a=Array(33).join(0) //  

नियमित अभिव्यक्ति

नियमित अभिव्यक्तियों को छोटा करने के लिए {n} का उपयोग करें। उदाहरण के लिए /\d{3}/ बजाय /\d\d\d/ । और इसके विपरीत /\d\d/ बजाय /\d{2}/ ।

आप नियमित निर्माणकर्ता के बजाय eval उपयोग कर सकते हैं:

 r=new RegExp("{"+p+"}","g") //  r=eval("/{"+p+"}/g") //  

बूलियन

का उपयोग करें ! true और false बनाने के लिए संख्याओं के साथ।

 [true,false] //  [!0,!1] //  

कार्यों

छोरों के बजाय पुनरावृत्ति के लिए नामित कार्यों का उपयोग करें

यह अक्सर छोटा होता है, क्योंकि यह आपको अनावश्यक चर के बिना, स्टैक के माध्यम से मूल्यों को खींचने की अनुमति देता है।
एक उदाहरण के रूप में, चल समारोह।

राज्य को संग्रहीत करने के लिए नामित कार्यों का उपयोग करें

यदि आपको फ़ंक्शन कॉल के बीच राज्य को संग्रहीत करने की आवश्यकता है, तो आप फ़ंक्शन को ऑब्जेक्ट के रूप में उपयोग कर सकते हैं और इसके गुणों में डेटा संग्रहीत कर सकते हैं:

 function(i){return function(){console.log("called "+(++i)+" times")}}(0) //  (function a(){console.log("called "+(ai=-~ai)+" times")}) //  0,function a(){console.log("called "+(ai=-~ai)+" times")} //   

तर्क के बिना कंस्ट्रक्टर को कॉल करते समय ओमेट ब्रैकेट्स

 now = +new Date() //  now = +new Date //  

जहाँ संभव हो नए कीवर्ड को छोड़ें

कुछ डिजाइनरों को new कीवर्ड का उपयोग करने की आवश्यकता नहीं है।

 r=new Regexp(".",g) //  r=Regexp(".",g) //  l=new Function("x","console.log(x)") //  l=Function("x","console.log(x)") //  

वापसी का बयान

जब आपको चर के अलावा कुछ और वापस करने की आवश्यकता होती है, तो return बाद एक जगह डालना आवश्यक नहीं है।

 return ['foo',42,'bar']; //  return['foo',42,'bar']; //  return {x:42,y:417}; //  return{x:42,y:417}; //  return .01; //  return.01; //  

अभी के लिए बस इतना ही।

सामान्य तौर पर, मेरा सुझाव है कि आप अपने काम के फल से खुद को परिचित करें। जटिल चीजों को 140 बाइट्स में फिट करने के प्रयास में, लोग कभी-कभी सिर्फ काम करते हैं। मुझे लगता है कि एक अनुभवी प्रोग्रामर भी अपने कोड में कुछ नया और दिलचस्प पाएंगे।