🌆 💥 👿 दूसरी प्रोग्रामिंग लैंग्वेज नहीं। भाग 2: प्रतिनिधित्व तर्क 🥤 🔯 🛌🏿

LsFusion भाषा और मंच त्रयी का दूसरा भाग। पहला भाग यहाँ पाया जा सकता है ।

यह डेटा को मिलाने और उपयोगकर्ता या अन्य सूचना प्रणाली को प्रदर्शित करने से संबंधित हर चीज पर प्रतिनिधित्व के तर्क पर ध्यान केंद्रित करेगा।

यह स्पष्ट है कि कई लोग फाइटर की प्रस्तुति को देखने के लिए इतने इच्छुक नहीं हो सकते हैं, और वे एक वास्तविक लड़ाई देखना चाहेंगे, यदि संभव हो तो रक्त के साथ (और यह होगा, क्योंकि पिछले लेखों की चर्चा ने संभावित प्रतियोगियों के असुरक्षित स्थानों को बेहतर ढंग से समझने में मदद की और इसे कहां हराया है) । लेकिन दो बातों पर विचार करना होगा:

a) यह हैबर है। यही है, एक तकनीकी संसाधन, वे यहां सुंदर चित्रों और विज्ञापन नारों को पसंद नहीं करते हैं - कुछ कहने के लिए, आपको इस पर विवरण की आवश्यकता है कि आप इसे कैसे प्राप्त करने जा रहे हैं।
बी) यह सूचना प्रणाली के विकास के लिए एक बाजार है, और यह वजन घटाने वाले उत्पादों के लिए बाजार के समान है। यहां, हर कोई कहता है कि हमारे पास एक त्वरित और आसान है। लेकिन जब विवरण की बात आती है, जिसमें, जैसा कि आप जानते हैं, शैतान झूठ बोलता है, या तो सरलतम CRUD का उपयोग उदाहरणों के रूप में किया जाता है या वे विभिन्न तरकीबों का सहारा लेते हैं: वे कोड के कुछ स्निपेट्स दिखाते हैं, और मुख्य भाग को शब्दों के साथ छिपाते हैं "यह कोई बात नहीं है" "," एक दो मिनट में पूरा हो गया "और ऐसा ही सब कुछ।

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

लेकिन पर्याप्त गीतात्मक खुदाई, हम विचारों के तर्क के ~~लड़ाकू~~ विवरण की ~~प्रस्तुति पर~~ लौटते हैं।

डोमेन लॉजिक (पहले लेख) की तरह, lsFusion में प्रेजेंटेशन लॉजिक की सभी अवधारणाएं एक स्टैक हैं:

और यह इस स्टैक के क्रम में है कि मैं उनके बारे में बात करूंगा।

सामग्री की तालिका

आकार

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

फ़ॉर्म को तार्किक रूप से दो भागों में विभाजित किया जा सकता है:

प्रपत्र की संरचना यह निर्धारित करती है कि फ़ॉर्म क्या डेटा दिखाता है।
प्रपत्र की प्रस्तुति निर्धारित करती है कि यह इस डेटा को कैसे प्रदर्शित करता है।

आकार की संरचना

हम स्वाभाविक रूप से, संरचना की संरचना के साथ शुरू करते हैं।

वस्तुएं

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

प्रत्येक फॉर्म ऑब्जेक्ट के लिए, आपको इसकी कक्षा निर्धारित करने की आवश्यकता है। यह वर्ग या तो आदिम (बिल्ट-इन) या ऑब्जेक्ट (कस्टम) हो सकता है।

FORM currentBalances ' '
OBJECTS s = Stock, i = Item // ,
;

प्रपत्र में वस्तुओं को जोड़ने के क्रम के अनुसार, वस्तुओं की एक क्रमबद्ध सूची बनाई जाती है। तदनुसार, वस्तुओं के एक निश्चित सेट के लिए अंतिम ऑब्जेक्ट को इस सूची में अधिकतम सीरियल नंबर के साथ इस सेट से एक ऑब्जेक्ट कहा जाएगा (जो कि सबसे हाल का है)।

