การเปิดแบบฟอร์มโดยทางโปรแกรมในแอปพลิเคชัน 1C ที่ได้รับการจัดการนั้นแตกต่างอย่างมากจากการเปิดในแอปพลิเคชันทั่วไป เรามาดูวิธีการแบบเก่ากันก่อน ประกอบด้วยการรับแบบฟอร์มแล้วเปิดในโหมดปกติหรือโหมดโมดอล (เมื่อเปิดในโหมดโมดอล แบบฟอร์มจะบล็อกโปรแกรม)

GetForm() . เปิด()

นี่เป็นวิธีการเปิดแบบฟอร์มที่ช้าที่สุด อย่างไรก็ตาม ช่วยให้คุณสามารถประมวลผลแบบฟอร์มโดยทางโปรแกรมก่อนเปิดได้ ในการประมวลผลโค้ดคุณต้องเปลี่ยนแปลงเล็กน้อย:

แบบฟอร์ม = GetForm( “เอกสาร ใบรับสินค้าและบริการ แบบฟอร์มเอกสาร”) ;
//ที่นี่เราดำเนินการกับแบบฟอร์ม
รูปร่าง. เปิด();

ควรคำนึงว่าเมื่อได้รับแบบฟอร์มแล้ว จะมีการดำเนินการตามขั้นตอนเหตุการณ์อื่น เมื่อสร้างบนเซิร์ฟเวอร์

มาดูวิธีการอื่นที่ช่วยให้คุณเปิดแบบฟอร์มในแอปพลิเคชัน 1C ที่ได้รับการจัดการได้เร็วและสะดวกยิ่งขึ้น อาจใช้วิธีการที่แตกต่างกันขึ้นอยู่กับสถานการณ์เฉพาะ

1. วิธีเปิดแบบฟอร์มออบเจ็กต์ในแอปพลิเคชันที่ได้รับการจัดการ หากมีลิงก์ไปยังแบบฟอร์มนั้น

ในกรณีนี้ทุกอย่างง่ายมาก

RefLink = ไดเรกทอรี ศัพท์. FindByCode("000000001" ) ;
OpenValue(อ้างอิงลิงค์);

2. วิธีการเปิดแบบฟอร์มการเลือกแล้วรับค่าที่เลือก

มีฟังก์ชั่นสำหรับสิ่งนี้ ป้อนค่า()ฟังก์ชั่นมี 3 พารามิเตอร์:

• ตัวแปรที่จะเขียนค่าที่เลือกไว้
• คำใบ้ที่จะแสดงในหน้าต่างการเลือก
• คำอธิบายประเภทของค่าที่เลือก อาจมีหลายประเภท ในกรณีนี้คุณจะได้รับแจ้งให้เลือกประเภทก่อนที่จะเลือกค่าเฉพาะ

จากผลของการดำเนินการฟังก์ชัน แบบฟอร์มการเลือกเริ่มต้นสำหรับออบเจ็กต์ประเภทที่ระบุจะเปิดขึ้น

ค่าตัวแปร
อาร์เรย์= อาร์เรย์ใหม่;
อาร์เรย์ เพิ่ม(ประเภท( "DirectoryLink.ระบบการตั้งชื่อ") ) ;
อาร์เรย์ เพิ่ม(ประเภท( “DirectoryLink. คู่สัญญา”) ) ;

TypeDescription= TypeDescription ใหม่ (อาร์เรย์) ;

Res = EnterValue(ค่า, "คำแนะนำ", TypeDescription);

วิธีการก่อนหน้านี้อนุญาตให้คุณเปิดแบบฟอร์มเริ่มต้นสำหรับวัตถุเท่านั้น (แบบฟอร์มวัตถุหรือแบบฟอร์มการเลือก) หากคุณต้องการเปิดแบบฟอร์มที่กำหนดเอง คุณสามารถใช้ฟังก์ชันนี้ได้ โอเพ่นฟอร์ม()

