घर संपादक

1सी मूल्यों की एक तालिका का निर्माण। कौन सी विधियाँ मौजूद हैं और एक साथ कई मानों की खोज कैसे करें

21 सितंबर 2011 को प्रकाशित

मानों की तालिका 1सी - भाग 3। मेटाडेटा. मान तालिका स्तंभों के माध्यम से लूपिंग

इस लेख में मैं आपको बताऊंगा कि "अज्ञात" संरचना के मानों की तालिका के साथ कैसे काम किया जाए, मानों की तालिका के कॉलमों के माध्यम से कैसे पुनरावृत्त किया जाए, कॉलम नामों का उपयोग किए बिना कॉलम और पंक्तियों से डेटा कैसे निकाला जाए। (यह आलेख स्क्रैच से 1सी; स्क्रैच से प्रोग्रामिंग 1सी; 1सी मानों की तालिका) लेखों की श्रृंखला से संबंधित है।

सामग्री को समझाने और हमारे कोड उदाहरणों को "लाइव" चलाने में सक्षम होने के लिए, हमें कुछ की आवश्यकता है 1C मानों की परीक्षण तालिका. हमारे कुछ उदाहरण मानों की तालिका से डेटा निकालेंगे, इसलिए हम तीन कॉलम "अंतिम नाम", "प्रथम नाम", "मध्य नाम" के साथ एक तालिका बनाएंगे और इसमें थोड़ी मात्रा में डेटा दर्ज करेंगे - अधिकतम 3 पंक्तियाँ :)

तो, आइए 1C मानों की एक परीक्षण तालिका बनाएं और उसे भरें:

MyTZ = नया वैल्यूटेबल; // वेरिएबल "MyTZ" MyTZ.Columns.Add("अंतिम नाम") में संग्रहीत मानों की एक नई तालिका बनाएं; // कॉलम बनाएं "अंतिम नाम" MyTZ.Columns.Add("Name"); // कॉलम "नाम" बनाएं MyTZ.Columns.Add("संरक्षक"); // "मध्य नाम" कॉलम बनाएं // हमारे मूल्यों की तालिका में पहली पंक्ति जोड़ें NewLine = MyTZ.Add(); NewString.LastName = "चपाएव"; NewLine.Name = "वसीली"; न्यूस्ट्रिंग.मध्य नाम = "इवानोविच"; // दूसरी पंक्ति जोड़ें NewLine = MyTZ.Add(); NewString.LastName = "डेज़रज़िन्स्की"; NewRow.Name = "फ़ेलिक्स"; न्यूस्ट्रिंग.मध्य नाम = "एडमंडोविच"; // तीसरी पंक्ति जोड़ें NewLine = MyTZ.Add(); NewLine.LastName = "कोटोव्स्की"; NewLine.Name = "ग्रेगरी"; न्यूस्ट्रिंग.मध्य नाम = "इवानोविच";

हमारी परीक्षण तालिका में तीन कॉलम हैं: पहला नाम, अंतिम नाम, संरक्षक नाम; और इसमें गृह युद्ध के नायकों के नाम वाली तीन पंक्तियाँ हैं।

पहला कोड नमूना एक संग्रह के रूप में 1C मान तालिका के कॉलमों की गणना कर रहा है।

// MyTZ.Columns साइकिल रिपोर्ट से प्रत्येक कॉलम के लिए TK के सभी कॉलमों के नाम प्रदर्शित करें ("कॉलम का नाम:" + कॉलम.नाम); अंतचक्र;

हमारा चक्र 1सी संदेश विंडो में सभी कॉलम नाम प्रदर्शित करेगा:

कॉलम का नाम: अंतिम नाम कॉलम का नाम: पहला नाम कॉलम का नाम: मध्य नाम

हम देखते हैं कि स्तंभों के माध्यम से पुनरावृति करने के लिए, पंक्ति पुनरावृत्ति चक्र (पिछले लेख में) के समान, एक विशेष संग्रह पुनरावृत्ति चक्र का उपयोग किया जाता है। MyTZ.कॉलम- यह 1C मान तालिका के स्तंभों का एक संग्रह है "MyTZ". संग्रह में प्रकार की वस्तुएं शामिल हैं "मूल्य तालिका कॉलम"इस प्रकार की प्रत्येक वस्तु मान तालिका का एक स्तंभ है और इसमें गुण और विधियाँ शामिल हैं। इन गुणों और विधियों तक पहुँचकर, हम एक कॉलम के बारे में आवश्यक जानकारी प्राप्त करते हैं या इसके साथ कुछ अन्य क्रियाएँ करते हैं।

उदाहरण के लिए, संपत्ति तक पहुँचना "नाम" (आम नाम) हमें वर्तमान कॉलम का नाम मिलता है।

मैं आपका ध्यान श्रृंखला के शीर्षक की ओर आकर्षित करना चाहूंगा: “सभी के लिए।” स्तंभ MyTZ.कॉलम साइकिल से" नाम के साथ चर "स्तंभ"हमारे द्वारा आविष्कार किया गया। एक ही नाम का उपयोग करना आवश्यक नहीं है. उदाहरण के लिए, आप इस वेरिएबल को अपनी पसंद के अनुसार कुछ भी कह सकते हैं "माईकरंटकॉलम"फिर उपरोक्त उदाहरण इस तरह दिखेगा:

// MyTK.Columns साइकिल रिपोर्ट से प्रत्येक MyCurrentColumn के लिए TK के सभी कॉलमों के नाम प्रदर्शित करें ("कॉलम का नाम:" + MyCurrentColumn.Name); अंतचक्र;

जब 1C निष्पादन सबसिस्टम इस प्रकार के एक चक्र का सामना करता है, तो चक्र के प्रत्येक पास के साथ यह हमारे संग्रह से एक तत्व को निर्दिष्ट नाम के साथ एक चर को निर्दिष्ट करता है, इस मामले में - एक संग्रह तत्वमूल्य तालिका कॉलम MyTZ.कॉलमऔर फिर हम उस वेरिएबल तक पहुंचते हैं जिसमें वर्तमान कॉलम होता है और संपत्ति का उपयोग करते हैं "नाम".

मैं कॉलम नाम के आगे कॉलम के संग्रह में प्रत्येक कॉलम की संख्या प्रदर्शित करने का प्रस्ताव करता हूं:

// MyTZ.Columns Cycle ColumnNumber = MyTZ.Columns.Index(Column) से प्रत्येक कॉलम के लिए मानों की तालिका के सभी कॉलमों की संख्या और नाम प्रदर्शित करें; // कॉलम नंबर प्राप्त करें कॉलमनाम = कॉलम.नाम; // कॉलम का नाम प्राप्त करें रिपोर्ट ("कॉलम संख्या:" + कॉलम संख्या + "कॉलम का नाम:" + कॉलम का नाम); अंतचक्र;