किसी भी समय फॉर्म पर प्रत्येक वस्तु का एक वर्तमान मूल्य है। इसका परिवर्तन प्रस्तुति के आधार पर होता है, या तो इंटरैक्टिव प्रस्तुति में उपयोगकर्ता की संबंधित क्रियाओं के परिणामस्वरूप, या स्थिर प्रतिनिधित्व में डेटा पढ़ने की प्रक्रिया में "वस्तुतः"।

गुण और कार्य

प्रपत्र पर ऑब्जेक्ट्स को परिभाषित करने के बाद, आप गुणों और कार्यों को जोड़ सकते हैं, ऊपर वर्णित वस्तुओं को तर्क के इनपुट के रूप में प्रतिस्थापित कर सकते हैं।

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

प्रदर्शन की वस्तु

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

FORM currentBalances ' '
OBJECTS s = Stock, i = Item // ,
PROPERTIES name(s), name(i), currentBalance(s, i)
;

फिर, गोदाम के नाम के लिए, प्रदर्शन ऑब्जेक्ट एस (गोदाम) होगा, और माल और शेष राशि के नाम के लिए, मैं (माल)।

हालांकि, यदि आवश्यक हो, तो डेवलपर प्रदर्शन ऑब्जेक्ट को स्पष्ट रूप से निर्दिष्ट कर सकता है (उदाहरण के लिए, एक इंटरैक्टिव दृश्य में संपत्ति को गोदामों की तालिका में शेष के साथ दिखाते हैं, सामान नहीं)।

फिल्टर और छंटनी

प्रत्येक फॉर्म के लिए, डेवलपर फ़िल्टर और ऑर्डर सेट कर सकता है जो फॉर्म पर देखने / चयन के लिए उपलब्ध वस्तुओं की सूची को सीमित करेगा, साथ ही जिस क्रम में उन्हें प्रदर्शित किया जाएगा।

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

FORM currentBalances ' '
OBJECTS s = Stock, i = Item // ,
PROPERTIES name(s), name(i), currentBalance(s, i)
FILTERS currentBalance(s, i) OR isActive(i)
;

फॉर्म स्क्रीनशॉट

उत्पादों को प्रदर्शित करते समय, केवल वही उत्पाद जो संतुलन पर हैं या सक्रिय के रूप में चिह्नित हैं, प्रदर्शित किए जाएंगे।

सॉर्ट्स को उस रूप में गुणों की एक सूची के रूप में परिभाषित किया जाता है जिसमें ऑर्डर ऑब्जेक्ट प्रदर्शित किए जाने चाहिए। अन्यथा, सब कुछ फिल्टर के समान है।

वस्तुओं का समूह

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

FORM currentBalances ' '
OBJECTS (s = Stock, i = Item) //
PROPERTIES name(s), name(i), currentBalance(s, i)
FILTERS currentBalance(s, i) OR isActive(i)
;

फॉर्म स्क्रीनशॉट

तदनुसार, लगभग हर जगह, फॉर्म की एकल वस्तुओं के बजाय पहले और बाद में, आप वस्तुओं के समूहों का उपयोग कर सकते हैं।

वास्तव में, यह वही है जो प्रलेखन में किया गया था: अधिक सामान्य शब्द "वस्तुओं के समूह" का उपयोग हर जगह किया जाता है, लेकिन इस लेख में चीजों को जटिल नहीं करने के लिए (और कई वस्तुओं से मिलकर वस्तुओं का समूह बहुत कम बार उपयोग किया जाता है), यह वस्तुओं के समूहों के बारे में भूलने और गिनने का निर्णय लिया गया था। वस्तुओं का एक समूह हमेशा एक ही वस्तु से युक्त होता है और, तदनुसार, अधिक जटिल "वस्तुओं के समूह" और "वस्तुओं के सेट" के बजाय हर जगह "ऑब्जेक्ट" शब्द का उपयोग करें।

संपत्ति समूह

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

स्तंभ की वस्तुएँ

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

FORM currentBalances ' '
// ,
//
OBJECTS s = Stock, i = Item
//
PROPERTIES name(i), currentBalance(s, i) COLUMNS (s) HEADER name(s)
FILTERS isActive(i), isActive(s)
;

फॉर्म स्क्रीनशॉट