ฟังก์ชั่นนี้มีพารามิเตอร์ค่อนข้างน้อย ลองดูบางส่วนของพวกเขา:

• ชื่อแบบฟอร์ม— ที่นี่คุณสามารถเลือกหนึ่งในรูปร่างวัตถุมาตรฐานได้ เช่น แบบฟอร์มการคัดเลือกหรือ แบบฟอร์มรายการ. หรือรูปแบบเฉพาะที่สร้างโดยนักพัฒนา
• ตัวเลือก— ให้คุณโอนเข้าแบบฟอร์มในแบบฟอร์มได้ โครงสร้างพารามิเตอร์บางตัวก่อนเปิดจึงกำหนดข้อมูลเอาต์พุต พารามิเตอร์อาจเป็นข้อมูลใดๆ ที่สามารถส่งผ่านจากไคลเอ็นต์ไปยังเซิร์ฟเวอร์ได้ พารามิเตอร์ที่ส่งผ่านเมื่อเปิดแบบฟอร์มสามารถประมวลผลได้ในขั้นตอน เมื่อสร้างOnServer()ที่แบบฟอร์มที่กำลังเปิดอยู่
• โหมดการเปิดแบบฟอร์ม— มี 3 ตัวเลือก: อิสระ, บล็อกอินเทอร์เฟซทั้งหมด, บล็อกแบบฟอร์มเจ้าของ

มาดูกันว่ามีการใช้งานฟังก์ชั่นอย่างไร โอเพ่นฟอร์ม()ในสถานการณ์ต่างๆ

3. วิธีการเปิดแบบฟอร์มของวัตถุที่มีอยู่

แต่ละแบบฟอร์มมีคุณลักษณะหลักหนึ่งรายการ ในรายการรายละเอียดแบบฟอร์มจะเน้นด้วยตัวหนา และมักเรียกว่า วัตถุในรูปแบบองค์ประกอบของหนังสืออ้างอิงและเอกสาร วัตถุอื่นๆ อาจมีชื่อที่แตกต่างกัน หากต้องการเปิดฟอร์มของออบเจ็กต์ที่มีอยู่ คุณต้องส่งพารามิเตอร์ไปยังฟอร์มที่กำลังเปิด สำคัญโดยมีค่าเป็นการอ้างอิงถึงวัตถุ

&บนไคลเอนต์
ขั้นตอน Command1 (คำสั่ง)
พารามิเตอร์ = โครงสร้างใหม่;
พารามิเตอร์. แทรก("คีย์" , FindC() ) ;
OpenForm(, พารามิเตอร์);
สิ้นสุดขั้นตอน

&บนเซิร์ฟเวอร์
ฟังก์ชั่น FindC();
ส่งคืนไดเร็กทอรี คู่สัญญา FindByRequisites ("TIN", "745107734623")
EndFunction

4. วิธีการเปิดแบบฟอร์มออบเจ็กต์ใหม่

ฟังก์ชันง่ายๆ จะทำตรงนี้ โอเพ่นฟอร์ม()โดยไม่มีพารามิเตอร์ใดๆ

&บนไคลเอนต์
ขั้นตอน Command1 (คำสั่ง)
โอเพ่นฟอร์ม( “สารบบ คู่สัญญา แบบฟอร์มวัตถุ”) ;
สิ้นสุดขั้นตอน

5. วิธีเปิดแบบฟอร์มออบเจ็กต์ใหม่และกรอกตามบางสิ่ง

คุณต้องผ่านพารามิเตอร์ ฐานค่าซึ่งจะเป็นการอ้างอิงไปยังวัตถุฐานการเติม นี่จะเป็นการเริ่มขั้นตอน กระบวนการกรอก()