निम्नलिखित पाठ 1C संदेश विंडो में प्रदर्शित किया जाएगा:

कॉलम नंबर: 0 कॉलम नाम: अंतिम नाम कॉलम नंबर: 1 कॉलम नाम: पहला नाम कॉलम नंबर: 2 कॉलम नाम: मध्य नाम

कृपया ध्यान दें कि 1C मान तालिका में स्तंभों को मान तालिका की पंक्तियों की तरह, शून्य से शुरू करके क्रमांकित किया गया है।

1C मान तालिका में स्तंभों की संख्या

मानों की तालिका में स्तंभों की संख्या जानने के लिए, हम स्तंभों के संग्रह पर "गणना ()" विधि का उपयोग करते हैं।

कॉलमों की संख्या = MyTZ.Columns.Quantity(); रिपोर्ट(स्तंभों की संख्या);

स्क्रीन पर "3" नंबर प्रदर्शित होगा। दरअसल, हमारी तालिका में तीन कॉलम हैं: "अंतिम नाम", "प्रथम नाम", "संरक्षक"

किसी कॉलम ऑब्जेक्ट को उसकी संख्या (सूचकांक) द्वारा प्राप्त करना और कॉलम इंडेक्स का उपयोग करके कॉलम की गणना करना

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

खाते के लिए = 0 MyTZ.Columns.Quantity() द्वारा - 1 चक्र करंटकॉलम = MyTZ.Columns[Act]; रिपोर्ट(वर्तमान कॉलम.नाम); अंतचक्र;

स्क्रीन पर हमें निम्नलिखित मिलेगा

पूरा नाम

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

किसी वस्तु की संपत्ति और किसी वस्तु की विधि को कभी भी भ्रमित नहीं करना महत्वपूर्ण है।

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

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

यदि मैं विधि कॉल में गलत तरीके से कोष्ठक लगाना भूल जाऊं तो दुभाषिया यही लिखेगा MyTZ.कॉलम.मात्रा("मात्रा()" के बाद कोष्ठक के बिना):

ऑब्जेक्ट फ़ील्ड नहीं मिला (मात्रा)

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

स्तंभ संख्याओं का उपयोग करके 1C मानों की तालिका से डेटा प्राप्त करना

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

फर्स्टलाइन = MyTK; // पहली पंक्ति प्राप्त करें (शून्य से क्रमांकित) फर्स्टकॉलमवैल्यू = फर्स्टरो; // पहले कॉलम का मान प्राप्त करें (कॉलम नंबरिंग भी स्क्रैच से है) रिपोर्ट (फर्स्ट कॉलम का मान); // तालिका की पहली पंक्ति में पहले कॉलम का मान प्रदर्शित करें

स्क्रीन प्रदर्शित होगी:

चपाएव

सबसे पहले, हमने [...] ऑपरेटर का उपयोग करके मूल्य तालिका तक पहुंच कर एक मूल्य तालिका पंक्ति ऑब्जेक्ट प्राप्त किया। (यदि आप भूल गए हैं कि यह कैसे करना है, तो आप पिछले लेख देख सकते हैं) हमने ऑपरेटर के अंदर तर्क "0" पारित किया है। यह मान तालिका की पहली पंक्ति का सूचकांक है. फर्स्टलाइन = MyTK;

इसके अलावा, हमें [...] ऑपरेटर का उपयोग करके स्ट्रिंग ऑब्जेक्ट तक पहुंचने का भी अधिकार है। इस ऑपरेटर के अंदर हमने मान तालिका का कॉलम नंबर पास किया, इस मामले में भी "0"। और इस प्रकार, हमें वर्तमान तालिका पंक्ति क्रमांकित "0" के लिए "0" क्रमांकित कॉलम का मान प्राप्त हुआ। हमने इस मान को स्क्रीन पर प्रदर्शित किया और यह स्ट्रिंग "चपाएव" का प्रतिनिधित्व करता है।

आइए अपने उदाहरण को थोड़ा जटिल बनाएं:

फर्स्टलाइन = MyTK; // पहली पंक्ति प्राप्त करें (शून्य से क्रमांकित) रिपोर्ट (फर्स्टलाइन); // तालिका रिपोर्ट (फर्स्टरो) की पहली पंक्ति में पहले कॉलम का मान प्रदर्शित करें; // तालिका रिपोर्ट (फर्स्टरो) की पहली पंक्ति में दूसरे कॉलम का मान प्रदर्शित करें; // तालिका की पहली पंक्ति में तीसरे कॉलम का मान प्रदर्शित करें

अब हमने अपनी मान तालिका की पहली पंक्ति के सभी तीन स्तंभों से मान प्रदर्शित कर दिए हैं:

चपाएव वसीली इवानोविच

अब मैं इस उदाहरण को भी संशोधित करूंगा ताकि हम वेरिएबल के बिना काम कर सकें "पहली पंक्ति"

रिपोर्ट(MyTZ); // तालिका रिपोर्ट (MyTZ) की पहली पंक्ति में पहले कॉलम का मान प्रदर्शित करें; // तालिका रिपोर्ट (MyTZ) की पहली पंक्ति में दूसरे कॉलम का मान प्रदर्शित करें; // तालिका की पहली पंक्ति में तीसरे कॉलम का मान प्रदर्शित करें

स्क्रीन पर भी वैसा ही होगा

चपाएव वसीली इवानोविच

हमने उपरोक्त उदाहरण में देखा कि किसी विशिष्ट पंक्ति और मानों की तालिका के एक विशिष्ट कॉलम में स्थित मान तक पहुंचने के लिए, हम इस रूप में दो ऑपरेटरों की अनुक्रमिक कॉल का उपयोग कर सकते हैं [...]: मान तालिका[पंक्ति सूचकांक][स्तंभ सूचकांक]

तो, हम एक लूप बनाने और पंक्ति और स्तंभ सूचकांकों का उपयोग करके सभी पंक्तियों और सभी स्तंभों का डेटा प्राप्त करने के लिए तैयार हैं:

रोकाउंटर के लिए = 0 MyTZ.Quantity() द्वारा - 1 लूप // पंक्तियों के माध्यम से चक्र कॉलमकाउंटर के लिए = 0 MyTZ.Columns.Quantity() द्वारा - 1 लूप // कॉलम के माध्यम से नेस्टेड लूप // सेल मान प्राप्त करें (वर्तमान पंक्ति से) और वर्तमान कॉलम) सेलवैल्यू = MyTK[रोकाउंटर][कॉलमकाउंटर]; // पंक्ति संख्या, स्तंभ संख्या और सेल मान प्रदर्शित करें रिपोर्ट ("पंक्ति संख्या" + पंक्ति गणना + "कॉलम संख्या" + कॉलम गणना + " = " + सेलवैल्यू); अंतचक्र; अंतचक्र;