तो, क्या रूप दिखाता है, कमोबेश यह पता चल गया है कि चलो यह कैसे कर सकते हैं।

प्रपत्र प्रस्तुत करना

तीन फार्म प्रस्तुतियाँ हैं:

स्क्रीनशॉट देखें

इंटरैक्टिव:

मुद्रण:

संरचित:

इंटरएक्टिव। एक दृश्य जिसके साथ उपयोगकर्ता बातचीत कर सकता है वह विभिन्न घटनाओं को ट्रिगर करके डेटा और वर्तमान वस्तुओं को बदल सकता है। दरअसल, इस प्रतिनिधित्व को आमतौर पर एक रूप कहा जाता है।
मुद्रित। इसे आमतौर पर एक रिपोर्ट कहा जाता है - सभी फॉर्म डेटा अपलोड करना और इसे ग्राफिकल रूप में प्रस्तुत करना। जिसमें उन्हें छापने की संभावना भी शामिल है (जहां से इसका नाम मिला)।
संरचित - विभिन्न संरचित स्वरूपों (JSON, XML, DBF, आदि) में फॉर्म का प्रतिनिधित्व। आमतौर पर अन्य प्रणालियों के साथ आगे एकीकरण के लिए उपयोग किया जाता है।

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

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

प्रदर्शनों का वर्णन शुरू होगा, शायद, सबसे कठिन - इंटरैक्टिव प्रस्तुति के साथ।

इंटरएक्टिव प्रस्तुति

एक इंटरैक्टिव दृश्य में, प्रपत्र ऑब्जेक्ट तालिका के रूप में प्रदर्शित होते हैं। इस तालिका की पंक्तियाँ डेटाबेस में उन वस्तुओं से मेल खाती हैं जो निर्दिष्ट फिल्टर, कॉलम को संतुष्ट करती हैं, बदले में, गुणों के अनुरूप हैं।

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

currentBalance ' ' (Stock s) = GROUP SUM currentBalance(s, Item i);
FORM currentBalances ' '
OBJECTS s = Stock, i = Item
// currentBalance(s) ,
PROPERTIES name(s), currentBalance(s) PANEL ,
name(i), currentBalance(s, i)
FILTERS currentBalance(s, i)
;

फॉर्म स्क्रीनशॉट

प्रपत्र ऑब्जेक्ट के वर्तमान मूल्य को बदलना या तो उपयोगकर्ता द्वारा तालिका की वर्तमान पंक्ति को बदलने के परिणामस्वरूप होता है, या किसी विशेष खोज ऑपरेटर (SEEK) का उपयोग करके बनाई गई क्रिया करने के परिणामस्वरूप होता है।

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

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

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

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

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

वस्तु पेड़

तालिकाओं के अलावा, मंच आपको पेड़ों के रूप में वस्तुओं के प्रदर्शन को व्यवस्थित करने की भी अनुमति देता है, दोनों फ्लैट ("एक दूसरे की तालिकाओं में नेस्टेड") और पुनरावर्ती (उदाहरण के लिए, डेटाबेस में "नेस्टेड" ऑब्जेक्ट)।

फ्लैट पेड़, वास्तव में, तालिकाओं का एक सामान्यीकरण है, जब एक ही बार में कई तालिकाओं को "संयुक्त" किया जाता है:

FORM currentBalances ' '
TREE tree s = Stock, i = Item
//
//
PROPERTIES name(s), currentBalance(s),
name(i), currentBalance(s, i)
;

फॉर्म स्क्रीनशॉट

यह एक अपेक्षाकृत जटिल तंत्र है और शायद ही कभी अभ्यास में उपयोग किया जाता है, इसलिए हम इस पर विस्तार से ध्यान नहीं देंगे।

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

parent = DATA ItemGroup (ItemGroup) IN base;
group = DATA ItemGroup (Item) IN base;
//
level '' (ItemGroup child, ItemGroup parent) = RECURSION 1 AND child IS ItemGroup AND parent = child STEP 1 IF parent = parent($parent);
currentBalance ' ' (ItemGroup ig, Stock s) = GROUP SUM currentBalance(s, Item i) IF level(ig, group(i));

