प्रोग्रामिंग भाषा जे। क्या प्यार करने के लिए?

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

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

थोड़ा इतिहास

J से पहले APL था। एपीएल भाषा का विकास केनेथ इवरसन ने 50 के दशक में हार्वर्ड कम्प्यूटेशनल मैथमेटिक्स में पढ़ाते समय किया था। विशेष रूप से शिक्षण के लिए, उन्होंने अपनी धारणा विकसित की। फिर इस भाषा को मशीनों में स्थानांतरित कर दिया गया और इसे एपीएल (मामूली: ए प्रोग्राम लैंग्वेज) के रूप में जाना जाने लगा। एपीएल सरणियों के साथ काम करता है और उनके साथ काम करने के लिए अनुकूलित है।

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

लघु समीक्षा जे

आप www.jsoftware.com पर J डाउनलोड और इंस्टॉल कर सकते हैं। प्रशिक्षण सामग्री और विभिन्न दस्तावेज भी हैं।

J एक कार्यात्मक भाषा है। लेकिन भाषा सामान्य नहीं है, क्लासिक कार्यात्मक नहीं है। चाटता नहीं। डेटा की इकाई एक n- आयामी सरणी है, सूची नहीं।

J एक दुभाषिया है (इस कार्यान्वयन में)। गतिशील टाइपिंग के साथ।

अभिव्यक्तियाँ क्रिया, संज्ञा, क्रिया विशेषण, गेरुंड, यूनियनों और बहुत कुछ से निर्मित होती हैं। इस पोस्ट में हम क्रियाओं (फ़ंक्शन / ऑपरेशन के एनालॉग) और संज्ञा (डेटा) में रुचि रखते हैं। गैर-जरूरी आंकड़े नहीं हैं, जैसा कि अनिवार्य भाषाओं में है। वे अपरिवर्तनीय हैं। इस प्रकार, जे में एक असाइनमेंट कहा जाता है, बल्कि एक "नामकरण सम्मेलन" है।

संज्ञा एक n- आयामी सरणी है। आप संज्ञा बना सकते हैं, उदाहरण के लिए, इस तरह:

३ ५ $ ०

हम शून्य से मिलकर 3 से 5 का दो आयामी सरणी प्राप्त करते हैं। आप किसी भी आयाम की एक सरणी प्राप्त कर सकते हैं। एक विशेष मामला शून्य आयामीता की एक सरणी है - यह एक अदिश राशि है। एक आयामी सरणी - वेक्टर। तो J में डेटा इकाई एक n- आयामी सरणी है। शून्य से भरे हुए सरणी का निर्माण करने के लिए, लेकिन हमें जिन नंबरों की आवश्यकता है, $ साइन के बाद, हम एक स्पेस के माध्यम से स्ट्रिंग में आवश्यक डेटा लिख ​​सकते हैं। उदाहरण के लिए, लाइन:

3 5 $ 1 2 3

यह 5 एरे द्वारा 3 बनाएगा और आउटपुट करेगा और इसे दोहराए जाने वाले अनुक्रम 1 2 3 के साथ बदले में भरेगा:

1 2 3 1 2
3 1 2 3 1
२ ३ १ २ २ ३

स्केलर बनाने के लिए, एक संख्या पर्याप्त है:

a =: ४

यहां मैंने पहले ही दिखाया है कि एक नाम कैसे सौंपा गया है। यानी और हमारे पास पहले से ही 4 है । एक वेक्टर बनाने के लिए, एक स्थान के साथ एक पंक्ति में संख्या लिखना पर्याप्त है:

4 5 3 6
4 5 3 6

* जैसा कि आप अनुमान लगा सकते हैं, जे इंटरैक्टिव मोड में काम करता है, तुरंत परिणाम प्रदर्शित करता है