&บนไคลเอนต์
ขั้นตอน Command1 (คำสั่ง)
พารามิเตอร์ = โครงสร้างใหม่;
พารามิเตอร์. ส่วนแทรก ("ฐาน", LinkToBuyerAccount);
โอเพ่นฟอร์ม( “เอกสารการขายสินค้าและบริการ แบบคำขอ”, พารามิเตอร์) ;
สิ้นสุดขั้นตอน

ตัวอย่างนี้จะสร้างเอกสาร การขายสินค้าและบริการและกรอกตามใบแจ้งหนี้เพื่อชำระเงินให้กับผู้ซื้อตามลิงก์ที่ถูกส่งไป

6. วิธีเปิดแบบฟอร์มและตั้งค่าการเลือก

การเลือกแบบฟอร์ม 1C สามารถทำได้ง่ายหรือซับซ้อน การเลือกอย่างง่ายเกี่ยวข้องกับสำนวนเช่น องค์กร = Horns and Hooves LLCการเลือกที่ซับซ้อนเกี่ยวข้องกับการเปรียบเทียบประเภทอื่น เช่น ในรายการ. ในบทความนี้เราจะพิจารณาการจัดองค์กรของการเลือกแบบง่ายและบทความแยกต่างหากจะเน้นไปที่การเลือกที่ซับซ้อน

ในการจัดระเบียบการเลือกแบบง่าย คุณต้องส่งพารามิเตอร์พร้อมคีย์ไปยังแบบฟอร์มที่กำลังเปิด การคัดเลือกค่าจะเป็นโครงสร้างที่คีย์คือชื่อของฟิลด์รายการไดนามิก และค่าคือข้อมูลที่กำลังค้นหา

ตัวอย่างเช่น เรามาเปิดแบบฟอร์มรายการไดเร็กทอรี ตัวเลข GTDและทำการเลือกโดยเจ้าของ - องค์ประกอบไดเร็กทอรี ศัพท์.

&บนไคลเอนต์
ขั้นตอน Command1 (คำสั่ง)
พารามิเตอร์ = โครงสร้างใหม่;

การเลือก = โครงสร้างใหม่;
การคัดเลือก Insert("เจ้าของ", LinkToNomenclature);

พารามิเตอร์. แทรก("การเลือก", การเลือก);

โอเพ่นฟอร์ม( "Directory.GTD Numbers.แบบฟอร์มรายการ", พารามิเตอร์) ;
สิ้นสุดขั้นตอน

7. วิธีการเปิดแบบฟอร์มลงทะเบียนข้อมูล

ในการดำเนินการนี้ คุณจะต้องมีรหัสรายการลงทะเบียนข้อมูล

บันทึกคีย์— นี่คือค่าของการวัดทั้งหมดและระยะเวลา (หากการลงทะเบียนเป็นระยะ) นั่นคือคีย์บันทึกคือพารามิเตอร์ที่สามารถระบุบันทึกได้โดยไม่ซ้ำกัน

อัลกอริธึมการเปิดมีดังนี้:

1. เราป้อนข้อมูลคีย์บันทึกด้วยค่าที่จำเป็นลงในโครงสร้าง
2. เราวางโครงสร้างผลลัพธ์ไว้ในอาร์เรย์
3. เราสร้างคีย์บันทึกจากอาร์เรย์
4. เราส่งพารามิเตอร์ไปยังแบบฟอร์มที่เปิดขึ้น สำคัญโดยมีคีย์บันทึกจากขั้นตอนที่ 3 เป็นค่า

&บนไคลเอนต์
ขั้นตอน Command1 (คำสั่ง)
พารามิเตอร์ = โครงสร้างใหม่;

KeyParameters= โครงสร้างใหม่;
พารามิเตอร์ที่สำคัญ Insert("ระบบการตั้งชื่อ", LinkToระบบการตั้งชื่อ);
พารามิเตอร์ที่สำคัญ ใส่("ประเภทราคา", LinkToPriceType);
พารามิเตอร์ที่สำคัญ Insert("ระยะเวลา", วันที่);