FORM currentBalances ' '
OBJECTS s=Stock PANEL //
PROPERTIES (s) name
TREE tree ig = ItemGroup PARENT parent, i = Item // /
PROPERTIES name(ig), currentBalance(ig, s)
PROPERTIES name(i), currentBalance(s, i)
FILTERS group(i) = ig
;

फॉर्म स्क्रीनशॉट

उपयोगकर्ता प्रपत्र प्रबंधन

सिस्टम के बेहतर एर्गोनॉमिक्स को सुनिश्चित करने के लिए (सभी के लिए फॉर्म नहीं बनाने के लिए), फॉर्म की इंटरैक्टिव प्रस्तुति को स्थापित करने के लिए संचालन का हिस्सा उपयोगकर्ताओं द्वारा स्वयं किया जा सकता है। उदाहरण के लिए, ऐसे ऑपरेशन हैं:

तालिकाओं की स्थापना (दृश्य कॉलम, ऑर्डर, फोंट, आदि),
कस्टम फ़िल्टर और प्रकार बनाना,
स्तंभ मानों द्वारा डेटा समूहीकृत करना,
एक तालिका प्रिंट करें और इसे एक्सेल पर अपलोड करें।

इसके अलावा, डेवलपर तथाकथित फ़िल्टर समूह बना सकता है, जिसे उपयोगकर्ता स्वतंत्र रूप से चालू / बंद कर सकता है। उदाहरण के लिए:

EXTEND FORM currentBalances //
FILTERGROUP stockActive // , , /
FILTER '' active(st) 'F11' // , F11
FILTERGROUP bal
FILTER ' ' currentBalance(st, sk) > 0 'F10'
FILTER ' ' currentBalance(st, sk) < 0 'F9'
FILTER ' ' currentBalance(st, sk) 'F8' DEFAULT
FILTER ' ' NOT currentBalance(st, sk) 'F7'
;

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

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

ऑब्जेक्ट ऑपरेटर्स

फॉर्म के साथ काम करने के सबसे सामान्य परिदृश्यों में से एक वस्तु को जोड़ना / हटाना है, साथ ही इसे नए रूप में संपादित करना भी है। इस तरह के परिदृश्यों को लागू करने के लिए, प्लेटफॉर्म में ऑपरेटरों का एक पूर्वनिर्धारित सेट होता है जो आपको फॉर्म क्रिएशन स्पेस में एक शब्द में आवश्यक क्रियाओं को बनाने की अनुमति देता है:

नई - एक वस्तु बनाएँ
EDIT - एक वस्तु का संपादन
NEWEDIT - एक वस्तु का निर्माण और संपादन
DELETE - किसी ऑब्जेक्ट को हटाएं

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

FORM teams
OBJECTS t=Team
// /
PROPERTIES (t) NEWSESSION NEW , EDIT , DELETE
OBJECTS p=Player
FILTERS team(p)=t
//
PROPERTIES (p) NEW , DELETE
;

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

FORM order ''
OBJECTS o = Order PANEL
PROPERTIES (o) date, number

OBJECTS d = OrderDetail
PROPERTIES (d) nameBook, quantity, price, NEW , DELETE
FILTERS order(d) = o

EDIT Order OBJECT o
;

इसी तरह, किसी दिए गए वर्ग की वस्तुओं के चयन के लिए रूपों को नए सिरे से परिभाषित किया जाता है।

आकार डिजाइन

अधिकांश मौजूदा GUI के साथ, एक फॉर्म की इंटरैक्टिव प्रस्तुति का डिज़ाइन एक पदानुक्रम है जिसके नोड्स घटक हैं। घटक, बदले में, हो सकते हैं:

कंटेनर - ऐसे घटक जिनमें अन्य घटक होते हैं।
बुनियादी घटक - मूल तत्वों के चित्रमय निरूपण: टेबल, संपत्ति पैनल, फिल्टर समूह, आदि।

कंटेनरों के अंदर घटकों की व्यवस्था करने का तंत्र अनिवार्य रूप से CSS फ्लेक्सिबल बॉक्स लेआउट को दोहराता है (और इसके साथ वेब क्लाइंट में इसे लागू किया जाता है), इसलिए हमने इस तंत्र पर बहुत विस्तार से ध्यान नहीं दिया।