निम्नलिखित स्क्रीन पर प्रदर्शित किया जाएगा:

लाइन नंबर 0 कॉलम नंबर 0 = चपाएव लाइन नंबर 0 कॉलम नंबर 1 = वसीली लाइन नंबर 0 कॉलम नंबर 2 = इवानोविच लाइन नंबर 1 कॉलम नंबर 0 = डेज़रज़िन्स्की लाइन नंबर 1 कॉलम नंबर 1 = फेलिक्स लाइन नंबर 1 कॉलम नंबर 2 = एडमंडोविच लाइन नंबर 2 कॉलम नंबर 0 = कोटोव्स्की लाइन नंबर 2 कॉलम नंबर 1 = ग्रिगोरी लाइन नंबर 2 कॉलम नंबर 2 = इवानोविच

दो चक्रों का उपयोग करते हुए, जिनमें से एक दूसरे के भीतर निहित है, हमने 1C मान तालिका की सभी पंक्तियों से सभी स्तंभों के मान प्रदर्शित किए। इस मामले में, हमने कॉलम नामों का उपयोग नहीं किया, बल्कि कॉलम और पंक्तियों को उनकी अनुक्रमणिका द्वारा एक्सेस किया। अधिक समझने के लिए, उदाहरण के अंदर टिप्पणियों पर ध्यान दें।

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

लाइनकाउंटर के लिए = 0 MyTZ.Quantity() द्वारा - 1 लूप // पंक्तियों के माध्यम से लूप रिपोर्ट (" ======= लाइन नंबर " + लाइनकाउंटर + " ======= "); रिपोर्ट करना(" "); // लाइन फ़ीड (एक खाली पंक्ति सम्मिलित करना) कॉलमकाउंटर के लिए = 0 MyTZ.Columns.Quantity() द्वारा - 1 लूप // कॉलम के माध्यम से नेस्टेड लूप // सेल मान प्राप्त करें (वर्तमान पंक्ति और वर्तमान कॉलम से) सेलवैल्यू = MyTZ [रोकाउंटर][कॉलमकाउंटर]; // कॉलम का नाम प्राप्त करें ColumnName = MyTZ.Columns[ColumnCounter].Name; // कॉलम नाम और सेल वैल्यू रिपोर्ट प्रदर्शित करें (कॉलमनाम + ":" + सेलवैल्यू); अंतचक्र; रिपोर्ट करना(" "); // लाइन फ़ीड (खाली लाइन डालना) एंडसाइकल;

अब, हमारी स्क्रीन पर जानकारी अधिक प्रतिनिधि दिखने लगी:

पंक्ति संख्या 0 ======= अंतिम नाम: चापेव प्रथम नाम: वसीली संरक्षक: इवानोविच ======= पंक्ति संख्या 1 ======= अंतिम नाम: डेज़रज़िन्स्की पहला नाम: फेलिक्स संरक्षक: एडमंडोविच ===== == पंक्ति संख्या 2 ======= अंतिम नाम: कोटोव्स्की पहला नाम: ग्रिगोरी संरक्षक: इवानोविच

हाँ, मैं लगभग भूल ही गया था। एक पंक्ति में दो [...][...] ऑपरेटरों का उपयोग करते समय, हम कॉलम इंडेक्स के बजाय इस कॉलम का नाम पास कर सकते हैं: वैल्यूटेबल[रोइंडेक्स][कॉलमनाम]

लाइनकाउंटर के लिए = 0 MyTZ.Quantity() द्वारा - 1 लूप // पंक्तियों के माध्यम से लूप रिपोर्ट (" ======= लाइन नंबर " + लाइनकाउंटर + " ======= "); रिपोर्ट करना(" "); // लाइन फ़ीड (एक खाली लाइन डालना) कॉलमकाउंटर के लिए = 0 MyTZ.Columns.Quantity() द्वारा - 1 लूप // कॉलम के माध्यम से नेस्टेड लूप कॉलमनाम = MyTZ.कॉलम[कॉलमकाउंटर].नाम; // कॉलम नाम प्राप्त करें सेल वैल्यू = MyTZ[RowCounter][ColumnName]; //

तीर से चिह्नित रेखा पर ध्यान दें। इस पंक्ति में, वर्तमान कॉलम के सूचकांक के बजाय, हम वर्ग कोष्ठक में तर्क के लिए वर्तमान कॉलम का नाम पास करते हैं [...] परिणाम वही होगा।

और अब, इस लेख की आखिरी बात।

पंक्तियों के संग्रह और स्तंभों के संग्रह के माध्यम से लूप का उपयोग करके 1C मान तालिका से सभी डेटा को सही ढंग से प्राप्त करना

MyTZ लूप से प्रत्येक करंटलाइन के लिए // स्ट्रिंग्स के संग्रह के माध्यम से लूप रिपोर्ट (" ======= लाइन नंबर " + MyTZ.Index(CurrentLine) + " ======= "); रिपोर्ट करना(" "); MyTZ.Columns लूप से प्रत्येक करंट कॉलम के लिए // नेस्टेड लूप कॉलम के संग्रह के माध्यम से पुनरावृत्त होता है कॉलम नाम = करंट कॉलम नाम; // कॉलम प्राप्त करें nameCellValue = currentRow[ColumnName]; // कॉलम नाम रिपोर्ट द्वारा सेल मान प्राप्त करें (कॉलमनाम + ":" + सेलवैल्यू); // कॉलम का नाम और सेल मान चक्र का अंत प्रदर्शित करें; रिपोर्ट करना(" "); अंतचक्र;

उदाहरण में, दो लूप का उपयोग किया गया था। स्तंभों के संग्रह के माध्यम से लूपिंग के लिए एक लूप को पंक्तियों के माध्यम से लूपिंग के लिए लूप के अंदर नेस्ट किया जाता है। यदि आपने उपरोक्त उदाहरणों पर काम किया है और पिछले लेख पढ़े हैं, तो आपको यह समझने में कोई कठिनाई नहीं होगी कि यह उदाहरण कैसे काम करता है।

अंत में, मैं मध्यवर्ती चर के उपयोग को समाप्त करके हमारे अंतिम उदाहरण में कोड की पंक्तियों की संख्या को यथासंभव कम कर दूंगा। हमें "औद्योगिक कोड" का एक नमूना मिलेगा जिसका उपयोग वास्तविक समस्याओं में किया जाता है।

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

