Sweet.js: जावास्क्रिप्ट सिंटैक्स एक्सटेंशन

आइए Sweet.js को देखने का प्रयास करें, एक कंपाइलर जो जावास्क्रिप्ट के लिए स्वच्छता मैक्रोज़ को लागू करता है।

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

Sweet.js अपने स्वयं के सिंटैक्स ट्री प्रारूप के साथ, लगभग टोकन स्तर पर, न्यूनतम संरचना के साथ संचालित होता है। एक तरफ, यह आपके मैक्रोज़ के लिए काफी विदेशी वाक्यविन्यास को परिभाषित करना संभव बनाता है, दूसरी ओर, यह मैक्रोज़ को थोड़ा अधिक जटिल बनाता है, जैसे कि वे मानक एएसटी जावास्क्रिप्ट पर परिभाषित किए गए थे।



चलो सबसे सरल उदाहरण से शुरू करते हैं, लेकिन सबसे पहले आपको Sweet.js स्थापित करना होगा:

npm install --global sweet.js 

उसके बाद, sjs उपयोगिता उपलब्ध होनी चाहिए। आइए एक मैक्रो लिखें जो दो चर के मूल्यों को स्वैप करेगा, निम्नलिखित कोड को swap.sjs फ़ाइल में swap.sjs :

 macro swap { rule { $x , $y } => { var tmp = $x; $x = $y; $y = tmp } } var x = 11; var y = 12; swap x, y; swap y, x; 

अब, ES5 संगत जावास्क्रिप्ट कोड प्राप्त करने के लिए, हमें बस इसे sjs -r ./swap.sjs को "फीड" करना होगा।

 var x = 11; var y = 12; var tmp = x; x = y; y = tmp; var tmp$2 = y; y = x; x = tmp$2; 

ध्यान देने योग्य बात यह है कि मैक्रो का विस्तार करते समय Sweet.js ने वैरिएबल नाम उत्पन्न किए, इस प्रकार एक नाम संघर्ष की संभावना को समाप्त कर दिया। इसका मतलब है कि Sweet.js स्वच्छता मैक्रोज़ को लागू करता है।

अब कुछ उपयोगी लिखते हैं। बीडीडी शैली में परीक्षण लिखने के लिए मैक्रोज़ के सेट के बारे में कैसे। सबसे सरल से शुरू करते हैं।

 let describe = macro { rule { $name:lit { $body ... } } => { describe($name, function () { $body ... }); } } let it = macro { rule { $name:lit { $body ... } } => { it($name, function () { $body ... }); } } describe "My functionality" { it "works!" { } } 

macro name फॉर्म के विपरीत, हमने let name = macro उपयोग किया है - यह अनंत पुनरावृत्ति को बाहर करने के लिए किया जाता है। चूंकि describe और it मैक्रोज़ नाम के साथ टोकन का एक सेट लौटाता है, जो मैक्रोज़ के नामों से मेल खाते हैं, Sweet.js तब तक संबंधित मैक्रोज़ को फिर से लागू करने का प्रयास करेंगे जब तक कि स्टैक बाहर नहीं निकलता। let फॉर्म इससे बचने में मदद करता है, क्योंकि यह सिंटैक्स के अंदर मैक्रो नाम के लिए बाइंडर्स नहीं बनाता है जो मैक्रो द्वारा वापस आ जाता है।

आइए देखें कि हमें क्या मिला

 describe('My functionality', function () { it('works!', function () { }); }); 

यह पहले से ही swap मैक्रो की तुलना में अधिक उपयोगी है, जिसे हमने बहुत शुरुआत में लिखा था, जो हमें लेखन कोड को बचाने और विषय क्षेत्र के करीब वाक्य रचना का उपयोग करने की अनुमति देता है।

आइए देखें कि हम परीक्षण लिखने के लिए मैक्रोज़ के साथ और क्या कर सकते हैं। लेखन के लिए मैक्रो के सेट के बारे में क्या? चूंकि मैक्रोज़ के पास कोड की संरचना तक पहुंच है, इसलिए हम बयानों की विफलता के बारे में सूचनात्मक संदेशों के साथ बयान लिखने के लिए इसका उपयोग कर सकते हैं। उसी समय, आइए देखें कि कैसे Sweet.js आपको infix macros लिखने की अनुमति देता है।

यह सब कैसे दिखेगा? मैं निम्नलिखित सिंटैक्स का सुझाव देता हूं:

 2 + 2 should == 4 "aabbcc" should contain "bb" [1, 2] should be truthy xy() should throw 

एक ही समय में, एक असफल बयान के साथ, मैं एक सूचनात्मक त्रुटि संदेश देखना चाहता हूं जो न केवल undefined has no method x की शैली में वर्तमान चर के मूल्यों को दिखाएगा, undefined has no method x , लेकिन आउटपुट होगा जिसके कारण कोड उत्पन्न हुआ। उदाहरण के लिए, 2 + 2 should == 5 का परिणाम त्रुटि संदेश में 2 + 2 should be equal to 5 ।

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

 macro fmt { case { _ ( $val:expr ) } => { function fmt(v) { return v.map(function(x){ return x.token.inner ? x.token.value[0] + fmt(x.token.inner) + x.token.value[1] : x.token.value; }).join(''); } return [makeValue('`' + fmt(#{$val}) + '`', #{here})]; } } 

पिछले उदाहरणों के विपरीत, यह मैक्रो एक केस मैक्रो है। नियम मैक्रोज़ के विपरीत जो हमने पहले इस्तेमाल किया था, केस मैक्रोज़ आपको वाक्यात्मक परिवर्तन को परिभाषित करने के लिए जावास्क्रिप्ट की सभी शक्ति का उपयोग करने की अनुमति देता है।

मैं विस्तार से वर्णन नहीं करूंगा कि यह मैक्रो क्या करता है। लेकिन योजना यह है - हम एक फ़ंक्शन fmt को परिभाषित करते हैं जो वाक्यविन्यास पेड़ को बायपास करता है और इससे कोड की एक पंक्ति उत्पन्न करता है। फिर हम एक और वाक्यविन्यास ट्री का निर्माण करते हैं, जिसमें एक पंक्ति नोड होता है और इसे मैक्रो के परिणामस्वरूप वापस कर देता है।

 fmt(1 + 1) // "1+1" fmt(xy(1, 2)) // "xy(1,2)" 

जैसा कि आप देख सकते हैं, सब कुछ एक धमाके के साथ काम करता है, सिवाय इसके कि स्ट्रिंग रिक्त स्थान के बिना प्राप्त की जाती है। fmt मैक्रो का सबसे अच्छा संस्करण लिखना पाठक के लिए एक अभ्यास के रूप में रहता है।

अब हम बयानों के लिए वाक्य रचना की प्रत्यक्ष परिभाषा की ओर मुड़ते हैं। हम बयानों के लिए मानक Node.js लाइब्रेरी से assert मॉड्यूल का उपयोग स्वयं करेंगे और बस इस मॉड्यूल से फ़ंक्शन कॉल में संकलित किए जाने वाले मैक्रोज़ को परिभाषित करेंगे।

 var assert = require('assert'); macro should { rule infix { $lhs:expr | == $rhs:expr } => { assert.deepEqual( $lhs, $rhs, fmt($lhs) + " should be equal to " + fmt($rhs)); } rule infix { $lhs:expr | be truthy } => { assert.ok( $lhs, fmt($lhs) + " should be truthy"); } rule infix { $lhs:expr | contain $rhs } => { assert.ok( $lhs.indexOf($rhs) > -1, fmt($lhs) + " should contain " + fmt($rhs)); } rule infix { $lhs:expr | throw } => { assert.throws( function() { $lhs }, Error, fmt($lhs) + " should throw"); } } 

हमने infix नियमों को परिभाषित करने के लिए rule infix निर्माण का उपयोग किया है, प्रतीक | टेम्पलेट में पता चलता है कि मैक्रो नाम का प्रतीक कहाँ होना चाहिए, इस मामले में should ।

अब दावों का एक सेट

 2 + 2 should == 4 "aabbcc" should contain "bb" [1, 2] should be truthy xy() should throw 

निम्नलिखित ES5 मान्य कोड में प्रकट किया जाएगा

 var assert = require('assert'); assert.deepEqual(2 + 2, 4, '`2+2`' + ' should be equal to ' + '`4`'); assert.ok('aabbcc'.indexOf('bb') > -1, '`aabbcc`' + ' should contain ' + '`bb`'); assert.ok([ 1, 2 ], '`[1,2]`' + ' should be truthy'); assert.throws(function () { xy(); }, Error, '`xy()`' + ' should throw'); 

कार्य पूरा हुआ! अब आप अपने कार्यों के लिए अपने मैक्रोज़ लिखना शुरू कर सकते हैं या कुछ पुस्तकालयों या रूपरेखाओं के लिए अपने स्वयं के वाक्यविन्यास को परिभाषित कर सकते हैं।

सभी मैक्रोज़ जिन्हें मैंने इस लेख में परिभाषित किया था (और थोड़ा और भी) npm और github पर उपलब्ध हैं:

• स्वीट- बड - वर्णन, यह, पहले, बाद में, ... मैक्रोज़
• मधुर-कथन - स्थूल चाहिए

उनका उपयोग करने के लिए, आपको सबसे पहले npm से आवश्यक पैकेजों को स्थापित करना होगा:

 % npm install --global mocha sweet.js % npm install sweet-bdd sweet-assertions 

और फिर कोड का संकलन और परीक्षण करें

 describe "additions" { it "works" { 2 + 2 should == 4 } } 

निम्न आदेशों का उपयोग करना

 % sjs -m sweet-bdd -m sweet-assertions ./specs.sjs > specs.js % mocha specs.js 

मैक्रोज़ के साथ अन्य पुस्तकालय भी npm पर उपलब्ध हैं। मैं स्पार्कलर पर उदाहरण की तलाश करता हूं, जो जावास्क्रिप्ट में एक पैटर्न (पैटर्न मिलान) के साथ तुलना करता है:

 function myPatterns { // Match literals case 42 => 'The meaning of life' // Tag checking for JS types using Object::toString case a @ String => 'Hello ' + a // Array destructuring case [...front, back] => back.concat(front) // Object destructuring case { foo: 'bar', x, 'y' } => x // Custom extractors case Email{ user, domain: 'foo.com' } => user // Rest arguments case (a, b, ...rest) => rest // Rest patterns (mapping a pattern over many values) case [...{ x, y }] => _.zip(x, y) // Guards case x @ Number if x > 10 => x } 

मुझे लगता है कि यह दिलचस्प था। सभी टिप्पणियों के लिए, कृपया टिप्पणियों में या, जो शर्मीली है, मुझे ईमेल भेजें।

अद्यतन। मैं यह कहना भूल गया कि Sweet.js में स्रोत मानचित्र बनाने की क्षमता है, इसलिए डिबगिंग (ब्राउज़र में कम से कम) के साथ कोई कठिनाई नहीं होनी चाहिए।