ध्यान दें कि फॉर्म का डिज़ाइन आमतौर पर खरोंच से नहीं बनता है (क्योंकि यह काफी समय लेने वाला है)। आमतौर पर, फ़ॉर्म की संरचना के आधार पर एक फॉर्म डिज़ाइन स्वचालित रूप से बनाई जाती है, और फिर डेवलपर केवल इसे थोड़ा बदलता है: उदाहरण के लिए, एक नया कंटेनर जोड़ता है और मौजूदा घटकों को इसमें स्थानांतरित करता है:

डिफ़ॉल्ट रूप डिजाइन उदाहरण

FORM myForm 'myForm'
OBJECTS myObject = myClass
PROPERTIES (myObject) myProperty1, myProperty2 PANEL
FILTERGROUP myFilter
FILTER 'myFilter' myProperty1(myObject)
;

डिफ़ॉल्ट डिजाइन में कंटेनरों और घटकों की पदानुक्रम इस तरह दिखाई देगी:

FORM myForm ' '
OBJECTS u = CustomUser
PROPERTIES (u) name, NEW , DELETE

OBJECTS c = Chat
PROPERTIES (c) message, NEW , DELETE
FILTERS user(c) = u
;

DESIGN myForm {
NEW middle FIRST {
type = CONTAINERH ;
fill = 1 ; //
MOVE BOX (u);
MOVE BOX (c);
}
}

फॉर्म स्क्रीनशॉट

फॉर्म डिजाइन 2.0 (प्रतिक्रिया)

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

फॉर्म स्क्रीनशॉट

लेकिन अगर सास बी 2 बी, या यहां तक कि बी 2 सी (उदाहरण के लिए, कुछ इंटरनेट बैंकिंग) की बात आती है, तो तुरंत डिजाइन को और अधिक एर्गोनोमिक बनाने के तरीके पर सवाल उठने लगते हैं।

वर्तमान चरण में, इस समस्या को हल करने के लिए, एक विशेष जावास्क्रिप्ट पुस्तकालय विकसित किया गया है, जिसका मुख्य कार्य प्रपत्र डेटा युक्त एक विशेष js-object बनाना और अद्यतन करना है। तदनुसार, इस ऑब्जेक्ट का उपयोग रिएक्ट घटक के लिए राज्य के रूप में किया जा सकता है और इस तरह किसी भी डिजाइन और विकसित होने वाले फॉर्म की किसी भी अतिरिक्त अन्तरक्रियाशीलता का निर्माण कर सकता है। उदाहरण के लिए:

प्रतिक्रिया का उदाहरण फ़ॉर्म (कोडैंडबॉक्स पर)

या अधिक जटिल उदाहरण - ड्रॉप-डाउन सूचियों और इसके लिए REST (या बल्कि स्टेटलेस) API का उपयोग करके:

ड्रॉप-डाउन सूचियों (कोडैंडबॉक्स पर) के साथ प्रतिक्रिया स्वरूप उदाहरण

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

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

साथ ही, यह दृष्टिकोण रिएक्ट मूल रूपों को उत्पन्न करने की अनुमति देगा, और इस तरह देशी मोबाइल एप्लिकेशन बनाने की अनुमति देगा। हालाँकि यह समस्या (देशी मोबाइल अनुप्रयोगों के साथ) हमने अभी तक बहुत गहराई से काम नहीं किया है।

सच है, हम ध्यान दें कि पुराने डिज़ाइन तंत्र का भी समर्थन किया जाएगा, क्योंकि, एक ही व्यावसायिक अनुप्रयोगों के लिए, यह पूरी तरह से अपना कार्य करता है।

प्रपत्र घटनाएँ

डोमेन ईवेंट के बाद फॉर्म ईवेंट दूसरी महत्वपूर्ण व्यवस्था है, जो क्रिया करने के लिए निर्धारित करने के लिए ज़िम्मेदार है।

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

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