MyTZ चक्र से प्रत्येक करंटलाइन के लिए // पंक्तियों पर पुनरावृति करें रिपोर्ट (" ======= लाइन नंबर " + MyTZ.Index(CurrentLine) + " ======= " + Symbols.PS); MyTZ.Columns लूप से प्रत्येक करंट कॉलम के लिए // कॉलम पर पुनरावृति करें रिपोर्ट (CurrentColumn.Name + ": " + currentRow[CurrentColumn.Name]); अंतचक्र; रिपोर्ट करना(" "); अंतचक्र;

स्क्रीन पर आउटपुट नहीं बदला है, यह पिछले उदाहरण जैसा ही है:

2 सप्ताह का पाठ्यक्रम

"शुरुआती लोगों के लिए 1सी में प्रोग्रामिंग"

पाठ्यक्रम ईमेल द्वारा भेजा जाएगा. चरण-दर-चरण कार्यों को पूरा करके प्रोग्रामर बनें।

भाग लेने के लिए आपको केवल एक कंप्यूटर और इंटरनेट की आवश्यकता है

पाठ्यक्रम तक निःशुल्क पहुंच:

एसपी-फोर्स-हाइड (डिस्प्ले: कोई नहीं;).एसपी-फॉर्म (डिस्प्ले: ब्लॉक; बैकग्राउंड: #eff2f4; पैडिंग: 5px; चौड़ाई: 270px; अधिकतम-चौड़ाई: 100%; बॉर्डर-त्रिज्या: 0px; -मोज़-बॉर्डर -रेडियस: 0px; -वेबकिट-बॉर्डर-रेडियस: 0px; फॉन्ट-फ़ैमिली: एरियल, "हेल्वेटिका न्यू", सेन्स-सेरिफ़; बैकग्राउंड-रिपीट: नो-रिपीट; बैकग्राउंड-पोजीशन: सेंटर; बैकग्राउंड-साइज़: ऑटो;) .एसपी-फॉर्म इनपुट (डिस्प्ले: इनलाइन-ब्लॉक; अपारदर्शिता: 1; दृश्यता: दृश्यमान;)। एसपी-फॉर्म .एसपी-फॉर्म-फील्ड्स-रैपर (मार्जिन: 0 ऑटो; चौड़ाई: 260पीएक्स;)। एसपी-फॉर्म .एसपी -फॉर्म-कंट्रोल (पृष्ठभूमि: #ffffff; सीमा-रंग: #cccccc; सीमा-शैली: ठोस; सीमा-चौड़ाई: 1px; फ़ॉन्ट-आकार: 15px; पैडिंग-बाएँ: 8.75px; पैडिंग-दाएँ: 8.75px; सीमा -त्रिज्या: 4px; -moz-बॉर्डर-त्रिज्या: 4px; -वेबकिट-बॉर्डर-त्रिज्या: 4px; ऊंचाई: 35px; चौड़ाई: 100%;).sp-form .sp-फ़ील्ड लेबल (रंग: #444444; फ़ॉन्ट- आकार: 13पीएक्स; फ़ॉन्ट-शैली: सामान्य; फ़ॉन्ट-वजन: बोल्ड;).एसपी-फॉर्म .एसपी-बटन (बॉर्डर-त्रिज्या: 4पीएक्स; -मोज़-बॉर्डर-त्रिज्या: 4पीएक्स; -वेबकिट-बॉर्डर-त्रिज्या: 4पीएक्स; पृष्ठभूमि-रंग: #f4394c; रंग: #ffffff; चौड़ाई: 100%; फ़ॉन्ट-भार: 700; फ़ॉन्ट-शैली: सामान्य; फ़ॉन्ट-फ़ैमिली: एरियल, "हेल्वेटिका न्यू", सैन्स-सेरिफ़; बॉक्स-छाया: कोई नहीं; -मोज़-बॉक्स-छाया: कोई नहीं; -वेबकिट-बॉक्स-छाया: कोई नहीं; पृष्ठभूमि: रैखिक-ढाल (शीर्ष पर, #e30d22 , #f77380);).एसपी-फॉर्म .एसपी-बटन-कंटेनर (पाठ-संरेखण: केंद्र; चौड़ाई: ऑटो;)

(यह आलेख स्क्रैच से 1सी; स्क्रैच से प्रोग्रामिंग 1सी; 1सी मानों की तालिका) लेखों की श्रृंखला से संबंधित है।

सारणीबद्ध रूप में एक आभासी डेटा भंडारण संरचना - यही है

मानों की तालिका 1C डेटाबेस की स्थायी वस्तु नहीं है और लॉन्च सत्रों के बीच सहेजी नहीं जाती है।

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

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

आइए मूल्यों की एक तालिका बनाएं और इसे किसी चीज़ से भरें। यह याद रखना चाहिए कि 1C मानों की तालिका न केवल मैन्युअल रूप से, ऑपरेटर को कॉल करके बनाई जा सकती है

न्यूवैल्यूटेबल;

एक मान तालिका अक्सर किसी अन्य ऑब्जेक्ट पर विधि कॉल का परिणाम होती है, उदाहरण के लिए किसी क्वेरी के परिणाम को मान तालिका में डंप किया जा सकता है, इत्यादि।

मैं आपको तुरंत एक सरल उदाहरण देता हूँ।

// MyTZ = नया वैल्यूटेबल; // वेरिएबल "MyTZ" में संग्रहीत मानों की एक नई तालिका बनाएं MyTZ. कॉलम. जोड़ें('अंतिम नाम' ); // कॉलम "अंतिम नाम" बनाएं MyTZ. कॉलम. जोड़ें('नाम'); // "नाम" कॉलम बनाएंरिपोर्ट (MyTZ); // MyTZ वैरिएबल का मान प्रदर्शित करें //

मैंने दो कॉलमों के साथ 1C मानों की एक तालिका बनाई: "अंतिम नाम", "प्रथम नाम"। प्रक्रिया रिपोर्ट(MyTK)संदेश विंडो में चर प्रकार प्रदर्शित करेगा MyTZ: मूल्यों की तालिका

हमारी मूल्य तालिका अभी खाली है। आइए इसमें प्रथम और अंतिम नाम के साथ कुछ पंक्तियाँ जोड़ें।

// मानों की तालिका भरें // हमारी मान तालिका में पहली पंक्ति जोड़ेंन्यूलाइन = MyTZ. जोड़ना() ; नई पंक्ति। अंतिम नाम = "सिदोरोव" ; नई पंक्ति। नाम = "वस्या" ; // हमारी मान तालिका में दूसरी पंक्ति जोड़ेंन्यूलाइन = MyTZ. जोड़ना() ; नई पंक्ति। अंतिम नाम = "इवानोव" ; नई पंक्ति। नाम = "पीटर" ;

हमें इस प्रकार एक तालिका प्राप्त हुई:

याद रखने की जरूरत: मान तालिका में पंक्ति संख्याएँ शून्य से प्रारंभ होती हैं

हमें पंक्ति संख्याओं की भी आवश्यकता क्यों है? और ताकि हम मानों की तालिका की एक अलग पंक्ति तक पहुंच सकें, उदाहरण के लिए, इस पंक्ति को स्क्रीन पर लें और प्रदर्शित करें।

// *** स्क्रीन पर शून्य रेखा के मान प्रदर्शित करें *** (रोजमर्रा की जिंदगी में हम आमतौर पर चीजों को एक से शुरू करते हैं, लेकिन यहां - शून्य से) // वर्गाकार कोष्ठकों में पंक्ति अनुक्रमणिका का उपयोग करके हमारी तालिका की शून्य पंक्ति प्राप्त करें ourNullString = MyTZ[ 0] ; // अब संपूर्ण शून्य स्ट्रिंग वेरिएबल "आवरफर्स्टलाइन" में समाहित हैरिपोर्ट(हमाराNullString.LastName); // पंक्ति शून्य में संग्रहीत "अंतिम नाम" कॉलम का मान प्रदर्शित करेंरिपोर्ट (हमाराNullString.Name); // उसी पंक्ति से "नाम" कॉलम का मान प्रदर्शित करें

परिणामस्वरूप, स्क्रीन प्रदर्शित होगी:

सिदोरोव वास्या

अब, बहुत ही स्मार्ट और संक्षिप्त के लिए, मैं एक उदाहरण दिखाऊंगा जो आपको ऐसी और ऐसी पंक्ति में एक कॉलम के मान तक पहुंचने की अनुमति देता है (इस तरह की और ऐसी पंक्ति में एक कॉलम का मान मानों की तालिका का एक सेल है) . एक अनौपचारिक शब्द, लेकिन एक सुविधाजनक)। लेकिन "ourZeroString" जैसे मध्यवर्ती चर का उपयोग किए बिना।

