हाल ही में, मैं मूंछों में भाग गया जिसे लॉजिक-कम टेम्पलेट होने का दावा किया जाता है ।
हालाँकि, यह कोई व्याख्या नहीं है कि इसे लॉजिक-लेस तरीके से क्यों बनाया गया है। दूसरे शब्द में, तर्क-कम टेम्पलेट का क्या फायदा है?
हाल ही में, मैं मूंछों में भाग गया जिसे लॉजिक-कम टेम्पलेट होने का दावा किया जाता है ।
हालाँकि, यह कोई व्याख्या नहीं है कि इसे लॉजिक-लेस तरीके से क्यों बनाया गया है। दूसरे शब्द में, तर्क-कम टेम्पलेट का क्या फायदा है?
जवाबों:
दूसरे शब्दों में, यह आपको पैर में खुद को गोली मारने से रोकता है। पुराने JSP दिनों में, JSP फ़ाइलों को जावा कोड के साथ छिड़का जाना बहुत आम बात थी, जो कि रिफ्लैक्टिंग को बहुत कठिन बना देती थी, क्योंकि आपके पास अपना कोड बिखरा हुआ था।
यदि आप डिज़ाइन के अनुसार टेम्प्लेट में लॉजिक को रोकते हैं (जैसे मूंछें करता है), तो आप लॉजिक को कहीं और लगाने के लिए बाध्य होंगे, इसलिए आपके टेम्प्लेट अप्रयुक्त हो जाएंगे।
एक और लाभ यह है कि आपको चिंताओं को अलग करने के संदर्भ में सोचने के लिए मजबूर किया जाता है: आपके नियंत्रक या तर्क कोड को यूआई में डेटा भेजने से पहले डेटा की मालिश करना होगा । यदि आप बाद में अपने टेम्प्लेट को दूसरे के लिए स्विच करते हैं (मान लीजिए कि आप एक अलग टेम्प्लेटिंग इंजन का उपयोग शुरू करते हैं), तो संक्रमण आसान होगा क्योंकि आपको केवल यूआई विवरण लागू करना होगा (क्योंकि टेम्पलेट पर कोई तर्क नहीं है, याद रखें)।
मुझे लगता है कि मैं अपनी राय में लगभग अकेला हूं, लेकिन मैं विपरीत शिविर में मजबूती से खड़ा हूं। मुझे विश्वास नहीं है कि आपके टेम्प्लेट में व्यावसायिक तर्क का संभावित मिश्रण पर्याप्त कारण है जो आपकी प्रोग्रामिंग भाषा की पूरी शक्ति का उपयोग नहीं करता है।
लॉजिक-कम टेम्प्लेट के लिए सामान्य तर्क यह है कि यदि आपके पास अपनी प्रोग्रामिंग लैंग्वेज की पूरी पहुंच है, तो आप लॉजिक में मिक्स हो सकते हैं, जिसका कोई खाका नहीं है। मुझे यह तर्क इस कारण लगता है कि आपको एक चम्मच का उपयोग मांस के टुकड़े करने के लिए करना चाहिए क्योंकि यदि आप चाकू का उपयोग करते हैं तो आप खुद को काट सकते हैं। यह बहुत सही है, और फिर भी यदि आप उत्तरार्द्ध का उपयोग करते हैं, तो आप अधिक सावधानी से अधिक उत्पादक होंगे।
उदाहरण के लिए, मूंछों का उपयोग करके निम्नलिखित टेम्पलेट स्निपेट पर विचार करें :
{{name}}:
<ul>
{{#items}}
<li>{{.}}</li>
{{/items}}
</ul>
मैं इसे समझ सकता हूं, लेकिन मैं निम्नलिखित ( अंडरस्कोर का उपयोग करके ) बहुत अधिक सरल और प्रत्यक्ष पाता हूं :
<%- name %>:
<ul>
<% _.each(items, function(i){ %>
<li><%- i %></li>
<% }); %>
</ul>
कहा जा रहा है, मैं समझता हूं कि तर्कहीन टेम्पलेट्स के फायदे हैं (उदाहरण के लिए, उन्हें बिना परिवर्तन के कई प्रोग्रामिंग भाषाओं के साथ उपयोग किया जा सकता है)। मुझे लगता है कि ये अन्य फायदे बहुत महत्वपूर्ण हैं। मुझे नहीं लगता कि उनका तर्क-कम स्वभाव उनमें से एक है।
nameऔर itemsइसमें जावास्क्रिप्ट शामिल हो सकता है।
मूंछें तर्क-कम है?
यह नहीं है:
{{#x}}
foo
{{/x}}
{{^x}}
bar
{{/x}}
इस के समान सुंदर?
if x
"foo"
else
"bar"
end
और नहीं है कि सुंदर के समान (पढ़ें: के लगभग एक परिभाषा) प्रस्तुति तर्क?
if x > 0 && x < 10) ... तो, जबकि मूंछ का उपयोग तर्क के साथ या उसके बिना करना संभव है, यह आपके ऊपर है। आखिरकार, यह सिर्फ एक उपकरण है।
एक लॉजिक-कम टेम्प्लेट एक ऐसा टेम्प्लेट होता है, जिसमें आपको भरने के लिए छेद होते हैं, न कि आप उन्हें कैसे भरते हैं। तर्क को कहीं और रखा जाता है और सीधे टेम्पलेट पर मैप किया जाता है। चिंताओं का यह पृथक्करण आदर्श है क्योंकि तब टेम्प्लेट को आसानी से विभिन्न लॉजिक के साथ, या यहां तक कि एक अलग प्रोग्रामिंग भाषा के साथ बनाया जा सकता है।
से मूंछें मैनुअल :
हम इसे "लॉजिक-लेस" कहते हैं क्योंकि अगर कोई बयान नहीं है, तो दूसरे खंड या लूप के लिए हैं। इसके बजाय केवल टैग हैं। कुछ टैग एक मूल्य के साथ बदले जाते हैं, कुछ कुछ नहीं, और कुछ अन्य मानों की एक श्रृंखला। यह दस्तावेज़ विभिन्न प्रकार के मूंछ टैगों की व्याख्या करता है।
सिक्के का दूसरा पहलू यह है कि व्यावसायिक तर्क को प्रस्तुति से बाहर रखने की एक बेताब कोशिश में, आप मॉडल में बहुत सारे प्रस्तुति तर्क रखते हैं। एक सामान्य उदाहरण यह हो सकता है कि आप एक तालिका में पंक्तियों को वैकल्पिक करने पर "विषम" और "यहां तक कि" कक्षाएं लगाना चाहते हैं, जो कि दृश्य टेम्पलेट में एक साधारण मोडुलो ऑपरेटर के साथ किया जा सकता है। लेकिन अगर आपका व्यू टेम्प्लेट आपको ऐसा करने की अनुमति नहीं देता है, तो आपके मॉडल डेटा में आपको न केवल स्टोर करना होगा कि कौन सी पंक्ति विषम है या यहां तक कि, लेकिन यह निर्भर करता है कि आपका टेम्पलेट इंजन कितना सीमित है, आपको अपने मॉडल को प्रदूषित करने की भी आवश्यकता हो सकती है। वास्तविक सीएसएस कक्षाओं के नाम के साथ। दृश्य मॉडल से अलग होने चाहिए, पूर्ण-विराम। लेकिन मॉडल भी देखें अज्ञेय होना चाहिए, और यह है कि इनमें से कई "नो-लॉजिक" टेम्पलेट इंजन आपको भूल जाते हैं। लॉजिक दोनों जगह जाता है,वास्तव में यह सही ढंग से तय करने के लिए करता है कि वह कहाँ जाता है। यह एक प्रस्तुति चिंता का विषय है, या एक व्यापार / डेटा चिंता? 100% प्राचीन विचार रखने के प्रयास में, प्रदूषण सिर्फ एक और कम दिखाई देने वाले लेकिन समान रूप से अनुपयुक्त जगह में लैंड करता है।
दूसरी दिशा में एक बढ़ता हुआ आंदोलन है, और उम्मीद है कि चीजें कहीं अधिक उचित मध्य-मैदान में केंद्रित होंगी।
यह आपके टेम्प्लेट को क्लीनर बनाता है, और यह आपको तर्क को एक ऐसी जगह पर रखने के लिए मजबूर करता है, जहां इसे ठीक से परीक्षण किया जा सकता है।
यह बातचीत ऐसा महसूस करती है जब मध्य युग के भिक्षु इस बात पर बहस करेंगे कि पिन के अंत में कितने स्वर्गदूत फिट हो सकते हैं। दूसरे शब्दों में इसकी शुरुआत धार्मिक, व्यर्थ और गलत तरीके से ध्यान केंद्रित करने के लिए होती है।
मिनी-रेंट एन्स्यूस (अनदेखा करने के लिए स्वतंत्र महसूस):
यदि आप पढ़ना जारी नहीं रखना चाहते हैं .. तो उपरोक्त विषय पर मेरी संक्षिप्त प्रतिक्रिया है: मैं तर्क-वितर्क से सहमत नहीं हूं। मैं इसे अतिवाद का एक प्रोग्रामिंग रूप मानता हूं। :-) :-)
अब मेरा शेख़ी जारी है: :-)
मुझे लगता है कि जब आप कई विचारों को चरम पर ले जाते हैं, तो परिणाम भयावह हो जाता है। और कभी-कभी (अर्थात यह विषय) मुद्दा यह है कि हम "गलत" विचार को चरम पर ले जाते हैं।
सभी लॉजिक को दृश्य से हटाना "लुडीक्रॉस" और गलत विचार है।
एक पल के लिए पीछे हटो।
हमें खुद से यह सवाल पूछने की आवश्यकता है कि तर्क को क्यों हटाएं? अवधारणा, स्पष्ट रूप से चिंताओं का पृथक्करण है । संभव के रूप में व्यावसायिक तर्क से अलग दृश्य प्रसंस्करण रखें। यह क्यों? यह हमें अलग-अलग प्लेटफ़ॉर्म (मोबाइल, ब्राउज़र, डेस्कटॉप इत्यादि के लिए) से व्यूज को स्वैप करने की अनुमति देता है और यह हमें कंट्रोल-फ्लो, पेज सीक्वेंस, वेलिडेशन चेंजेस, मॉडल चेंजेस, सिक्योरिटी एक्सेस इत्यादि को आसानी से स्वैप करने की अनुमति देता है। विचारों (विशेष रूप से वेब विचारों) से हटा दिया गया, यह विचारों को अधिक पठनीय बनाता है और इसलिए अधिक बनाए रखने योग्य है। मुझे वह मिलता है और मैं उससे सहमत हूं।
हालाँकि ओवरराइडिंग का फोकस चिंताओं को अलग करने पर होना चाहिए। 100% लॉजिक-कम विचार नहीं। विचारों के भीतर का तर्क "मॉडल" को कैसे प्रस्तुत करना है, इसके साथ संबंधित होना चाहिए। जहां तक मेरा सवाल है, विचारों में तर्क बिल्कुल ठीक है। आपके पास दृश्य-तर्क हो सकते हैं जो व्यवसाय-तर्क नहीं है।
हां, दिन में जब हमने JSP, PHP या ASP पेजों को कोड लॉजिक और व्यू लॉजिक से अलग या बिना अलग किए लिखा था, तो इन वेब-ऐप्स का रखरखाव एक बुरा सपना था। मेरा विश्वास करो मुझे पता है, मैंने बनाया और फिर इनमें से कुछ मठों को बनाए रखा। यह उस रखरखाव के चरण के दौरान था जिसे मैं वास्तव में (मेरे और मेरे सहयोगियों के तरीकों की त्रुटि) समझ गया था। :-) :-)
तो उच्च (उद्योग पंडितों) से सम्पादन बन गया, आपको अपने वेब-एप्स को सामने वाले नियंत्रक (जैसे कि हैंडलर या क्रियाओं के लिए भेजा जाना चाहिए) का उपयोग करके संरचना करना चाहिए [अपना वेब-ढांचा चुनें] और आपके विचारों में कोई कोड नहीं होना चाहिए । विचार गूंगे खाके बनने वाले थे।
इसलिए मैं सामान्य रूप से उपरोक्त भावना के साथ सहमत हूं, न कि एडिट की वस्तुओं की बारीकियों के लिए, बल्कि एडिट के पीछे की प्रेरणा - जो कि दृश्य और व्यावसायिक तर्क के बीच चिंताओं के अलगाव की इच्छा है।
एक परियोजना जिसमें मैं शामिल था, हमने लॉडिकस चरम पर तर्क-कम-विचार विचार का पालन करने की कोशिश की। हमारे पास एक घरेलू-विकसित टेम्पलेट इंजन था जो हमें HTML में मॉडल ऑब्जेक्ट्स को प्रस्तुत करने की अनुमति देगा। यह एक साधारण टोकन आधारित प्रणाली थी। यह एक बहुत ही सरल कारण के लिए भयानक था। कभी-कभी एक दृश्य में हमें तय करना होता है, क्या मुझे HTML का यह छोटा सा टुकड़ा प्रदर्शित करना चाहिए .. या नहीं .. यह निर्णय आमतौर पर मॉडल में कुछ मूल्य पर आधारित होता है। जब आपके पास देखने में कोई तर्क नहीं है, तो आप कैसे करते हैं? खैर आप नहीं कर सकते। इस बारे में हमारे वास्तुकार के साथ मेरे कुछ प्रमुख तर्क थे। हमारे विचारों को लिखने वाले सामने वाले एचटीएमएल लोग पूरी तरह से हंस्ट्रुंग थे जब उन्हें इस बात का सामना करना पड़ा और वे बहुत तनाव में थे क्योंकि वे अपने सामान्य उद्देश्यों को प्राप्त नहीं कर सकते थे। इसलिए मैंने हमारे टेम्प्लेटिंग इंजन के भीतर एक सरल IF-statement की अवधारणा पेश की। मैं आपको राहत और शांत होने का वर्णन नहीं कर सकता। हमारे टेम्प्लेट्स में एक सरल IF-Statement अवधारणा के साथ समस्या का समाधान किया गया था! अचानक हमारा टेम्प्लेटिंग इंजन अच्छा हो गया।
तो हम इस मूर्खतापूर्ण तनावपूर्ण स्थिति में कैसे आए? हमने गलत उद्देश्य पर ध्यान केंद्रित किया। हमने नियम का पालन किया, आपके विचारों में कोई तर्क नहीं होना चाहिए। वह गलत था। मुझे लगता है कि "नियम-से-अंगूठे" होना चाहिए, अपने विचारों में तर्क की मात्रा को कम से कम करें। क्योंकि अगर आप अनजाने में व्यावसायिक तर्क को दृश्य में रेंगने की अनुमति नहीं दे सकते - जो चिंताओं के पृथक्करण का उल्लंघन करता है।
मैं समझता हूं कि जब आप घोषित करते हैं कि "आपके पास विचारों में कोई तर्क नहीं होना चाहिए", तो यह जानना आसान हो जाता है कि आप "अच्छे" प्रोग्रामर कब बन रहे हैं। (यदि वह आपकी अच्छाई का माप है)। अब उपरोक्त नियम के साथ मध्यम जटिलता के एक वेब-एप्लिकेशन को लागू करने का प्रयास करें। यह इतनी आसानी से नहीं किया गया है।
मेरे लिए, विचारों में तर्क का नियम इतना स्पष्ट नहीं है और स्पष्ट रूप से यही वह जगह है जहाँ मैं चाहता हूँ।
जब मैं विचारों में बहुत सारे तर्क देखता हूं, तो मैं एक कोड-गंध का पता लगाता हूं और अधिकांश लॉजिक को विचारों से खत्म करने की कोशिश करता हूं - मैं कोशिश करता हूं कि व्यावसायिक तर्क कहीं और रहें - मैं चिंताओं को अलग करने की कोशिश करता हूं। लेकिन जब मैं ऐसे लोगों के साथ बातचीत करना शुरू करता हूं जो कहते हैं कि हमें सभी तर्क को देखने से दूर करना होगा , ठीक है, मेरे लिए, कि कट्टरता का सिर्फ स्मैक जैसा कि मैं जानता हूं कि आप ऊपर बताई गई स्थितियों में समाप्त हो सकते हैं।
मैं अपने शेख़ी के साथ कर रहा हूँ। :-)
चीयर्स,
डेविड
लॉजिकलेस टेम्प्लेट के लिए मैं सबसे अच्छा तर्क लेकर आया हूं, तब आप क्लाइंट और सर्वर दोनों पर एक ही समान टेम्प्लेट का उपयोग कर सकते हैं। हालाँकि आपको वास्तव में तर्कहीन की आवश्यकता नहीं है, बस एक ही है जिसकी अपनी "भाषा" है। मैं उन लोगों से सहमत हूं जो शिकायत करते हैं कि मूंछें व्यर्थ रूप से सीमित हैं। धन्यवाद, लेकिन मैं एक बड़ा लड़का हूं और मैं आपकी मदद के बिना अपने टेम्पलेट्स को साफ रख सकता हूं।
एक अन्य विकल्प सिर्फ एक टेम्प्लेटिंग सिंटैक्स ढूंढना है जो क्लाइंट और सर्वर दोनों पर समर्थित भाषा का उपयोग करता है, अर्थात सर्वर पर जावास्क्रिप्ट या तो नोड द्वारा उपयोग किया जाता है। या तो आप एक जेएस दुभाषिया और जुबां का उपयोग कर सकते हैं जैसे जुबैर के माध्यम से।
तब आप haml.js की तरह कुछ का उपयोग कर सकते हैं जो अब तक प्रदान किए गए किसी भी उदाहरण की तुलना में बहुत अधिक क्लीनर है और महान काम करता है।
एक वाक्य में: लॉजिक-कम का मतलब है कि टेम्प्लेट इंजन अपने आप में कम जटिल है और इसलिए इसमें एक छोटा पदचिह्न है और अप्रत्याशित रूप से व्यवहार करने के लिए इसके कम तरीके हैं।
भले ही यह प्रश्न पुराना है और उत्तर दिया गया है, मैं अपने 2 which जोड़ना चाहूंगा (जो एक शेख़ी की तरह लग सकता है, लेकिन ऐसा नहीं है, यह सीमाओं के बारे में है और जब वे अस्वीकार्य हो जाते हैं)।
एक टेम्पलेट का लक्ष्य कुछ को प्रस्तुत करना है, न कि व्यावसायिक तर्क करना। अब एक पतली रेखा नहीं है जो आपको एक टेम्पलेट में करने और उनमें "व्यावसायिक तर्क" रखने की आवश्यकता है। भले ही मैं वास्तव में मूंछों के प्रति सकारात्मक था और इसका उपयोग करने की कोशिश की, मैंने समाप्त कर दिया मुझे वह करने में सक्षम नहीं होना चाहिए जो मुझे बहुत सरल मामलों में चाहिए।
डेटा की "मालिश" (स्वीकृत उत्तर में शब्दों का उपयोग करने के लिए) एक वास्तविक समस्या बन सकती है - यहां तक कि सरल रास्तों का भी समर्थन नहीं किया जाता है (कुछ जो हैंडलबार्स। जेएस पते)। यदि मेरे पास डेटा है और मुझे उस समय ट्वीक करने की आवश्यकता है, जब मैं कुछ प्रस्तुत करना चाहता हूं क्योंकि मेरा टेम्पलेट इंजन बहुत सीमित है, तो यह अंत में सहायक नहीं है। और यह मंच-स्वतंत्रता के उस हिस्से को हरा देता है जो मूंछें अपने लिए दावा करती हैं; मुझे हर जगह मालिश करने वाले तर्क की नकल करनी है।
उस ने कहा, कुछ हताशा के बाद और अन्य टेम्पलेट इंजनों को आजमाने के बाद हमने अपना (... अभी तक एक और ...) निर्माण किया, जो .NET रेजर टेम्प्लेट से प्रेरित वाक्य रचना का उपयोग करता है। यह सर्वर पर पार्स और संकलित है और एक सरल, स्व-निहित जेएस फ़ंक्शन (वास्तव में आवश्यकता के अनुसार मॉड्यूल) उत्पन्न करता है, जिसे टेम्पलेट को "निष्पादित" करने के लिए आमंत्रित किया जा सकता है, परिणाम के रूप में एक स्ट्रिंग लौटाता है। ब्रैड द्वारा दिया गया नमूना हमारे इंजन का उपयोग करते समय इस तरह दिखेगा (जो मुझे व्यक्तिगत रूप से मूंछ और अंडरस्कोर दोनों की तुलना में आसानी से बेहतर लगता है):
@name:
<ul>
@for (items) {
<li>@.</li>
}
</ul>
मूंछों वाले धारावाहिकों में कॉल करने पर एक और तर्क-मुक्त सीमा ने हमें मारा। जबकि मस्टैच द्वारा पार्टिकल्स का समर्थन किया जाता है, पहले पास किए जाने वाले डेटा को कस्टमाइज़ करने की कोई संभावना नहीं है। इसलिए एक मॉड्यूलर टेम्पलेट बनाने में सक्षम होने और छोटे ब्लॉकों का पुन: उपयोग करने के लिए, मैं उनमें बार-बार कोड के साथ टेम्पलेट करना समाप्त करूंगा।
हमने XPath से प्रेरित एक क्वेरी भाषा लागू करके हल किया, जिसे हमने JPath कहा। मूल रूप से, हम बच्चों का उपयोग करने के लिए / डॉट्स का उपयोग करने के बजाय, और न केवल स्ट्रिंग, संख्या और बूलियन लीटर का समर्थन करते हैं, बल्कि वस्तुओं और सरणियों (सिर्फ JSON की तरह) का भी समर्थन करते हैं। भाषा साइड-इफ़ेक्ट-फ़्री है (जो टेम्प्लेटिंग के लिए बहुत ज़रूरी है) लेकिन नई साहित्यिक वस्तुएं बनाकर डेटा को "मालिश" करने की अनुमति देता है।
मान लें कि हम पंक्तियों पर क्रियाशील हेडर और लिंक के साथ "डेटा ग्रिड" तालिका प्रस्तुत करना चाहते हैं, और बाद में गतिशील रूप से jQuery का उपयोग करके पंक्तियों को जोड़ते हैं। यदि मुझे कोड की नकल नहीं करनी है तो पंक्तियों को आंशिक रूप से होना चाहिए। और यहीं से परेशानी शुरू होती है अगर कुछ अतिरिक्त जानकारी जैसे कि कॉलम को क्या प्रस्तुत किया जाएगा, दृश्यमॉडल का हिस्सा है, और प्रत्येक पंक्ति पर उन कार्यों के लिए बस यही है। हमारे टेम्प्लेट और क्वेरी इंजन का उपयोग करके कुछ वास्तविक कार्य कोड यहां दिए गए हैं:
टेबल टेम्प्लेट:
<table>
<thead>
<tr>
@for (columns) {
<th>@title</th>
}
@if (actions) {
<th>Actions</th>
}
</tr>
</thead>
<tbody>
@for (rows) {
@partial Row({ row: ., actions: $.actions, columns: $.columns })
}
</tbody>
</table>
पंक्ति टेम्पलेट:
<tr id="@(row.id)">
@for (var $col in columns) {
<td>@row.*[name()=$col.property]</td>
}
@if (actions) {
<td>
@for (actions) {
<button class="btn @(id)" value="@(id)">@(name)...</button>
}
</td>
}
</tr>
JS कोड से मंगलाचरण:
var html = table({
columns: [
{ title: "Username", property: "username" },
{ title: "E-Mail", property: "email" }
],
actions: [
{ id: "delete", name: "Delete" }
],
rows: GetAjaxRows()
})
इसमें कोई व्यावसायिक तर्क नहीं है, फिर भी यह पुन: प्रयोज्य और विन्यास योग्य है, और यह साइड-इफ़ेक्ट फ्री भी है।
rowस्थिर नामों का उपयोग करने के बजाय गतिशील रूप से ऑब्जेक्ट से ली जाने वाली संपत्ति के नामों को निर्दिष्ट करने की अनुमति देता है । उदाहरण के लिए अगर $col.property == 'Something'यह सामग्री की उपज होगी row.Something।
यहाँ चरित्र की गिनती के साथ, सूची प्रदान करने के 3 तरीके दिए गए हैं। सभी लेकिन पहला और सबसे छोटा तर्क-प्रधान अस्थायी भाषा में हैं ..
कॉफीस्क्रिप्ट ( प्रतिक्रियाशील कॉफी बिल्डर डीएसएल के साथ) - 37 वर्ण
"#{name}"
ul items.map (i) ->
li i
नॉकआउट - 100 चार्ट
<span data-bind="value: name"/>
<ul data-bind="foreach: items">
<li data-bind="value: i"/>
</ul>
हैंडलबार / मूंछ - 66 वर्ण
{{name}}:
<ul>
{{#items}}
<li>{{.}}</li>
{{/items}}
</ul>
अंडरस्कोर - 87 वर्ण
<%- name %>:
<ul>
<% _.each(items, function(i){ %>
<li><%- i %></li>
<% }); %>
</ul>
लॉजिक-कम टेम्प्लेट का वादा था, मुझे लगता है, कि व्यापक कौशल वाले लोग पैर में खुद को शूट किए बिना लॉजिक-कम टेम्प्लेट का प्रबंधन करने में सक्षम होंगे। हालाँकि, उपरोक्त उदाहरणों में आप जो देखते हैं वह यह है कि जब आप स्ट्रिंग-आधारित मार्कअप में न्यूनतम-तर्क भाषा जोड़ते हैं, तो परिणाम अधिक जटिल होता है, कम नहीं। इसके अलावा, आप देख रहे हैं कि आप पुराने स्कूल PHP कर रहे हैं।
स्पष्ट रूप से मैं "व्यावसायिक तर्क" (व्यापक संगणना) को बाहर रखने के लिए आपत्ति नहीं करता। लेकिन मुझे लगता है कि प्रथम श्रेणी की भाषा के बजाय प्रदर्शन तर्क के लिए उन्हें एक छद्म भाषा देने से कीमत चुकानी पड़ती है। न केवल टाइप करने के लिए, बल्कि संदर्भ-स्विचिंग का एक जघन्य मिश्रण इसे पढ़ने की जरूरत है।
निष्कर्ष रूप में, मैं तर्क-वितर्क-युक्त टेम्पलेट्स को देखने में विफल रहता हूं, इसलिए मैं कहूंगा कि उनका लाभ मेरे लिए शून्य है, लेकिन मैं इस बात का सम्मान करता हूं कि समुदाय के कई लोग इसे अलग तरह से देखते हैं :)
लॉजिक-कम टेम्पलेट का उपयोग करने के मुख्य लाभ हैं:
मैं ब्रैड से सहमत हूं: underscoreशैली को समझना आसान है। लेकिन मुझे स्वीकार करना होगा कि चीनी सभी को खुश नहीं कर सकती है। यदि _.eachकुछ भ्रामक है, तो आप पारंपरिक forलूप का उपयोग कर सकते हैं ।
<% for(var i = 0; i < items.length; i++) { %>
<%= items[i] %>
<% } %>
यह हमेशा अच्छा होता है यदि आप मानक निर्माण जैसे कि forया पर वापस आ सकते हैं if। बस उपयोग करें <% if() %>या <% for() %>जबकि Mustacheकुछ के लिए उपयोग करें if-then-else(और अगर आप प्रलेखन नहीं पढ़ा तो भ्रमित):
{{#x}}
foo
{{/x}}
{{^x}}
bar
{{/x}}
टेम्पलेट इंजन बहुत अच्छा है जब आप आसानी से नेस्टेड टेम्पलेट प्राप्त कर सकते हैं ( underscoreशैली):
<script id="items-tmpl" type="text/template">
<ul>
<% for(var i = 0; i < obj.items.length; i++) { %>
<%= innerTmpl(obj.items[i]) %>
<% } %>
</ul>
</script>
<script id="item-tmpl" type="text/template">
<li>
<%= name %>
</li>
</script>
var tmplFn = function(outerTmpl, innerTmpl) {
return function(obj) {
return outerTmpl({obj: obj, innerTmpl: innerTmpl});
};
};
var tmpl = tmplFn($('#items-tmpl').html(), $('#item-tmpl').html());
var context = { items: [{name:'A',{name:'B'}}] };
tmpl(context);
मूल रूप से आप अपने आंतरिक tmpl को अपने संदर्भ की संपत्ति के रूप में पास करते हैं। और उसी के अनुसार बुलाओ। मिठाई :)
वैसे, यदि आपकी रुचि का एकमात्र सामान टेम्पलेट इंजन है, तो स्टैंडअलोन टेम्पलेट कार्यान्वयन का उपयोग करें। यह केवल 900 अक्षरों का है जब खनन किया गया (4 लंबी लाइनें):