changeQuantity (Order o, Book b) {
INPUT q = INTEGER DO { //
IF lastOrderDetail(o, b) THEN { // ,
IF q THEN //
quantity(OrderDetail d) <- q IF d = lastOrderDetail(o, b) WHERE order(d) = o AND book(d) = b; //
ELSE // -
DELETE OrderDetail d WHERE order(d) == o AND book(d) == b;
} ELSE
IF q THEN
NEW d = OrderDetail { //
order(d) <- o;
book(d) <- b;
quantity(d) <- q;
}
}
}

EXTEND FORM order
OBJECTS b = Book
PROPERTIES name(b) READONLY , quantity(o, b) ON CHANGE changeQuantity(o, b)
;

, – , ( , , , paste , ). . .

, , , , , , , , INPUT.

, , , , , , . उदाहरण के लिए:

FORM order
OBJECTS o = Order
PROPERTIES (o) customer ON CHANGE {
INPUT s = STRING DO {
customer(o) <- s;
IF s THEN
MESSAGE 'Customer changed to ' + s;
ELSE
MESSAGE 'Customer dropped' ;
}
}
;

, , :

,
( ),
,
.

, INPUT – . (ASK):

DELETE Order o WHERE selected(o);
ASK ' ' + ( GROUP SUM 1 IF DROPPED (Order o)) + ' . ?' DO {
APPLY ;
}

(DIALOG) , , , , .

.

, . , , . , «» . , A B, A B, A A, B (A, B) B, A B ( «» ).

, , :

:
, , A B, A ( ).

उदाहरण के लिए:

FORM myForm 'myForm'
OBJECTS A, B SUBREPORT , C, D, E
PROPERTIES f(B, C), g(A, C)
FILTERS c(E) = C, h(B, D)
;

, , , , .

LGPL – JasperReports.

, JasperReports , . , :

«» ( , O1, O2, O3,… On, O2 – O1, O3 – O2 ..) ;
, .

«» , SUBREPORT ( , -):

FORM shipment
OBJECTS s=Shipment //
PROPERTIES (s) date, customer = nameCustomer, stock = nameStock // , ( customer) ( stock)
PROPERTIES total = ( GROUP SUM quantity(ShipmentDetail d)*price(d) IF shipment(d)=s) //
OBJECTS sd=ShipmentDetail //
FILTERS shipment(sd) = s //
PROPERTIES (sd) index, item = nameItem // , ( item)
PROPERTIES (sd) price, quantity // ,
PROPERTIES sum '' = (quantity(sd) * price(sd)) // - * ( sum)
;

run() {
// 12345
PRINT shipment OBJECTS s = ( GROUP MAX Shipment s IF number(s) = '12345' )
XLSX TO exportFile;
}

JasperReports (, lsFusion). , . , JasperSoft Studio.

, lsFusion- IDEA, Eclipse, ( Eclipse JasperReports ). IDEA , language injection, jrxml-, , , , , , . , , Eclipse GrammarKit autocomplete (, ), stub-, lazy chameleon- ( ), , . .

() :

(XML, JSON) – , () -.
(DBF, CSV, XLS) – - . parent, «» -.

, (- ), , , ( ). . , .

– XML, JSON. , , JSON ( XML ).

/ JSON , : JSON-, – , – . :

JSON

/ , / :

/ : , .
X:
- X , , . इस मामले में:
  - X ,
  - ( ) X.

, / :

 JSON  ::= { JSON  ,   /    } JSON  ,   /  ::= JSON  1 | JSON   1 | JSON   1 JSON  2 | JSON   2 | JSON   2 ... JSON  M | JSON   M | JSON   M JSON  ::= "   " :   JSON   ::= "  " : { JSON   ,   /  } JSON   ::= "  " : [ { JSON   ,   /  1 }, { JSON   ,   /  2 }, ... { JSON   ,   /  N }, ]

GROUP money;

FORM shipment
OBJECTS dFrom= DATE , dTo= DATE
OBJECTS s=Shipment //
PROPERTIES (s) date, customer = nameCustomer, stock = nameStock // , ( customer) ( stock)
FILTERS dFrom <= date(s) AND date(s) <= dTo //
OBJECTS sd=ShipmentDetail //
FILTERS shipment(sd) = s //
PROPERTIES (sd) IN money index, item = nameItem, price, quantity // , ( item), , money
;