KeyArray = อาร์เรย์ใหม่;
คีย์อาร์เรย์ เพิ่ม(พารามิเตอร์คีย์);

รายการคีย์ = ใหม่( "ข้อมูลการลงทะเบียนบันทึกคีย์ราคาระบบการตั้งชื่อ", คีย์อาร์เรย์) ;

พารามิเตอร์. Insert("คีย์", คีย์บันทึก);

โอเพ่นฟอร์ม( “ทะเบียนข้อมูล ราคาระบบการตั้งชื่อ แบบบันทึก”, พารามิเตอร์) ;
สิ้นสุดขั้นตอน

บ้าน สำหรับนักพัฒนามือใหม่ เรียนรู้การเขียนโปรแกรม

จะเปิดรูปแบบของวัตถุที่มีอยู่ได้อย่างไร?

เมื่อเปิดฟอร์มของออบเจ็กต์ที่มีอยู่ นอกเหนือจากชื่อของฟอร์มแล้ว คุณต้องระบุออบเจ็กต์ที่ควรเปิดฟอร์มด้วย ในการดำเนินการนี้ ให้ใช้พารามิเตอร์แบบฟอร์มคีย์และลิงก์ไปยังวัตถุที่เราสนใจ

ตัวอย่างเช่น หากคุณจำเป็นต้องเปิดแบบฟอร์มขององค์กรที่มีเคอร์เซอร์อยู่จากรายการแบบฟอร์มองค์กร คุณสามารถทำได้ด้วยวิธีต่อไปนี้:

เราส่งพารามิเตอร์แบบฟอร์มในรูปแบบของโครงสร้าง โดยที่ชื่อขององค์ประกอบโครงสร้างสอดคล้องกับชื่อของพารามิเตอร์แบบฟอร์ม และค่าคือค่าที่เราต้องการตั้งค่าพารามิเตอร์แบบฟอร์ม

หากคุณต้องการเปิดไม่ใช่รูปแบบหลัก แต่เป็นรูปแบบที่กำหนดเองของวัตถุที่สร้างขึ้นในตัวกำหนดค่าแทนที่จะเป็นชื่อมาตรฐานของรูปแบบหลัก (ObjectForm) ให้ระบุคำว่า รูปแบบ ตามด้วยจุด - ชื่อของแบบฟอร์มที่สร้างขึ้นใน ตัวกำหนดค่า

ตัวอย่างเช่น:

ReferenceToDirectoryElement = Elements.List.CurrentRow; FormParameters = โครงสร้างใหม่ ("คีย์", ReferenceToDirectoryElement); OpenForm("Directory.Organizations.Form.UniversalObjectForm",พารามิเตอร์แบบฟอร์ม);

ควรสังเกตว่าในกรณีที่นอกเหนือจากลิงก์ไปยังออบเจ็กต์แล้ว ไม่จำเป็นต้องส่งพารามิเตอร์ไปยังแบบฟอร์มที่กำลังเปิดอยู่ และเป็นรูปแบบหลักของออบเจ็กต์ที่มีอยู่ซึ่งจำเป็น คุณสามารถใช้วิธีที่ง่ายกว่าได้ - เปิดแบบฟอร์มตามขั้นตอน ค่าเปิด():

OpenValue(Items.List.CurrentRow);

วิธีการนี้มีความหลากหลายน้อยกว่า แต่ในบางกรณีก็ช่วยประหยัดเวลาและความพยายาม ตัวอย่างเช่น ในกรณีที่พิจารณา บรรทัดดังกล่าวหนึ่งบรรทัดสามารถแทนที่ขั้นตอนสามบรรทัดทั้งหมดที่เราเขียนไว้ก่อนหน้านี้

อย่างไรก็ตาม ต้องใช้ความระมัดระวังเมื่อใช้ขั้นตอนนี้ ในบางกรณี อาจทำให้เกิดการเรียกเพิ่มเติมไปยังเซิร์ฟเวอร์ ตัวอย่างเช่น เมื่อคุณต้องการเปิดแบบฟอร์มรายการไดเรกทอรีแบบลำดับชั้น เมื่อใช้ขั้นตอนนี้ แพลตฟอร์มจะทำการเรียกเพิ่มเติมไปยังเซิร์ฟเวอร์เพื่อตรวจสอบว่าองค์ประกอบเป็นกลุ่มหรือไม่ เนื่องจากจะต้องเปิดแบบฟอร์มที่แตกต่างกันสำหรับองค์ประกอบและสำหรับกลุ่ม

ในเวลาเดียวกัน นักพัฒนาสามารถทราบข้อมูลนี้ล่วงหน้าภายในอัลกอริธึมของเขา และด้วยการใช้ฟังก์ชัน OpenForm() นักพัฒนาสามารถเปิดแบบฟอร์มที่ต้องการโดยไม่ต้องเรียกเซิร์ฟเวอร์เพิ่มเติม โดยระบุชื่อมาตรฐานของฟอร์มหลักทันที รูปร่าง.

ขอให้เป็นวันที่ดีทุกคน!
ฉันคิดว่าข้อมูลในหัวข้อนี้จะมีประโยชน์มากสำหรับผู้เยี่ยมชมฟอรัมนี้
เป็นเวลานานที่ฉันไม่สามารถแก้ปัญหาได้ - จะเปิดแบบฟอร์มของเอกสารใหม่ได้อย่างไรเพื่อที่จะเปิดไม่ว่างเปล่า แต่กรอกโดยทางโปรแกรมบางส่วนแล้วในขณะที่เอกสารยังไม่ได้ถูกบันทึกในฐานข้อมูล? ฉันใช้เวลาส่วนใหญ่ค้นหาวิธีแก้ไขปัญหานี้บนอินเทอร์เน็ต เยี่ยมชมฟอรัมหลายแห่งที่มีการหยิบยกปัญหานี้ขึ้นมา แต่มีเพียงไม่กี่แห่งเท่านั้นที่พบวิธีแก้ปัญหา วิธีที่ง่ายที่สุดคือการสร้างเอกสารใหม่โดยทางโปรแกรมกรอกรายละเอียดที่จำเป็นโดยทางโปรแกรมเขียนเอกสารลงในฐานข้อมูลจากนั้นเปิดให้กับผู้ใช้ จะเกิดอะไรขึ้นถ้าผู้ใช้ไม่ต้องการบันทึกมัน? จะเกิดอะไรขึ้นถ้าเขาเปลี่ยนใจและปิดฟอร์มที่เปิดอยู่? ในกรณีนี้เอกสารที่บันทึกไว้แล้วจะยังคงอยู่ในฐานข้อมูล และใครต้องการเอกสารเพิ่มเติมในฐานข้อมูล?
และถ้าคุณไม่บันทึกเอกสาร ตัวเลือกยอดนิยมที่สุดคือการใช้วิธี GetForm (“Documents. Required Document Type. Document Form”) แต่ในกรณีนี้ คุณสามารถรับแบบฟอร์มเอกสารเปล่าและแสดงโดยใช้เมธอด Open() นี่ก็ไม่ใช่ทางเลือกเช่นกัน...
หลังจากนั้นครู่หนึ่ง ปัญหาได้รับการแก้ไขโดยใช้ฟังก์ชันบริบทส่วนกลาง "กรอกค่าคุณสมบัติ"

บริบททั่วโลก
เติมค่าคุณสมบัติ
ไวยากรณ์:
กรอกค่าคุณสมบัติ(<Приемник>, <Источник>, <Список свойств>, <Исключая свойства>)
คำอธิบาย:
คัดลอกค่าคุณสมบัติ<Источника>ถึงคุณสมบัติ<Приемника>. การจับคู่ทำได้โดยใช้ชื่อคุณสมบัติ

โดยใช้งานของฉันเป็นตัวอย่าง ฉันต้องการอธิบายว่าคุณสามารถใช้ฟังก์ชันนี้เพื่อกรอกแบบฟอร์มสำหรับเอกสารใหม่ได้อย่างไร งานมีดังนี้: มีเอกสารหนึ่งฉบับ (ใบสั่งงาน) ซึ่งจำเป็นสำหรับส่วนตารางซึ่งเป็นเอกสารอีกฉบับหนึ่ง (การให้บริการ) ดังนั้นจึงจำเป็นต้องตรวจสอบให้แน่ใจว่าเมื่อมีการเพิ่มเอกสารใหม่ "การแสดงผลบริการ" ในส่วนตารางของ "คำสั่งงาน" รูปแบบของเอกสารใหม่ "การแสดงผลบริการ" จะแสดงบนหน้าจอพร้อมรายละเอียด กรอกแล้วนำมาจากคำสั่งงานที่เกิดการสร้าง ในเวลาเดียวกันเอกสารใหม่ในขณะที่แบบฟอร์มปรากฏบนหน้าจอยังไม่ได้ถูกบันทึกลงในฐานข้อมูล จะต้องดำเนินการนี้หากผู้ใช้ตัดสินใจไม่กรอกเอกสารกะทันหันและเพียงปิดแบบฟอร์ม
นี่คือส่วนของโค้ดพร้อมวิธีแก้ไขปัญหา:

&ในขั้นตอนไคลเอนต์ EnterRecord()RecordForm = GetForm("Document.Provision of Medical Services.ObjectForm"); กรอกค่าคุณสมบัติ (RecordForm.Object, Object, "วันที่, ผู้เชี่ยวชาญ, ความเชี่ยวชาญ, พยาบาล, สถานะการดำเนินการ",); // กรอกค่ารายละเอียดที่มีชื่อเหมือนกันในเอกสารทั้งสอง TextStr = Elements.Reception.CurrentData; //ข้อมูลของบรรทัดปัจจุบันของเอกสารต้นฉบับโครงสร้างคุณสมบัติ = โครงสร้างใหม่; // โครงสร้างประกอบด้วยค่าของรายละเอียดที่ต้องกรอกในแบบฟอร์มของเอกสารใหม่ แต่ไม่ได้อยู่ในเอกสารต้นฉบับ StructureProperties.Insert("Work Order", Object.Link); PropertyStructure.Insert("ReceptionTime",TexStr.ReceptionTime); กรอกค่าคุณสมบัติ (RecordForm.Object, โครงสร้างคุณสมบัติ, "RecordOrder, AppointmentTime",); รายการแบบฟอร์ม.เปิด(); สิ้นสุดขั้นตอน

นั่นคือ เราดำเนินการทั้งหมดโดยตรงบนไคลเอนต์ โดยไม่ต้องติดต่อกับเซิร์ฟเวอร์ ภายในขั้นตอนเดียวที่สร้างขึ้นโดยอิสระ ที่จริงแล้ว ด้วยวิธีนี้ คุณสามารถกรอกและเปิดแบบฟอร์มเอกสารหรือหนังสืออ้างอิงใดก็ได้ ขั้นแรก ฉันกรอกรายละเอียดจากแบบฟอร์มหนึ่งไปยังอีกแบบฟอร์มหนึ่งโดยใช้วัตถุแบบฟอร์ม จากนั้นโดยใช้วัตถุ "โครงสร้าง" ซึ่งฉันแทรกรายละเอียดที่ขาดหายไป ฉันกรอกรายละเอียดเพิ่มเติมของแบบฟอร์มที่กำลังเปิดอยู่ จากนั้นจึงเปิด รูปร่าง.
ฉันหวังว่าหัวข้อนี้จะช่วยประหยัดเวลาสำหรับหลาย ๆ คนที่ต้องเผชิญกับงานที่คล้ายกัน!