दूसरी पंक्ति से कोशिकाओं के मान प्रदर्शित करने के लिए (यह न भूलें कि पंक्ति दूसरी है, लेकिन इस पंक्ति का सूचकांक एक है, इसलिए क्रमांकन शून्य से शुरू होता है)

अंत में, इस लेख का अंतिम बिंदु। मैंने आपको सूचकांक (पंक्ति संख्या) द्वारा मूल्य तालिका की एकल पंक्ति तक पहुंचने का एक उदाहरण दिखाया। किसी सेल की सामग्री को पढ़ने या निर्दिष्ट करने का सार्वभौमिक रूप है: "MyValueTable[RowNumber].ColumnName"

अब मैं आपको मूल्यों की तालिका की सामग्री के पूर्ण आउटपुट का एक चक्र दूंगा। विस्तृत स्पष्टीकरण के बिना, ताकि आप भी अपना दिमाग लगा सकें :)

// // हमारे मूल्यों की तालिका की सभी पंक्तियों को लूप करें और प्रदर्शित करें// MyTZ के अनुसार LineNumber = 0 के लिए। मात्रा() - 1 चक्र रिपोर्ट (MyTZ[LineNumber] . LastName); // "अंतिम नाम" कॉलम का मान प्रदर्शित करेंरिपोर्ट (MyTK[LineNumber] . नाम); // "नाम" कॉलम का मान प्रदर्शित करेंअंतचक्र;

इस लूप को चलाने के परिणामस्वरूप, स्क्रीन पर निम्नलिखित प्रदर्शित होगा:

सिदोरोव वास्या इवानोव पेट्या

यहां मैंने आपको मूल्यों की 1C तालिका के साथ काम करने की मूल बातें बताईं। यह जानकारी 1C 8.0, 8.1, 8.2 पर लागू होती है। "1C वैल्यू टेबल" ऑब्जेक्ट के बारे में दिलचस्प विवरण यहीं समाप्त नहीं होते हैं। इस ऑब्जेक्ट में डेटा के साथ सुविधाजनक कार्य के लिए जबरदस्त क्षमताएं हैं। मैं इसके बारे में निम्नलिखित लेखों में बात करूंगा।

डिग्टिएरेव रोमन।

शुरुआत से 1सी में प्रोग्राम करना कैसे सीखें?

1सी प्रोग्रामर के रूप में कैसे काम करें और प्रति माह 150,000 रूबल तक कैसे कमाएं?

मुफ्त में साइन अप

2 सप्ताह का पाठ्यक्रम

"शुरुआती लोगों के लिए 1सी में प्रोग्रामिंग"

भाग लेने के लिए आपको केवल एक कंप्यूटर और इंटरनेट की आवश्यकता है

पाठ्यक्रम तक निःशुल्क पहुंच:

इन्फोस्टार्ट के सभी पाठकों को नमस्कार। यह आलेख प्रोग्रामेटिक रूप से प्रबंधित एप्लिकेशन के रूप में मानों की एक मनमानी तालिका बनाने के मुद्दे के लिए समर्पित होगा।

कार्य की विशेषताएं.

जिस किसी ने भी नियमित एप्लिकेशन में प्रोग्राम किया है, उसे अक्सर फॉर्म पर मूल्यों की एक मनमानी तालिका प्राप्त करने के कार्य का सामना करना पड़ता है। मानों की एक मनमानी तालिका वह तालिका होती है जिसके स्तंभों की संख्या और प्रकार पहले से ज्ञात नहीं होते हैं। यानी, 3 कॉलम हो सकते हैं, या शायद 6, या शायद 8। एक सामान्य एप्लिकेशन में, सब कुछ सरल है: आप प्रोसेसिंग फॉर्म पर "मूल्यों की तालिका" तत्व रख सकते हैं, और फिर मूल्यों की बनाई गई तालिका को स्थानांतरित कर सकते हैं। इस तत्व को प्रोग्रामेटिक रूप से। फिर एक साधारण आदेश के साथ:

प्रपत्र Elements.TableField.CreateColumns();

फॉर्म पर मूल्यों की एक तैयार तालिका प्राप्त करें। ऐसा प्रतीत होगा कि यह अधिक सरल हो सकता है।

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

समस्या का समाधान.

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