run() {
EXPORT shipment OBJECTS dFrom = 2019_02_20 , dTo = 2019_04_28 ; //
}

 { "s": [ { "date": "21.02.19", "sd": [ { "money": { "item": " 3", "quantity": 1, "price": 5, "index": 1 } } ], "stock": " 2", "customer": " 2" }, { "date": "15.03.19", "sd": [ { "money": { "item": " 1", "quantity": 1, "price": 5, "index": 1 } }, { "money": { "item": " 2", "quantity": 1, "price": 10, "index": 2 } }, { "money": { "item": " 3", "quantity": 1, "price": 15, "index": 3 } }, { "money": { "item": " 4", "quantity": 1, "price": 20, "index": 4 } }, { "money": { "item": "Milk", "quantity": 1, "price": 50, "index": 5 } } ], "stock": " 1", "customer": " 3" }, { "date": "04.03.19", "sd": [ { "money": { "item": " 1", "quantity": 2, "price": 4, "index": 1 } }, { "money": { "item": " 2", "quantity": 3, "price": 4, "index": 2 } }, { "money": { "item": " 1", "quantity": 2, "price": 5, "index": 3 } } ], "stock": " 1", "customer": " 2" }, { "date": "04.03.19", "sd": [ { "money": { "item": " 1", "quantity": 3, "price": 1, "index": 1 } }, { "money": { "item": " 2", "quantity": 2, "price": 1, "index": 2 } } ], "stock": " 1", "customer": " 2" }, { "date": "14.03.19", "sd": [ { "money": { "item": " 2", "quantity": 1, "price": 2, "index": 1 } } ], "stock": " 1", "customer": " 2" }, { "date": "17.04.19", "sd": [ { "money": { "item": " 2", "quantity": 5, "price": 6, "index": 1 } }, { "money": { "item": " 1", "quantity": 2, "price": 6, "index": 2 } } ], "stock": " 1", "customer": " 1" }, { "date": "21.02.19", "sd": [ { "money": { "item": " 3", "quantity": 1, "price": 22, "index": 1 } } ], "stock": " 2", "customer": " 1" }, { "date": "21.02.19", "sd": [ { "money": { "item": " 3", "quantity": 1, "price": 22, "index": 1 } } ], "stock": " 2", "customer": " 1" }, { "date": "20.02.19", "sd": [ { "money": { "item": " 3", "quantity": 1, "price": 22, "index": 1 } } ], "stock": " 2", "customer": " 1" } ] }

, JSON JSON-. , , IDE JSON , – JSON. , ( , , JSON- ), . / JSON .

, :

.
– , .

, , , ( ). , , , / :

run() {
EXPORT XLSX FROM item = upper(name(Item i)), currentBalance(i, Stock s),
stock = name(s), barcode(i), salePrice(i)
WHERE (name(i) LIKE '%%' OR salePrice(i) > 10 ) AND currentBalance(i, s);
}

, SELECT SQL. , , , ( , ).

, , , – .

, , , :

– .
– : .

run(Genre g) {
SHOW booksByGenre OBJECTS g=g;
PRINT booksByGenre OBJECTS g=g;
EXPORT booksByGenre OBJECTS g=g;
}

– ( ) . .

(SHOW, DIALOG)

(WAIT) – , , , , .
(NOWAIT) – .

.

, :

(FLOAT) – .
(DOCKED) – System.forms.

, – .

, , (DIALOG). (, , ), , , .

, , (INPUT), ( ), , , ( ), , , ( ).

FORM booksByGenre
OBJECTS g = Genre PANEL
PROPERTIES (g) name
OBJECTS b = Book
PROPERTIES (b) name
FILTERS genre(b) = g
;

EXTEND FORM ordersByGenre
PROPERTIES (o) nameBook
ON CHANGE {
DIALOG booksByGenre OBJECTS g = g, b = book(o) INPUT DO
book(o) <- b;
}
;

(PRINT)

( ) , JasperReports : DOC, DOCX, XLS, XLSX, PDF, HTML, RTF , JasperReports. , , , , ( , ).

, - (PREVIEW), , / . , , .

(EXPORT, IMPORT)

, , , : XML, JSON, DBF, CSV, XLS, XLSX. .

, , , – . () , () , .

– , , « », :