अब प्रकारों के बारे में। जे में, सरणी के आयाम के अलावा, इसके तत्वों का एक प्रकार है। यानी तत्व हमेशा समान होते हैं। कई संख्यात्मक प्रकार हैं: तार्किक (0, 1), पूर्णांक, पूर्णांक किसी भी वर्ण के साथ, तर्कसंगत, वास्तविक, जटिल। इसके अलावा, संख्यात्मक प्रकारों के साथ-साथ विशेष संख्याएं भी हैं: शून्य से अनंत, अनंत, अनिश्चितता। गणितीय कार्यों के लिए J का डायनेमिक टाइपिंग बहुत अच्छा है - यह प्रत्येक ऑपरेशन पर निर्धारित करेगा कि इसमें क्या संख्याएँ हैं। उदाहरण के लिए, यदि हम पूर्णांक के मैट्रिक्स पर वर्गमूल लागू करते हैं, तो हम वास्तविक या जटिल संख्या प्राप्त कर सकते हैं। मूल सरणी के तत्वों पर निर्भर करता है।

इसके अलावा जम्मू में, संख्यात्मक प्रकारों के अलावा, हैं
1) प्रतीक (शाब्दिक)। J में, आप टेक्स्ट को प्रोसेस भी कर सकते हैं। मामला J अक्षर का वेक्टर है। वर्ण निर्दिष्ट करने के लिए, इसे एकल उद्धरण चिह्नों में संलग्न करें। वर्णों के एक वेक्टर को निर्दिष्ट करने के लिए - यह एकल उद्धरणों में पाठ को संलग्न करने के लिए पर्याप्त है।
2) बॉक्सिंग एक पैकेज्ड टाइप है। यानी किसी भी मैट्रिक्स को पैक किया जा सकता है और एक बॉक्स मिल सकता है। और बक्से से आप एक सरणी बना सकते हैं। बक्से की मदद से, इस तरह से, आप पेड़ बना सकते हैं।
और कुछ और विशेष प्रकार, जिन पर हम विचार नहीं करेंगे।

संज्ञा से निपटा। अब, क्रिया क्या हैं।
क्रिया अन्य भाषाओं में गणितीय शब्दों में एक ऑपरेशन की तरह है। J verbs में दो प्रकार के होते हैं: monad (मोनड) और dyad (dyad)। यह एकात्मक और बाइनरी संचालन के समान है। और यह एक अद्भुत अवसर देता है: क्रिया बनाने के लिए आपको इनपुट के लिए नामों की आवश्यकता नहीं है। इनपुट हमेशा एक या दो होता है - दाएं और बाएं।

किसी भी चर नाम का उपयोग किए बिना एक पंक्ति में अन्य क्रियाओं से एक क्रिया बनाने के लिए विशेष नियम हैं।

तो, पहला मानक उदाहरण:

avg =: + / % #

क्रिया avg वेक्टर का अंकगणितीय माध्य है। उसके शरीर पर ध्यान दें - केवल 4 अक्षर। यहां हमारे पास केवल तीन क्रियाएं हैं - संख्याएं ( + / ) जोड़ें, वेक्टर की लंबाई ( # ) लें और पहले को दूसरे ( % ) में विभाजित करें।

* प्रतीकों + और / द्वारा इंगित वेक्टर में संख्याओं को जोड़ें। पहला दो नंबरों का योग है, और दूसरा सभी तत्वों (यानी बाएं गुना) के बीच एक ऑपरेशन डालना है। चूंकि स्लैश व्यस्त है, इसलिए J में डिवीजन ऑपरेशन को% चिन्ह द्वारा दर्शाया गया है।

एक वेक्टर बनाएं और उस पर हमारी क्रिया लागू करें:

a =: 5 3 7 0 2 4
एवीजी ए
3.5

सदिश का अंकगणित माध्य प्राप्त किया।

यह जादू कैसे होता है? J ऐसे सरल नियमों का उपयोग करता है। सबसे पहले, जम्मू में परिचालन की कोई प्राथमिकता नहीं है और इसे दाएं से बाएं तक निष्पादित किया जाता है । यदि हम एक अभिव्यक्ति लिखते हैं:

2 * 3 + 4
14

हमें 14 मिलते हैं, 10. नहीं। जो सामान्य तौर पर, अभिव्यक्ति के निर्माण को सरल बनाता है। यदि आपको ऑर्डर बदलने की आवश्यकता है, तो कोष्ठक का उपयोग किया जाता है:

( २ * ३ ) + ४
10

डरो मत, ये सिर्फ भाव थे जो सीधे मानों की गणना करते थे, और जब हमने avg =: + / % # लिखा था, तो हम क्रियाओं को मिलाकर क्रिया को सेट करते हैं।

अब हम विश्लेषण करेंगे कि अंकगणितीय माध्य कार्यों की गणना करने की क्रिया कैसे होती है।
जब एक क्रिया में तीन क्रियाएं होती हैं, तो पहले चरम क्रियाओं को संज्ञाओं पर लागू किया जाता है, और फिर मध्य क्रिया को इसके संबंध में बाईं और दाईं ओर लागू किया जाता है।
इस तरह:


यदि एक क्रिया में 5 क्रियाएं होती हैं, तो पहले तीन दाएं निष्पादित होते हैं, जैसा कि ऊपर दिखाया गया है, फिर उन्हें दो बाईं ओर ले जाया जाता है और उसी क्रम में उन्हें आगे निष्पादित किया जाता है। उदाहरण के लिए, अधिकतम दो तत्वों को लेने की क्रिया: ">"। इसलिए, सूची से अधिकतम: "> ./"
और एक क्रिया लिखें जो अधिकतम मूल्य और अंकगणितीय माध्य का योग पाता है:

d =: > / ++ / % #

वेक्टर पर लागू करें:

दा
10.5

यह कैसे काम करता है:

कृपया ध्यान दें कि जब मैं "यह कैसे काम करता है" लिखता हूं, तो मेरा मतलब यह नहीं है कि मुझे पता है कि इन क्रियाओं को जे किस क्रम में निष्पादित करता है। मैं केवल इस तरह के क्रियाओं को समझने का अर्थ समझाता हूं। क्रियाओं की पंक्ति से हम कहते हैं कि हम क्या चाहते हैं। और कैसे - जे का फैसला करता है।

ऊपर, मैंने अभिव्यक्ति के निर्माण के नियमों में से केवल एक का वर्णन किया है। बस आपको सार को पकड़ने के लिए, संभव के रूप में, संक्षेप में एक लाइन में जटिल एल्गोरिदम का वर्णन करें और लैकोनिज़्म जे। का रहस्य क्या है स्वाभाविक रूप से, अब जे का वर्णन करने का कोई मतलब नहीं है।

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

ऊपर वर्णित जे में क्रिया लिखने के लिए फॉर्म को टैसीट कहा जाता है।

अब कुछ उदाहरण, बिना यह बताए कि वे कैसे काम करते हैं।

उदाहरण

1. ININ JOIN

SQL में ऐसे उदाहरण पर विचार करें। हमारे पास दो टेबल हैं:

CREATE TABLE Customers (ID INT, Name TEXT, Age INT, Salary INT) CREATE TABLE Orders (OID INT, Date DATETIME, CustomerID INT, Amount INT) 

किसी तरह हम उन्हें भरते हैं। और ऐसा निवेदन:

 SELECT * FROM Orders o INNER JOIN Customers c ON o.CustomerID = c.ID AND o.Amount < 2000 

मैं जानबूझकर समानता से तालिकाओं में शामिल नहीं हूं, लेकिन कार्य को थोड़ा जटिल करने के लिए अधिक जटिल भविष्यवाणी के माध्यम से।
और जे में ही करने का प्रयास करें।

createTable =: [: |:,। & a:
संघ =: ( [: {। [।] :, [: ( [: <[:>] # ~ ~: & a :) " 1 ( [: {: [ ] , ( [: {:] ) { ~। ( [: {।] ) i। [: {]
सम्मिलन =: [ संघ [: ( {।,: ( [: < ( : <[: ( $ ~ [: १ & #, # ) > ] " 0 {:) ) [: |: [:>] |
पंक्तियाँ =: {। ( [: <, :) " 1 1 [: |: [: ( [: < " 1 [:,।> ) " 0 {:
value =: [: ( : ( {{। @। ( [: 1 & = # )) ]::, [:> [ ((( [: <[ ) = [: {।] ) # [: {:] )। [>]
pr =: [:, [: ( : ( [:: [] ( [: < ( [:>]], [:>]] " 0 0 ) " 0 1 [:>]] / [: ( [ : <[: पंक्तियों > ) " 0 ]
Join =: 1 : '((([[:: [:> {}।),: [: ([(<: (> 0 0)) " 1 [: {: [: 1 2 0 & |: [:>> [:, u " 0) #]) (pr y)) '

सामान्य तौर पर, इस समस्या को हल करने के लिए यह सभी कोड है। आवश्यक क्रियाएं हैं। तालिकाएँ बनाएं और आबाद करें:

ग्राहक =: createTable 'ID' ; ' नाम ' ?' आयु ' ?' वेतन '
आदेश =: createTable 'OID' ;) दिनांक ' ?' ग्राहक ' ?' राशि '

ग्राहक =: ग्राहक सम्मिलित करते हैं ( <' ID' ; 1 ) , ( <' नाम' ; ' रमेश' ) , ( <' आयु' ; 32 ) , ( <' वेतन' ; 2000 ;
ग्राहक =: ग्राहक सम्मिलित करते हैं ( <' ID' ; 2 ) , ( <' नाम' ; ' खिलन' ) , ( <' आयु' ; 25 ) , ( <' वेतन' ; 1500 ;
ग्राहक =: ग्राहक सम्मिलित करते हैं ( <' ID' ; 3 ) , ( <' नाम' ; ' कौशिक' ) , ( <' आयु' ; 23 ) , ( <' वेतन' ; 2000 )
ग्राहक =: ग्राहक सम्मिलित करते हैं ( <' ID' ; 4 ) , ( <' नाम' ; ' चैताली' ) , ( <' आयु' ; 25 ) , ( <' वेतन' ; 6500 )
ग्राहक =: ग्राहक सम्मिलित करते हैं ( <' ID' ; 5 ) , ( <' नाम' ; ' हार्दिक' ) , ( '' आयु ' ; 27 ) , ( <' वेतन ' ; 8500 )
ग्राहक =: ग्राहक सम्मिलित करते हैं ( <' ID' ; 6 ) , ( <' नाम' ; ' कोमल' ) , ( '' आयु '' ; 22 ) , ( <' वेतन' ; 4500 )
ग्राहक =: ग्राहक सम्मिलित करते हैं ( <' ID' ; 7 ) , ( <' नाम' ; ' Muffy' ) , ( '' आयु ' ; 24 ) , ( <' वेतन ' ; 10000 )

आदेश =: आदेश सम्मिलित करें ( <' OID' ; 102 ) , ( <' दिनांक' ; ' 2009 - 10 - 08' ) , ( <' CustomerID' ; 3 ) , ( <' राशि' ; 3000 ;
आदेश =: आदेश सम्मिलित करें ( <' OID' ; 100 ) , ( <' दिनांक' ; ' 2009 - 10 - 08' ) , ( <' CustomerID' ; 3 ) , ( <' राशि' ; 1500 ;
आदेश =: आदेश सम्मिलित करें ( <' OID' ; 101 ) , ( <' दिनांक' ; ' 2009 - 11 - 20' ) , ( <' CustomerID' ; 2 ) , ( <' राशि' ; 1560 )
आदेश =: आदेश डालें ( <' OID' ; 103 ) , ( <' दिनांक' ; ' 2008 - 05 - 20' ) , ( <' CustomerID' ; 4 ) , ( <' राशि' ; 2060 )


आइए देखें कि हमारी तालिका में:

ग्राहकों

आईडी	नाम	आयु	वेतन
1 2 3 4 5 6 7	रमेश Khilan कौशिक चैताली हार्दिक कोमल Muffy	32 25 23 25 27 22 24	2000 1500 2000 6500 8500 4500 10000

आदेश

OID	तिथि	CustomerID	मात्रा
102 100 101 103	2009-10-08 2009-10-08 2009-11-20 2008-05-20	3 3 2 4	3000 1500 1560 2060

और विधेय के साथ क्वेरी:

(( [: 2000 और > 'राशि' और मूल्य ) *। 'ग्राहक' और मूल्य = 'आईडी' और मूल्य ) ग्राहक शामिल हों ; < आदेश

आईडी	नाम	आयु	वेतन	OID	तिथि	CustomerID	मात्रा
2 3	Khilan कौशिक	25 23	1500 2000	101 100	2009-11-20 2009-10-08	2 3	1560 1500

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

उदाहरण वास्तव में जटिल नहीं है, क्योंकि सरणियाँ कुछ हद तक तालिकाओं के समान होती हैं, और J आयतों में बक्से (बक्से) खींचता है, जिससे आप तुरंत तालिकाओं को प्रदर्शित कर सकते हैं।

2. सुडोकू सॉल्वर

i = :, (( , | | :) i। 9 9 ) ,,। / , / i 4 $ 3
c =: ( # = [: # ~। ) @ -। और ०
t =: [: ( [ ( [[: * / _9: c \ ]] " 1 #] ) i & {+ " 1 1 ( >: i। 9 ) * / [: i & = i। और ०
r =: [:, ` $: @। ( 0: ई। )) [:; ( < @ t ) " १
s =: 9 9 और $ @ r @ ,


यह सब कोड है। एक इनपुट मैट्रिक्स बनाएं:
] एम =: ९ ९ $ "। " 0 '20037000900920000700100004002000000000800090000600004090010000800007600400089001'
2 0 0 3 7 0 0 0 9
0 0 9 2 0 0 0 0 7
0 0 1 0 0 4 4 0 0 2
0 5 0 0 0 0 0 8 0 0
0 0 8 0 0 0 0 9 0 0
0 0 6 0 0 0 0 4 4 0
९ ० ० १ ० ० ५ ० ० १
8 0 0 0 0 7 6 0 0
४ ० ० ० 0 ९ ० ० १

इस पर क्रिया को लागू करें और समाधान प्राप्त करें:
एस.एम.
2 8 4 3 7 5 1 6 9
6 3 9 2 1 8 4 5 7
5 7 1 9 6 4 3 8 2
१ ५ २ ४ ९ ६ 3। ३
3 4 8 7 5 2 9 1 6
९ ६ 8 ३ ३ १ २ ४ ५
९ ६ 3 १ ४ ३ ३ ५ २ 3
8 1 3 5 2 7 6 9 4
4 2 5 6 8 9 7 3 1

3. प्रस्तावना

मैं अधिक व्यावहारिक कार्य के लिए जे कोड दिखाना चाहता हूं और मैट्रिसेस / सरणियों के करीब नहीं होना चाहिए। मुझे संदेह था कि वेक्टर दृष्टिकोण पार्सिंग के लिए उपयुक्त है। पद के लिए एक सरल कार्य चुनने के लिए विचार आया, जिसका समाधान पार्सिंग से जुड़ा हुआ है। मैं प्रोलॉग लागू करता हूं। अधिक सटीक, सभी प्रोलॉग नहीं, क्योंकि कार्य व्यावहारिक नहीं है और आप अधिक समय और प्रयास नहीं करना चाहते हैं। यह प्रोलॉग का एक सबसेट होगा, यह दिखाने के लिए, सिद्धांत रूप में, टैसिट रिकॉर्डिंग फॉर्म भी ऐसे कार्यों के लिए उपयुक्त है। इस प्रोलॉग में, यदि आप इसे कॉल कर सकते हैं, तो एक क्लिपिंग भी नहीं होगी। केवल सरल तथ्य और नियम, संचालन "और", "या"। तो कोड:

frq =: [: -। [: ( 2: | + / ) \ '' '' & = |
sp =: ( # @ [ ) ( [: <[}। [:>]] " 0 0 [ ( ] < / ~ । ~ : + / \ e *। [: frq ] ) ।
spf =: [: <[: ( [: ',' & sp [: -। & ')' = ' और ' (' { " 0 1 ,। और ', ' ) >
cl =: # ~ [: - ई। & ( 33 {। A. ) *। frq
parse =: [: ( [: <(: ( spf @ {। ) , ( })। ( [: <[: ( [<: <[<: spf " 0 [: '),' & sp > ) " 0। [: ');' & sp [:> {:) @ (( 2: = # ))) ::: ': -' & sp > ) " 0 _1:}। [: '।" और सपा सीएल

isVar =: [: ( 91 & > *। 64 & < ) [: a। & i। [: {।>
बदलें =: (( ) i। ~ [: {। [ ] { ( [: {: [ ) ,] ` ( [: <[$: [:>]] @! ( [: ३२ & = [: ३] ! : 0 [:>]] ) " 2 0
gp =: [:> [: {।>
gv =: [: ( # ~ [: + / / " 1 .Var " 0 ) ,।
सूट =: ( [ ( 0: ` ( [: ( # = [: # [: ~] [: {| |] [: ~ [! ~: ( # ~ [:] |]: isVar " 0 [: | {: | :) gv ) *। ( [: *। / [: +। / [: ( isVar " 0 , = / ) , :) ) @। (( [: # [ ] = [: #] )। [: gp ] ) " 1 0 #]
sr =: [ ( ] ( ~ की जगह : [ ] |:] " 2 [: ( [ ( । :: [ isVar {:) " 1 #] ) [ gv ~ [: gp ] ) " 1 0 सूट
groupVars =: [: ( [: <> $ ~ 2:, ~ [: - # ] " 1 [:> [: ( [: <[<: > ( > @ [ ) ( [: <, " 1 1 ) "" 2 2 ( > @ ] )) / ] < / ~ ~ [: {| |
isRuleTrue =: ( [: + / । ( [: *। / ] ( isTrue ~ [:>]] " 1 0 [:> [ ] " 0 1 ) ` ( 0: <[: # getVarsFrRule ) @। ( 0: <# @ gv @ ; @ ; @ [ )
isTrue =: ] (( a: & e। @ ] ) +। [: +। / [ ( isRuleTrue ~ [:>]] " 1 0 [: -। a: a ]] [: {: [: | [: -। & ( a :, a :) [: ( 0 2 $ a :) & , [:> sr
getVars = :; (( [: <[::। ~ ( > @ {। @ ] gv [: gp ] ) ` (( > @ {{ @ । @ ) $: ( << @ gp @ ] ) ( [ बदलें ~ ]: |: [:>]] " 0 0 ( }। @ [ ) GetVarsFromRule ~ [:> [: {: [:>]] @ @ ( (:: <: [[#:>]] ) " 1 0 sr
getVarsFromRule =: ] ( [ ( {: {।] ) # ~ [ ( isRuleTrue ~ [:>]] " 1 0 [: {:]] [: ] [] [] [] : [ ] [:>]] " 1 0 [:] ` groupVars @। ( 0: <# ) [: ~। [:; [:]; ( [: <[ getVars ~ [:>]] " 1 0 [:;]

लक्ष्य =: ( [: < S: 0 [: {। [: parse [:, & '। ]] ) ( [: { और ( > ' नहीं ' ; ' हां ' ) अब )) ( [: ] (( > @ {। ) , [: '=' & ,, [:> {:) @। ( 2: = # )) " 1 [:> getVars ) @। ( [: + / / [: IsVar " 0 [ ) ( [: पार्से [ )

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

कोड को प्रोलॉग पर सेट करते हैं:
prolog_code =: 0 : 0
नर (जेफ)।
नर (फ्रेड)।
महिला (मेरी)।
माता-पिता (जेफ, विंस, जेन)।
माता-पिता (मेरी, विन्स, जेन)।

बहन_ऑफ़ (एक्स, वाई): - महिला (एक्स),
माता-पिता (एक्स, एफ, एम),
माता-पिता (Y, F, M)।
)

और सवालों की एक जोड़ी।
"क्या मैरी फ्रेड के लिए एक बहन है?":
prolog_code गोल 'बहन_ऑफ (मेरी, फ्रेड)'
नहीं
"किसे बहन की जरूरत है?":
prolog_code गोल 'बहन_ऑफ (मेरी, एक्स)'
एक्स = जेफ

एक्स = मेरी

निष्कर्ष

मुझे उम्मीद है कि आप जे पर संक्षेप में जटिल समस्याओं को हल करने के लिए प्रेरित हैं। हल्कापन की कीमत पर, आपको संदेह हो सकता है।

उदाहरणों का उद्देश्य टैचीथ रूप में कोड दिखाना है। क्या आपने देखा कि कोड में व्यावहारिक रूप से कोई भी गैर-मानक पुस्तकालय क्रियाएं नहीं हैं? सभी कोड लगभग विराम चिह्न के होते हैं। ये प्राथमिक क्रिया जे हैं। बेशक, कोई भी आपको इस तरह लिखने के लिए मजबूर नहीं करता है, बिना अपने क्रियाओं को दर्ज किए, उन्हें सार्थक नाम दिए बिना। लेकिन उच्च स्तर के जे का प्रस्ताव है, कोड की संक्षिप्तता के आधार पर, नए नामों का परिचय न देना। एक नया कोड बनाने के प्रयासों की लागत छोटी है, जो इस तथ्य की ओर जाता है कि कम बार आप नाम के पीछे कोड छिपाना चाहते हैं। सामान्य तौर पर, समय के साथ, यह इस तथ्य की ओर जाता है कि जे में प्रोग्रामर एक ही क्रिया को पढ़ता है, जो कई नहीं हैं, और अंततः कोड को पढ़ने के लिए बेहतर और बेहतर सीखता है। कोड स्पष्ट और स्पष्ट हो रहा है।

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

J एक भाषा के रूप में एक उच्च प्रवेश सीमा है। सबसे पहले, यह व्यावहारिक रूप से अपठनीय है। सभी क्रियाओं का अध्ययन करने के बाद, आप शायद ही इस पर लिख सकते हैं, लेकिन आप अपना कोड भी नहीं पढ़ सकते हैं। लेकिन समय के साथ, आप इसे आसान और आसान कर सकते हैं। अन्य भाषाओं के साथ ऐसा नहीं होगा।

साथ ही, यह उल्लेख किया जाना चाहिए कि इसका यह अर्थ नहीं है कि J के पास खराब समर्थन है और इसमें पर्याप्त पुस्तकालय नहीं हैं। एक्सेल फाइल, डेटाबेस के साथ काम करने, वीडियो के साथ काम करने से पहले से ही बहुत सारे घटनाक्रम हैं। इसके अलावा J बहु-प्रतिमान है, इस पर न केवल मौन रूप में लिखा जा सकता है, बल्कि अनिवार्य भी है। छोरों और शाखाओं के साथ। त्रुटि से निपटने के साथ। J OOP का समर्थन करता है।

J के साथ काम करना कोडिंग की तरह नहीं है, बल्कि एक सूत्र की व्युत्पत्ति है। सबसे पहले, आप कोड में सहकर्मी होंगे, टाइपिंग की गति बहुत कम है। लेकिन इस सब के साथ, परिणाम, यहां तक ​​कि पहली बार में, अन्य भाषाओं की तुलना में तेज होगा। अतिरिक्त-बड़े अनुभव और कोड की पठनीयता के बिना भी, समय के साथ यह पता चलता है कि जम्मू में किसी समस्या को हल करने के लिए बैठना किसी अन्य, अधिक परिचित भाषा में हल करने की तुलना में बहुत आसान लगता है। जे के साथ काम करना एक शक्तिशाली कैलकुलेटर के साथ काम करने जैसा है, न कि प्रोग्रामिंग भाषा। आपको कोई एहसास नहीं है कि आप सदियों से कुछ बना रहे हैं। परिणाम प्राप्त करने की गति कोडिंग में अधिक साहस देती है और आप आसानी से विभिन्न विकल्पों की कोशिश कर सकते हैं।

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

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

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

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

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

संदर्भ

1. आधिकारिक वेबसाइट: www.jsoftware.com
2. मैं एक उत्कृष्ट लेख पढ़ने का सुझाव देता हूं - प्रोग्रामिंग भाषा जे, परिचय