प्रपत्र पर एक तालिका का निर्माण एक विशेषता के रूप में मूल्य तालिका के विवरण के माध्यम से होता है:
चयन प्रकार ऐरे = नया ऐरे; चयन प्रकार की सरणी। जोड़ें (प्रकार ("मूल्य तालिका")); चॉइस टाइप डिस्क्रिप्शन = नया टाइप डिस्क्रिप्शन (चॉइस टाइप एरे); विवरण की सारणी = नई सारणी; गुणों की सारणी। जोड़ें (नए प्रपत्र गुण ("अनुसूची तालिका", चयन प्रकार का विवरण, "", "TZN")); अब हमें एक प्रोग्राम वैल्यू टेबल बनानी होगी जिसमें डेटा हो। यदि मानों की तालिका किसी क्वेरी से प्राप्त की जाती है, तो सब कुछ कमोबेश क्रम में है। यदि तालिका मैन्युअल रूप से बनाई गई है, तो उन स्तंभों का अर्थ जिनमें संख्याएँ या दिनांक होंगे, "प्रकारों का विवरण" के माध्यम से बनाया जा सकता है। मुद्दा यह है कि मानों की तालिका में कॉलमों का कोई न कोई प्रकार अवश्य होना चाहिए। यदि, उदाहरण के लिए, यह अपेक्षा की जाती है कि उपयोगकर्ता इन कॉलमों में डेटा को अंतःक्रियात्मक रूप से भर देगा, तो आप मूल्य तालिका के कॉलम को केवल एक नाम के साथ नहीं जोड़ सकते हैं; इसमें एक प्रकार होना चाहिए। ध्यान रखें - यह बहुत महत्वपूर्ण है क्योंकि... हम इन प्रकारों को प्रपत्र की तालिका में स्थानांतरित कर देंगे।
हम एक तालिका बनाते हैं जिसमें कई कॉलम होते हैं:
सीडी = न्यूडेटक्वालिफायर्स(डेटपार्ट्स.टाइम); ऐरेकेडी = नया ऐरे; ArrayCD.Add(प्रकार("दिनांक")); विवरण प्रकार समय = नया विवरण प्रकार (ऐरेसीडी, सीडी); टीजेड = नया वैल्यूटेबल;
TK.Columns.Add("साथ", विवरणप्रकारसमय);
TK.Columns.Add("पहले", विवरण प्रकारसमय);
TK.कॉलम.जोड़ें("नाम");
TK.Columns.Add('नोट'); // पूरा नाम और नोट - पंक्तियाँ इसके बाद, हम अपनी TK प्रोग्राम तालिका को आवश्यक डेटा से भर देंगे। हमें एक TK तालिका प्राप्त होती है जिसमें आवश्यक मान होते हैं और निर्मित प्रपत्र विशेषता में स्थानांतरित होने के लिए तैयार होते हैं। टीके से प्रत्येक कॉलम के लिए कॉलम चक्र

गुणों की सारणी। जोड़ें (नए फॉर्म गुण (कॉलम नाम, कॉलम मान प्रकार, "शेड्यूलटेबल"));

अंतचक्र;
ChangeDetails(ArrayDetails);
चयन फ़ील्ड तालिका = तत्व। जोड़ें ("टीजेडएन", प्रकार ("फॉर्मटेबल"));
सिलेक्शनफील्ड्सटेबल.डेटापाथ = "शेड्यूलटेबल";
सिलेक्शनफ़ील्डटेबल.डिस्प्ले = टेबलडिस्प्ले.लिस्ट;

यह एक सरल संयोजन है और हमारी तालिका तैयार है।

टीके से प्रत्येक कॉलम के लिए कॉलम चक्र

न्यूएलिमेंट = एलिमेंट्स.एड(कॉलम.नाम, टाइप("फॉर्मफील्ड"), सिलेक्शनफील्डटेबल);
NewElement.View = फॉर्मफ़ील्डव्यू.इनपुटफ़ील्ड;
NewElement.DataPath = "शेड्यूलटेबल।" + कॉलम.नाम;
नया तत्व.चौड़ाई = 10;

अंतचक्र;

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

चयन फ़ील्ड्स की तालिका। सेटएक्शन ("चयन", "TZNSelection");

इस घटना को संसाधित करने के लिए, एक प्रक्रिया के रूप में एक अलग प्रक्रिया निर्धारित की गई है:

&ऑनक्लाइंट
प्रक्रिया TKNSelection(TK, चयनित पंक्ति, फ़ील्ड, मानक प्रसंस्करण)
//हैंडलर EndProcedure को आदेश देता है

ध्यान दें कि टेबल हैंडलर क्लाइंट पर फायर करते हैं और इसलिए उनके पास एक कंपाइलर पॉइंटर कमांड होना चाहिए

&ऑनक्लाइंट

खैर, आखिरी चीज जो मैं जोड़ना चाहता था वह यह है कि इन सभी चरणों के बाद, तैयार तालिका को फॉर्म विशेषता में पास करना याद रखें:

वैल्यूएफ़ॉर्मएट्रिब्यूट्स(टीओआर, "शेड्यूलटेबल");

परिणामस्वरूप हमारे पास यह है:

और यहाँ "चयन" घटना का संचालन है:

उपसंहार.

मुझे उम्मीद है कि यह लेख उन 1C प्रोग्रामर्स की मदद करेगा जो प्रोग्रामेटिक रूप से किसी फॉर्म पर टेबल बनाना शुरू कर रहे हैं।

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

धन और वस्तुओं का हिसाब-किताब रखने के लिए व्यवसाय में विभिन्न तालिकाओं का व्यापक रूप से उपयोग किया जाता है। लगभग हर दस्तावेज़ एक तालिका है.

एक तालिका में गोदाम से भेजे जाने वाले सामान की सूची होती है। एक अन्य तालिका इन वस्तुओं के भुगतान की बाध्यता को दर्शाती है।

इसलिए, 1C में, तालिकाओं के साथ काम करना एक प्रमुख स्थान रखता है।

1C में तालिकाओं को "सारणीबद्ध भाग" भी कहा जाता है। निर्देशिकाएँ, दस्तावेज़ और अन्य उनके पास हैं।

निष्पादित होने पर क्वेरी एक तालिका लौटाती है जिसे दो अलग-अलग तरीकों से एक्सेस किया जा सकता है।

पहला - तेज़ - चयन, इससे पंक्तियाँ प्राप्त करना केवल क्रम में ही संभव है। दूसरा है क्वेरी परिणाम को मानों की तालिका में अपलोड करना और फिर उस तक यादृच्छिक पहुंच।

//विकल्प 1 - क्वेरी परिणामों तक क्रमिक पहुंच

// तालिका प्राप्त करें
चुनें = Query.Run().Select();
// हम क्वेरी परिणाम की सभी पंक्तियों को क्रम से देखते हैं
जबकि सेलेक्ट.नेक्स्ट() लूप
रिपोर्ट(चयन.नाम);
अंतचक्र;

//विकल्प 2 - मानों की तालिका में अपलोड करना
अनुरोध = नया अनुरोध ("निर्देशिका से नाम चुनें। नामकरण");
// तालिका प्राप्त करें
तालिका = क्वेरी.रन().अनलोड()।
//आगे हम सभी पंक्तियों के माध्यम से पुनरावृति भी कर सकते हैं
टेबल साइकिल से प्रत्येक पंक्ति के लिए
रिपोर्ट(स्ट्रिंग.नाम);
अंतचक्र;
//या मनमाने ढंग से स्ट्रिंग तक पहुंचें
पंक्ति = तालिका.खोजें('फावड़ा', 'नाम');

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

प्रपत्र पर तालिका (मोटा ग्राहक)

जब तालिका प्रपत्र पर रखी जाती है तो उपयोगकर्ता उसके साथ काम करता है।

हमने प्रपत्रों के साथ काम करने के बुनियादी सिद्धांतों पर पाठ में और आगे के पाठ में चर्चा की

तो, चलिए टेबल को फॉर्म पर रखें। ऐसा करने के लिए, आप तालिका को नियंत्रण कक्ष से खींच सकते हैं। इसी तरह, आप मेनू से फॉर्म/इंसर्ट कंट्रोल का चयन कर सकते हैं।

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

डेटा प्रॉपर्टी में "..." बटन पर क्लिक करें। सारणीबद्ध भागों की सूची देखने के लिए, आपको ऑब्जेक्ट शाखा का विस्तार करना होगा।

जब आप सारणीबद्ध भाग का चयन करते हैं, तो 1C स्वयं प्रपत्र पर तालिका में कॉलम जोड़ देगा। ऐसी तालिका में उपयोगकर्ता द्वारा दर्ज की गई पंक्तियाँ संदर्भ पुस्तक/दस्तावेज़ के साथ स्वचालित रूप से सहेजी जाएंगी।

उसी डेटा प्रॉपर्टी में, आप एक मनमाना नाम दर्ज कर सकते हैं और वैल्यू टेबल प्रकार का चयन कर सकते हैं।

इसका मतलब है कि मूल्यों की एक मनमानी तालिका का चयन किया गया है। यह स्वचालित रूप से कॉलम नहीं जोड़ेगा, न ही यह स्वचालित रूप से सहेजा जाएगा, लेकिन आप इसके साथ जो चाहें कर सकते हैं।

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

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

तालिका को प्रबंधित करने के लिए, आपको प्रपत्र पर एक कमांड पैनल प्रदर्शित करना होगा। मेनू आइटम फॉर्म/इंसर्ट कंट्रोल/कमांड बार का चयन करें।

कमांड बार गुणों में, ऑटोफ़िल चेकबॉक्स का चयन करें ताकि पैनल पर बटन स्वचालित रूप से दिखाई दें।

प्रपत्र पर तालिका (पतला/प्रबंधित ग्राहक)

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

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

कॉलम जोड़ने के लिए, इस फॉर्म विशेषता पर राइट-क्लिक मेनू का उपयोग करें, विशेषता कॉलम जोड़ें का चयन करें।

फिर टेबल को बाईं ओर भी खींचें।

किसी तालिका में कमांड बार रखने के लिए, तालिका गुणों में, उपयोग - कमांड बार स्थिति अनुभाग में मानों का चयन करें।

Excel में तालिका अपलोड करना

प्रपत्र पर स्थित किसी भी 1सी तालिका को एक्सेल में मुद्रित या अपलोड किया जा सकता है।

ऐसा करने के लिए, तालिका में खाली जगह पर राइट-क्लिक करें और सूची चुनें।

एक प्रबंधित (पतले) क्लाइंट में, मेनू आइटम सभी क्रियाएं/प्रदर्शन सूची का उपयोग करके समान क्रियाएं की जा सकती हैं।

सवाल 1C v8 में विभिन्न प्रकार के मानों का एक तालिका स्तंभ बनाना
उत्तरमान तालिका कॉलम बनाते समय, आप पास कर सकते हैं प्रकार की सारणी, और शायद एक विशिष्ट प्रकार। जब आपको एक कॉलम के लिए कई अलग-अलग प्रकार निर्दिष्ट करने की आवश्यकता होती है तो प्रकारों की एक सरणी का उपयोग किया जाता है।

प्रकारों को इंगित करने के लिए उपयोग किया जाता है "सामान्य वस्तु" - "प्रकारों का विवरण". इसलिए, पहले हम बताएंगे कि "प्रकारों का विवरण" ("मूल्य प्रकारों का विवरण") क्या है।

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

"प्रकार विवरण" विधि का सिंटैक्स

नये विवरण प्रकार(<Исходное описание типов>, <Добавляемые типы>, <Вычитаемые типы>, <Квалификаторы числа>, <Квалификаторы строки>, <Квалификаторы даты>)
विकल्प:
<Исходное описание типов> (वैकल्पिक)
प्रकार: विवरण प्रकार। प्रकारों का प्रारंभिक विवरण, जिसके आधार पर नया निर्माण किया जाएगा।
<Добавляемые типы> (वैकल्पिक)
प्रकार: सरणी, स्ट्रिंग। प्रकार मानों की एक सरणी एक प्रकार जिसमें वे प्रकार शामिल होते हैं जिनका उपयोग ऑब्जेक्ट में किया जाएगा, या एक स्ट्रिंग जिसमें अल्पविराम द्वारा अलग किए गए प्रकारों के नाम होते हैं।
<Вычитаемые типы> (वैकल्पिक)
प्रकार: सरणी, स्ट्रिंग। प्रकार मानों की एक सरणी (या अल्पविराम से अलग किए गए प्रकार के नामों वाली एक स्ट्रिंग) जिसमें वे प्रकार शामिल हैं जिन्हें पहले पैरामीटर में निर्दिष्ट प्रारंभिक घोषणा से बाहर रखा जाएगा।
<Квалификаторы числа> (वैकल्पिक)
प्रकार: क्वालिफायर नंबर। संख्या क्वालीफायर जो संख्यात्मक प्रकार के मान्य मानों का वर्णन करते हैं।
<Квалификаторы строки> (वैकल्पिक)
प्रकार: क्वालिफायरस्ट्रिंग्स। स्ट्रिंग क्वालीफायर जो एक स्ट्रिंग प्रकार के मान्य मानों का वर्णन करते हैं।
<Квалификаторы даты> (वैकल्पिक)
प्रकार: क्वालीफायर दिनांक। दिनांक क्वालीफायर जो दिनांक प्रकार के मान्य मानों का वर्णन करते हैं।
विवरण:
कुछ प्रकारों को जोड़कर और अन्य को छोड़कर, किसी अन्य प्रकार के विवरण के आधार पर एक प्रकार का विवरण बनाता है। यदि कोई नया क्वालिफायर निर्दिष्ट नहीं किया गया है, तो मूल प्रकार की घोषणा के क्वालिफायर को बरकरार रखा जाएगा।
"प्रकार विवरण" ऑब्जेक्ट का उपयोग करने का एक उदाहरण:

// नए प्रकारों के साथ मान्य प्रकारों के विवरण का विस्तार करेंऐरे = नया ऐरे; सारणी। जोड़ें(प्रकार( "संदर्भ लिंक. तरीके")); सारणी। जोड़ें(प्रकार("संख्या" )); चिह्न = मान्य चिह्न. गैर-नकारात्मक; QuNumbers = नए क्वालिफायरनंबर(10, 2, चिह्न); वैलिडटाइप्स = न्यूटाइपडिस्क्रिप्शन (वैलिडटाइप्स, ऐरे, केवीनंबर्स);

अब, वास्तव में, किसी तालिका में विभिन्न प्रकार के स्तंभ मानों के सही निर्माण के उदाहरण।

सामान्य तौर पर, कॉलम प्रकारों को निम्नानुसार परिभाषित करना पर्याप्त है:

टी.के. कॉलम. जोड़ना( "सॉर्ट इंडेक्स", नया विवरण प्रकार ("संख्या") ); टी.के. कॉलम. जोड़ें('सेक्शननाम', नया प्रकार विवरण('स्ट्रिंग' ) ) ; टी.के. कॉलम. जोड़ें('DataCorr' , नया प्रकार विवरण('दिनांक' ) ) ; टी.के. कॉलम. जोड़ना( "बिना शर्त विलोपन", नया प्रकार विवरण("बूलियन")); टी.के. कॉलम. जोड़ें("नामपद्धति", नया प्रकार विवरण()); टी.के. कॉलम. जोड़ें('सेक्शनडेटा' , नया प्रकार विवरण('संरचना' ) ); // मापदंडों के स्पष्टीकरण के साथ कॉलम "संख्या" और "स्ट्रिंग" बनाने का उदाहरण:टी.के. कॉलम. जोड़ना( "पूर्ण प्रतिशत", नए विवरण प्रकार ("नंबर", नए क्वालिफायरनंबर (18, 2))); टी.के. कॉलम. जोड़ें("SectionName" , NewTypeDescription("String" , , NewStringQualifiers(200,AllowedLength. Variable) ) ) ); टी.के. कॉलम. जोड़ें("डीकमीशनडेट" , न्यूटाइपडिस्क्रिप्शन("डेट" , , , न्यूडेटक्वालिफायर्स(डेटपार्ट्स.डेटटाइम) ) ) ;

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

////// तकनीकी विशिष्टताओं की संरचना का गठन (स्तंभों का निर्माण) //// तकनीकी विनिर्देश के क्वालीफायर क्षेत्रों में प्रतिस्थापन के लिए क्वालीफायर को परिभाषित करेंसीएन = नए क्वालिफायर नंबर (18, 9); केएस = न्यूस्ट्रिंगक्वालिफायर्स(200); सीडी = न्यूडेटक्वालिफायर्स(डेटापार्ट्स.डेटटाइम); //// भविष्य के टीके कॉलम के लिए प्रकार विवरण परिभाषित करें // एक सरणी प्रकारों का प्रारंभिक विवरण है, जिसके आधार पर एक नया बनाया जाएगा // कृपया ध्यान दें कि टीके कॉलम के लिए इस उदाहरण में प्रारंभिक प्रकार का विवरण एक सरणी हैऐरे = नया ऐरे; सारणी। जोड़ें(प्रकार("स्ट्रिंग") ); टाइपडिस्क्रिप्शनस्ट्रिंग = नया टाइपडिस्क्रिप्शन(ऐरे, , केएस); सारणी। स्पष्ट() ; सारणी। जोड़ें(प्रकार("संख्या") ); टाइपडिस्क्रिप्शननंबर = नया टाइपडिस्क्रिप्शन(सरणी, , , सीएन); सारणी। स्पष्ट() ; सारणी। जोड़ें(प्रकार("दिनांक") ); विवरण प्रकार दिनांक = नया विवरण प्रकार (सरणी, , , , सीडी); सारणी। स्पष्ट() ; सारणी। जोड़ें(प्रकार( "निर्देशिकालिंक.नामपद्धति") ) ; प्रकार विवरणनामपद्धति = नए प्रकार का विवरण (सरणी); सारणी। स्पष्ट() ; सारणी। जोड़ें(प्रकार( "निर्देशिकालिंक.श्रृंखलानामपद्धति") ) ; टाइपडिस्क्रिप्शनश्रृंखला = नया टाइपडिस्क्रिप्शन(ऐरे); सारणी। स्पष्ट() ; सारणी। जोड़ें(प्रकार( "निर्देशिकालिंक.गुणवत्ता") ) ; टाइपडिस्क्रिप्शनक्वालिटी = नया टाइपडिस्क्रिप्शन(सरणी); सारणी। स्पष्ट() ; सारणी। जोड़ें(प्रकार("बूलियन") ); टाइपडिस्क्रिप्शनबूलियन = नया टाइपडिस्क्रिप्शन(ऐरे); // वास्तव में टीके में कॉलम जोड़ना (भविष्य के टीके की संरचना बनाना)टी.के. कॉलम. जोड़ें("नामपद्धति", विवरणप्रकारनामपद्धति); टी.के. कॉलम. जोड़ें("कोड", टाइपडिस्क्रिप्शनस्ट्रिंग); टी.के. कॉलम. जोड़ना( "श्रृंखला नामकरण", विवरणप्रकारश्रृंखला); टी.के. कॉलम. जोड़ें("अकाउंटकोड", टाइप डिस्क्रिप्शनस्ट्रिंग); टी.के. कॉलम. जोड़ें('एक्शनडेट', टाइपडिस्क्रिप्शनडेट); टी.के. कॉलम. जोड़ें("गुणवत्ता", प्रकार विवरणगुणवत्ता); टी.के. कॉलम. जोड़ें('नंबरयूएस', विवरणप्रकारनंबर); टी.के. कॉलम. जोड़ें("लिखें बंद करें", टाइपडिस्क्रिप्शनबूलियन); . . . //////// तकनीकी विशिष्टताओं की संरचना का गठन (स्तंभों का निर्माण) ////////////////////////////////////////////////////////

मान तालिका में एक पंक्ति जोड़ने के लिए, देखें