.
( , , , , , TRUE f(a) = b – f(a) b)

TRUE ( , , 0 , .., , , ).

// ,
inn = DATA LOCAL BPSTRING [ 9 ] (Shipment);
barcode = DATA LOCAL BPSTRING [ 13 ] (ShipmentDetail);

FORM shipments
OBJECTS s=Shipment EXTID 'shipments' // EXTID s, shipments
PROPERTIES (s) number, date, inn
OBJECTS sd=ShipmentDetail EXTID 'detail' // EXTID sd, detail
FILTERS shipment(sd) = s // shipment detail
PROPERTIES (sd) barcode, price, quantity
;

run() {
FOR jsonFile = JSONFILE ( '\{ shipments : [ ' + // jsonFile / run, {} escape'
' \{number : "13423", date : "01.01.2019", inn : "2", detail : [\{ barcode : "141", quantity : 5, price : 10 \}, \{ barcode : "545", quantity : 2, price : 11 \}] \},' +
' \{number : "12445", date : "01.02.2019", inn : "1", detail : [\{ barcode : "13", quantity : 1, price : 22 \}] \} ]\}' )
DO {
IMPORT shipments FROM jsonFile; //
FOR BPSTRING [ 9 ] inn = inn(Shipment s) DO { // inn
customer(s) <- legalEntityINN(inn); // INN
stock(s) <- GROUP MAX st AS Stock; // - ( id)
}
FOR barcode(Item item) = barcode(ShipmentDetail sd) DO //
item(sd) <- item;

APPLY ;
exportString() <- IF canceled() THEN applyMessage() ELSE ' ' ;
}
}

, , . , , , . . ( ), .

- , ( ). , , ( ). .

. , — .

– , . , , . , , .

100x100 . , , . , «» . , ( ). , . , .

. , - , , .

:

, – , , .
– forms, log, status, root, toolbar, tree, (, root, , )

FORM items;
FORM stocks;
FORM legalEntities;
FORM shipments;
hello() { MESSAGE 'Hello world' ; }
hi() { MESSAGE 'Hi' ; }

NAVIGATOR {
NEW FOLDER catalogs '' WINDOW toolbar { // ,
NEW items; // - items,
}
catalogs { //
NEW FORM stocksNavigator '' = stocks; // - stocksNavigator stocls catalogs
NEW legalEntities AFTER items; // - legalEntities catalogs items
NEW shipments;
}
NEW FOLDER documents '' WINDOW toolbar { // ,
// root,
//
NEW ACTION hi; // -
NEW ACTION h=hello; // -
MOVE shipments BEFORE h; // shipments catalogs document hello
}
}

, – , , , , , ERP-. , , « », : ? गंभीरता से? ? , -, lsFusion language-based ( SQL ABAP), library-based ( Java 1C) / . , , – domain-specific , . -, , , , . : , , , . , , , ( ).

. – , :

: , , , , , ;
: , .

, :

. «» : , , / . , , , , , , .
. control flow . , – .
SQL ( ORM). , , , .

निष्कर्ष

, , (, , , , tutorial, , , ). , , ( ) «», , lsFusion.

, , – . , . , , « . .», , ( - ).

. : « ». , . , , lsFusion SQL-. , , , – , - , . , SQL- ( ). , . , , ( , ), , , . «?», « ...?» «?».

UPD: .

दूसरी प्रोग्रामिंग लैंग्वेज नहीं। भाग 2: प्रतिनिधित्व तर्क

आकार

आकार की संरचना

वस्तुएं

गुण और कार्य

प्रदर्शन की वस्तु

फिल्टर और छंटनी

वस्तुओं का समूह

संपत्ति समूह

स्तंभ की वस्तुएँ

प्रपत्र प्रस्तुत करना

इंटरएक्टिव प्रस्तुति

वस्तु पेड़

उपयोगकर्ता प्रपत्र प्रबंधन

ऑब्जेक्ट ऑपरेटर्स

आकार डिजाइन

फॉर्म डिजाइन 2.0 (प्रतिक्रिया)

प्रपत्र घटनाएँ

(SHOW, DIALOG)

(PRINT)

(EXPORT, IMPORT)

निष्कर्ष

More articles: