ตามกฎแล้ว การเรียนรู้ภาษาการเขียนโปรแกรมใดๆ จะเริ่มต้นด้วยตัวอย่างการเขียนภาษาแรก โปรแกรมที่ง่ายที่สุด("สวัสดีชาวโลก!"). ทำเช่นนี้เพื่อแสดงการทำงานด้วยโครงสร้างพื้นฐานทางวากยสัมพันธ์อย่างชัดเจน เราจะไม่ให้เป็นข้อยกเว้นสำหรับวิธีการนำเสนอเนื้อหาที่เป็นที่ยอมรับโดยทั่วไปเมื่อสำรวจสภาพแวดล้อมการพัฒนาใหม่ ดังนั้นบทความแรกของเราจึงควรมองในแง่เดียวกัน ในนั้นเราจะวิเคราะห์รายละเอียดคำตอบของคำถามต่อไปนี้เกี่ยวกับการเขียนโปรแกรมบนแพลตฟอร์ม 1C:Enterprise 8:

• การเขียนโค้ดโปรแกรมในภาษา 1C ในตัวช่วยได้ที่ไหนและด้วยอะไร?
• โมดูลซอฟต์แวร์คืออะไร มีกฎการทำงานกับโมดูลอะไรบ้าง?
• ตัวแปรคืออะไร ทำงานอย่างไร จะประกาศตัวแปรอย่างไรและที่ไหน?
• มีการเปรียบเทียบ การมอบหมาย และตัวดำเนินการแบบมีเงื่อนไขใดบ้าง และคุณใช้ตัวดำเนินการเหล่านี้อย่างไร
• การดำเนินการบูลีน - คืออะไรและจะทำงานร่วมกับสิ่งเหล่านี้ได้อย่างไร?
• ทำไมเราถึงต้องการลูปและใช้งานอย่างไร?

บทความนี้จะเป็นประโยชน์กับทุกคนที่ยังไม่คุ้นเคยกับการพัฒนาบนแพลตฟอร์ม 1C:Enterprise 8 แต่ต้องการเรียนรู้วิธีการเขียนโปรแกรมบน 1C

การบังคับใช้

เนื้อหานี้เกี่ยวข้องกับแพลตฟอร์ม 1C:Enterprise 8 รุ่น 8.2 และ 8.3

ตัวแปรและตัวดำเนินการ

ในบทความนี้เราจะเริ่มศึกษาภาษาในตัว 1C:Enterprise 8 รหัสปฏิบัติการมีอยู่ในโมดูลโปรแกรม

มีโมดูลจำนวนมากที่ออกแบบมาเพื่อจัดการกับเหตุการณ์ต่างๆ

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

ดังนั้นแต่ละโมดูลจะอธิบายลักษณะการทำงานของการกำหนดค่า ณ จุดหนึ่ง ประการแรกโมดูลประกอบด้วยส่วนสำหรับอธิบายตัวแปร เหล่านั้น. เราสามารถประกาศตัวแปรบางตัวในโมดูลได้

ในอนาคตสามารถนำมาใช้ในขั้นตอนและฟังก์ชันของโมดูลนี้ได้ หากมีการกำหนดตัวแปรด้วยคำสำคัญส่งออก ตัวแปรนั้นจะพร้อมใช้งานภายนอกโมดูลนี้ ตัวอย่างบรรทัดการประกาศตัวแปร:

Perem Warehouse, Division, ผู้จัดเก็บสินค้าส่งออก;

หลังจากการประกาศตัวแปรแล้ว จะมีส่วนของขั้นตอนและฟังก์ชันต่างๆ

ด้านหลังเป็นส่วนของโปรแกรมหลักที่จะดำเนินการเมื่อเข้าถึงโมดูลนี้

ตัวอย่างเช่น ในส่วนของโปรแกรมหลัก คุณสามารถเริ่มต้นตัวแปรได้ เช่น ให้ค่าเริ่มต้นแก่พวกเขา:

รัฐ=1;
นิพจน์ใหม่=2;
ผลลัพธ์=3;

โมดูลสามารถมองได้ว่าเป็นการรวมกันของตัวดำเนินการที่แตกต่างกันซึ่งดำเนินการต่าง ๆ ที่เราต้องการ

ตัวคั่นตัวดำเนินการคือสัญลักษณ์ ";" (อัฒภาค). เครื่องหมายนี้เป็นจุดสิ้นสุดของข้อความ เหล่านั้น. ตัวดำเนินการสามารถเขียนได้ดังนี้:

ผลลัพธ์=100X200
+400
-600;

ไม่ว่าคำสั่งนั้นจะอยู่ที่กี่บรรทัดก็ตาม

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

อัฒภาคไม่สามารถวางไว้ในคำสั่งสุดท้ายของโครงสร้างที่กำหนด เช่น ขั้นตอน เหล่านั้น. รหัสต่อไปนี้จะใช้งานได้:

ขั้นตอนการคำนวณค่า()

ค่าเริ่มต้น = 100;
ค่ากลาง = InitialValue/5;
FinalValue = ค่าเริ่มต้น+ค่ากลาง

สิ้นสุดขั้นตอน

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

ตัวแปรได้รับการออกแบบมาเพื่อเก็บค่าบางประเภทข้อมูล ใช้สำหรับจัดเก็บข้อมูลระดับกลางเพื่อการประมวลผล

ในโมดูลซอฟต์แวร์เกือบทุกตัวที่ดำเนินการบางอย่าง จะมีตัวแปรต่างๆ มากมาย การพิมพ์ตัวแปรตามค่าในแพลตฟอร์ม 1C:Enterprise 8 นั้นนุ่มนวล

ตัวอย่างเช่น ตัวแปรสามารถมีค่าประเภทข้อมูลหนึ่ง จากนั้นสองสามบรรทัดต่อมา - อีกประเภทหนึ่ง:

สร้าง = เท็จ;
สร้าง = จริง;
สร้าง =100;

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

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

ตั้งชื่อตัวแปรโดยใช้คำอธิบายตัวระบุแบบคลาสสิก ตัวระบุประกอบด้วยตัวอักษร ตัวเลข และขีดล่าง ตัวระบุต้องขึ้นต้นด้วยตัวอักษรหรือขีดล่าง

ในกรณีนี้ ชื่อของตัวแปรควรสะท้อนถึงความหมายของตัวแปรนี้ ชื่อตัวแปรตัวอักษรตัวเดียว (เช่น A, B, C) เป็นตัวอย่างที่ไม่ดี พวกเขาไม่ได้สะท้อนสาระสำคัญของตัวแปร

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

คำที่สงวนไว้ เช่น Procedure, Function, Loop, EndLoop ฯลฯ ไม่สามารถใช้ในชื่อตัวแปรได้ (โครงสร้างเหล่านี้จะถูกเน้นด้วยสีแดงในโมดูลโปรแกรม)

คำสงวนเป็นตัวดำเนินการภาษาในตัวและมีจำนวนคำค่อนข้างน้อย ทั้งหมดนี้นำเสนอใน ผู้ช่วยไวยากรณ์.

ควรสังเกตว่าชนิดข้อมูลไม่ใช่คำสงวน (เช่น Array, Boolean, True, False) ระบบจะยอมรับชื่อตัวแปรดังกล่าวอย่างถูกต้อง

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

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

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

มีชื่อเรื่องมากมาย ภาษาอังกฤษค่อนข้างจำยาก เมื่อใช้สองภาษาร่วมกัน ความสามารถในการอ่านโค้ดโปรแกรมจะลดลง

การดำเนินการบูลีน

ตัวดำเนินการเปรียบเทียบมักใช้ตรรกะบูลีนที่ส่งกลับค่า True หรือ False

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

เงื่อนไขอาจค่อนข้างซับซ้อน สามารถรวมกันได้ และใช้ตัวดำเนินการต่อไปนี้: AND, OR และ NOT ดังนั้นสำหรับตัวดำเนินการ AND:

ความจริงและความจริง = ความจริง;
จริงและเท็จ = เท็จ;
เท็จและจริง = เท็จ;
เท็จและเท็จ = เท็จ

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

ตัวดำเนินการ NOT เพียงกลับค่าปัจจุบัน (False to True, True to False)

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

ตัวดำเนินการ NOT มีลำดับความสำคัญสูงสุด ตามด้วยตัวดำเนินการ AND ตามด้วยตัวดำเนินการ OR สิ่งใดก็ตามที่อยู่ในวงเล็บจะมีลำดับความสำคัญสูงสุดและจะดำเนินการก่อน

ตัวอย่างเช่น เรามาตั้งค่าลำดับความสำคัญ (ลำดับการดำเนินการ) สำหรับการดำเนินการในนิพจน์ที่กำหนด:

ไม่ใช่ (เงื่อนไข 1 หรือ เงื่อนไข 2) และ เงื่อนไข 3 หรือ เงื่อนไข 4
1.ผลลัพธ์ 1 = (เงื่อนไข 1 หรือ เงื่อนไข 2);
2. ผลลัพธ์2 = ไม่ใช่ผลลัพธ์1;
3. ผลลัพธ์ 3 = ผลลัพธ์ 2 และเงื่อนไข 1;
4. ผลลัพธ์ = ผลลัพธ์ 3 หรือ เงื่อนไข 4;

มีกฎการแปลง:

NOT (เงื่อนไข 1 หรือ เงื่อนไข 2) = ไม่ใช่ เงื่อนไข 1 และ ไม่ใช่ เงื่อนไข 2

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

ผู้ดำเนินการมอบหมาย

ไม่ควรสับสนระหว่างตัวดำเนินการกำหนดกับตัวดำเนินการความเท่าเทียม แม้ว่าจะมีตัวสะกดเหมือนกันก็ตาม

หลักการของตัวดำเนินการกำหนดคือค่าด้านซ้าย (ตัวแปรทางด้านซ้าย) จะถูกกำหนดค่าให้อยู่ทางด้านขวาของเครื่องหมายเท่ากับ ลองดูตัวอย่าง:

ตัวแปร 1 = ตัวแปร 2 = ตัวแปร 3;

Variable1 ได้รับการกำหนดค่าความเท่าเทียมกันจากตรรกะบูลีน เช่น เป็นจริงถ้า Variable2 = Variable3 หรือเป็นเท็จ

เมื่อทดสอบตำแหน่งของโปรแกรมเมอร์มือใหม่งานที่ใช้บ่อยคือการสลับค่าของตัวแปรสองตัว

ปัญหานี้แก้ไขได้โดยใช้ตัวดำเนินการมอบหมายงานและมีสองวิธีแก้ไข

โซลูชัน # 1 โดยใช้ตัวแปรชั่วคราว:
ตัวแปรชั่วคราว = ตัวแปร1;
ตัวแปร 1 = ตัวแปร 2;
Variable2 = ตัวแปรชั่วคราว;

โซลูชัน #2:
ตัวแปร 1 = ตัวแปร 1 + ตัวแปร 2;
ตัวแปร 2 = ตัวแปร 1 – ตัวแปร 2;
ตัวแปร 1 = ตัวแปร 1 – ตัวแปร 2;

ตัวดำเนินการแบบมีเงื่อนไข

มีตัวดำเนินการดังกล่าว หากหลังจากนั้นจำเป็นต้องอธิบายเงื่อนไขบางอย่าง (เงื่อนไขนั้นอาจมีขนาดค่อนข้างใหญ่) เงื่อนไขจะตามด้วยคำว่า That และคำสั่งที่จะดำเนินการ

ซึ่งอาจตามด้วยคีย์เวิร์ด Else และชุดคำสั่งอื่นๆ หากมีเงื่อนไขที่แตกต่างกันหลายประการ คุณสามารถใช้ชุดคำหลักได้ มิฉะนั้นถ้า(ดูตัวอย่างด้านล่าง) การก่อสร้างทั้งหมดจะต้องลงท้ายด้วยคำสำคัญ สิ้นสุดถ้าตามด้วยอัฒภาค

นอกจากเงื่อนไขที่เรียบง่ายและหลายเงื่อนไขแล้ว ยังมีรูปแบบที่สั้นลงของตัวดำเนินการตามเงื่อนไข: ?(Condition, Expression1, Expression2);

หากเงื่อนไขเป็นจริงก็จะถูกดำเนินการ การแสดงออก1, มิฉะนั้น - การแสดงออก2. รหัสตัวอย่าง: ExpensiveProduct = ?(Product.Price>100000, True, False);

ในทางปฏิบัติแทนที่จะเปรียบเทียบบันทึกกับค่า จริง (โกหก) พิมพ์:

ถ้าตัวแปร = จริง จากนั้น
และ
ถ้าตัวแปร = เท็จ แล้ว

สัญกรณ์เทียบเท่าที่ใช้จริงคือ:

ถ้าตัวแปรแล้ว
และ
ถ้าไม่ใช่ตัวแปรแล้ว

ตัวดำเนินการแบบวนรอบ

สำหรับลูปประเภทใดก็ตาม จำเป็นต้องใช้การบ่งชี้จุดสิ้นสุดของลูปนี้อย่างชัดเจน คำสำคัญ จุดสิ้นสุดของวงจร. มีวงจรหลายประเภท

วนซ้ำบนเคาน์เตอร์- วงจรที่มีจำนวนการทำซ้ำคงที่ เงื่อนไขในการออกจากวงจรเกินค่าจำกัด ตัวอย่างการใช้คำนวณค่าของ A!

ก = 5;
แฟกทอเรียล = 1;
สำหรับตัวนับ = 1 โดยรอบ
แฟกทอเรียล = แฟกทอเรียล * ตัวนับ;
สิ้นสุดรอบ;

วนซ้ำตามเงื่อนไข– เงื่อนไขของลูปที่กำหนดจะเป็นไปตามเงื่อนไขตราบใดที่เป็นจริง ตัวอย่าง:

จำนวนคงเหลือ = 1,000;
ราคาสินค้าเพิ่มเติม = 243;
ปริมาณ = 0;
ในขณะที่จำนวนคงเหลือ>0 รอบ
ปริมาณ = ปริมาณ +1;
จำนวนคงเหลือ = จำนวนคงเหลือ – ปริมาณ*ราคาของผลิตภัณฑ์เพิ่มเติม;
ราคาสินค้าเพิ่มเติม = ราคาสินค้าเพิ่มเติม * 0.8;
จุดสิ้นสุดของวงจร
ปริมาณ = ปริมาณ-1;

รอบนี้จะคำนวณจำนวนหน่วยของผลิตภัณฑ์ที่สามารถซื้อได้ในจำนวนที่กำหนด (1,000 รูเบิล) หากหลังจากซื้อผลิตภัณฑ์แต่ละหน่วยแล้ว ราคาก่อนหน้านี้จะคูณด้วยปัจจัย 0.8 ราคาเดิมของผลิตภัณฑ์คือ 243 รูเบิล

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

หมุนเวียนไปตามคอลเลกชัน (ชื่ออื่นสำหรับทุกคน)

มีคอลเลกชันจำนวนมากในแพลตฟอร์ม (ซึ่งเป็นคอนเทนเนอร์ที่มีองค์ประกอบบางประเภท)

คุณสามารถวนซ้ำองค์ประกอบของคอลเลกชันได้โดยใช้การวนซ้ำประเภทพิเศษ

ตัวอย่างเช่น มีอาร์เรย์ของตัวเลข คุณต้องคำนวณผลรวมขององค์ประกอบทั้งหมดของอาร์เรย์:

จำนวน = 0;
สำหรับแต่ละองค์ประกอบจาก Array Loop
ผลรวม=ผลรวม+รายการ;
สิ้นสุดรอบ;

สำหรับรอบก็มี ผู้ประกอบการพิเศษ: ดำเนินการต่อและ ยกเลิก.

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

ผู้ดำเนินการ ยกเลิกอนุญาตให้ลูปสิ้นสุดการดำเนินการแม้ว่าเงื่อนไขลูปจะเป็นจริงก็ตาม

นี่เป็นการสรุปความคุ้นเคยครั้งแรกของเรากับการพัฒนาในภาษา 1C ภายใน

แล้วเฮลโลเวิลด์ล่ะ? เรายังไม่ได้เขียนเลยใช่ไหม? ใช่ แต่ไม่มีอะไรขัดขวางไม่ให้คุณทำมันด้วยตัวเอง เพราะ... ความรู้ก็เพียงพอแล้ว ถ้าไม่ได้ผลคุณสามารถดูได้ที่นี่

ภาษาการเขียนโปรแกรมในตัวของโปรแกรม 1C:Enterprise คือภาษาโปรแกรมที่ใช้ในตระกูล 1C:Enterprise ของโปรแกรมการบัญชีอัตโนมัติ ภาษานี้เป็นคลาสของภาษาเฉพาะโดเมนระดับสูงที่คอมไพล์ไว้ล่วงหน้า สภาพแวดล้อมการดำเนินการคือแพลตฟอร์ม 1C:Enterprise (รวมถึง 1C:การบัญชี) สภาพแวดล้อมการพัฒนาด้วยภาพเรียกว่า “Configurator” และเป็นส่วนหนึ่งของแพ็คเกจ 1C:Enterprise

ภาษารองรับไวยากรณ์คำสั่งในภาษารัสเซียและอังกฤษ ภาษาถิ่นที่มาพร้อมเครื่องสำหรับเวอร์ชัน 1C:7.0, 1C:7.5 และ 1C:7.7 สามารถเข้ากันได้จากล่างขึ้นบนโดยมีข้อยกเว้นเล็กน้อย ภาษาถิ่นสำหรับ 1C:7x เข้ากันได้กับ 1C:8x ในแง่ของตัวดำเนินการหลัก แต่แตกต่างกันอย่างมากในการทำงานกับวัตถุแอปพลิเคชัน ซึ่งส่งผลให้แทบไม่สมเหตุสมผลเลยที่จะถ่ายโอนรหัสจากแพลตฟอร์ม 1C:7x ไปยัง แพลตฟอร์ม 1C:8x

ในรูปแบบไวยากรณ์ ภาษาการเขียนโปรแกรม 1C:8 จะคล้ายคลึงกับ ภาษาภาพขั้นพื้นฐาน. แพลตฟอร์มดังกล่าวมีชุดคลาสหลักคงที่ซึ่งออกแบบมาเพื่อแก้ไขปัญหาทั่วไปในด้านการใช้งาน คลาสพื้นฐานบางคลาส:

• เอกสาร,
• บันทึกเอกสาร
• คงที่,
• การรักษา,
• รายงาน,
• โอนย้าย,
• ผังบัญชี
• ไดเร็กทอรี ฯลฯ

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

ประเภทของออบเจ็กต์เมตาดาต้าเหล่านี้ ได้แก่ กระบวนการทางธุรกิจ เอกสาร งาน การประมวลผล รายงาน แผนประเภทและคุณลักษณะการคำนวณ ผังบัญชี การลงทะเบียนการสะสม การคำนวณและข้อมูล ไดเรกทอรี โครงการที่เขียนด้วยภาษา 1C:Enterprise เรียกว่าการกำหนดค่า การขาย การใช้งาน และการบำรุงรักษา 1C และการกำหนดค่าเป็นกิจกรรมเชิงพาณิชย์หลักของบริษัทพันธมิตร 1C

นอกจากนี้ยังมีส่วนประกอบเพิ่มเติมที่ขยายคลาสหลักให้อนุญาต การสร้างฟรีและเปลี่ยนแปลง อย่างไรก็ตาม นักพัฒนาไม่แนะนำให้ใช้ส่วนประกอบเหล่านี้ ในทางปฏิบัติ การใช้งานทำให้เกิดการละทิ้ง การสนับสนุนทางเทคนิคจากบริษัท 1C และพันธมิตร

ตัวอย่างเช่น ส่วนประกอบ 1C++ จะขยายภาษาโดยใช้ OOP แบบเต็ม การใช้งานช่วยเพิ่มความเป็นไปได้ในการกำหนดค่า 1C นี่เป็นผลิตภัณฑ์ฟรีที่เผยแพร่ภายใต้ใบอนุญาต GNU GPL แบบเปิด

นอกจากนี้ยังมีโครงการ 2C ฟรีที่ไม่ใช้โมดูลที่เป็นกรรมสิทธิ์จาก 1C และผู้ผลิตซอฟต์แวร์รายอื่น นี่คือคอร์ที่ขยายได้ของระบบที่คล้ายกับ 1C ซึ่งเขียนใหม่ตั้งแต่ต้น ซึ่งแจกจ่ายอย่างอิสระภายใต้ลิขสิทธิ์ GNU GPL “อ็อบเจ็กต์ในตัว” 1C เช่น รีจิสเตอร์และไดเร็กทอรี เป็นคลาสที่แอปพลิเคชันโปรแกรมเมอร์สามารถแทนที่ได้

ในตอนแรก ภาษา 1C มีชื่อทำงานว่า "1Sik" ซึ่งออกเสียงว่า "odynesik" อย่างไรก็ตามมันก็หายไปอย่างรวดเร็วจากการใช้ในแหล่งข้อมูลอย่างเป็นทางการ เมื่อมีการกล่าวถึงภาษาบิวท์อินนี้ในเอกสาร ปัจจุบันเรียกว่า "ภาษาโปรแกรม 1C" บน ช่วงเวลานี้ไม่มีชื่อของตัวเองที่สะดวกต่อการออกเสียงด้วยวาจา ในบริบทของการพูดคุยถึงแพ็คเกจ 1C:Enterprise มักเรียกง่ายๆ ว่า "ภาษาในตัว"

ฉันต้องการรีวิวโปรแกรมตัวอย่างที่แสดงคำทักทายแบบดั้งเดิมสำหรับผู้เริ่มต้นเรียนรู้ภาษาการเขียนโปรแกรม:

รายงาน("สวัสดีชาวโลก!");

รหัสนี้จะทำงานใน 1C:Enterprise เวอร์ชัน 7.7

21.12.2010

สิ่งพิมพ์ก่อนหน้า:

สำหรับทุกคนที่ต้องการเข้าสู่การเขียนโปรแกรม เราต้องการอธิบายสิ่งง่ายๆ ที่ไม่ได้กล่าวถึงในหนังสือเรียนการเขียนโปรแกรมทั้งหมด แต่ผู้ที่ต้องการเชี่ยวชาญการเขียนโปรแกรมในภาษา 1C ตั้งแต่เริ่มต้นควรรู้เรื่องนี้

1. ภาษาการเขียนโปรแกรมคือภาษาอย่างแรกเลย

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

2. ฝึกฝน

คุณคงเคยได้ยินมาว่าคนที่รู้ภาษาต่างประเทศบางคนค่อยๆ ลืมไปโดยไม่ได้ฝึกใช้ หลังจากศึกษาพื้นฐานของการเขียนโปรแกรมบน 1C แล้ว ฝึกฝนทุกวันในการทำงานง่าย ๆ เพื่อไม่ให้สูญเสียความรู้ที่ได้รับมาก่อนหน้านี้และค่อยๆ ทำงานที่ซับซ้อนมากขึ้น พัฒนาทักษะของคุณ

ทุกธุรกิจจะดำเนินไปได้ดีขึ้นหากมีแรงจูงใจสำหรับคุณในอนาคต ทักษะการเขียนโปรแกรมเป็นรางวัลที่เป็นตัวเงิน งานที่ดี, ลิฟต์สังคมง่าย ฯลฯ ไม่มีความลับใดที่ผลิตภัณฑ์ซอฟต์แวร์ 1C Enterprise ได้รับความนิยมอย่างมากในพื้นที่หลังโซเวียต จากสิบบริษัท มีแปดบริษัทใช้โปรแกรม 1C เพื่อบันทึกกิจกรรมทางธุรกิจของตน ดังนั้นพวกเขาต้องการผู้ดูแลระบบหรือโปรแกรมเมอร์ 1C ที่จะดูแลและแก้ไขโปรแกรม โดยธรรมชาติแล้วตลาดดังกล่าวต้องการผู้เชี่ยวชาญ 1C บางครั้งบริษัทต่างๆ ก็พร้อมที่จะจ้างพนักงานที่มีคุณสมบัติไม่สูงมากนักซึ่งมีทักษะการเขียนโปรแกรมเพื่อให้ได้เงินเดือนที่เหมาะสมโดยมีเงื่อนไขของการพัฒนาตนเอง และแม้ว่าคุณจะไม่ต้องการทำงานให้กับบริษัทเชิงพาณิชย์หรือแฟรนไชส์ ​​โปรแกรมเมอร์ที่มีคุณสมบัติเหมาะสมก็สามารถหางานในการแลกเปลี่ยนอิสระหรือดำเนินโครงการที่กำหนดเองได้ โดยทั่วไปแล้วโปรแกรมเมอร์ 1C จะไม่ถูกทิ้งไว้โดยไม่มีงาน

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

ในบทความนี้เราจะพิจารณาการสร้างภาษาโปรแกรม 1C เช่น รอบ.

มีสามวิธีในการจัดระเบียบลูป

1. วนซ้ำโดยใช้นิพจน์เชิงตรรกะ (ดำเนินการจนกระทั่ง การแสดงออกทางตรรกะจริง)
2. วนซ้ำผ่านคอลเลกชัน

ลองดูแต่ละวิธีเหล่านี้

วนซ้ำโดยใช้ตัวแปรตัวนับวนซ้ำ

ไวยากรณ์:

สำหรับ< Переменная> = < НачальноеЗначение>โดย< КонечноеЗначение>วงจรEndCycle;

ด้วยวิธีการจัดระเบียบลูปนี้ ตัวแปรตัวนับจะถูกกำหนดค่าเริ่มต้นที่แน่นอน และจะดำเนินการจนกว่าค่าของตัวแปรตัวนับจะน้อยกว่าหรือเท่ากับค่าสุดท้ายที่ระบุ

ในการวนซ้ำแต่ละครั้ง ค่าตัวนับจะเพิ่มขึ้นทีละหนึ่ง นี่คือตัวอย่างพื้นฐานที่สุดของการวนซ้ำ:

สำหรับตัวนับ = 0 ถึง 1,000 รอบการสิ้นสุดรอบ;

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

สำหรับตัวนับ = 0 ถึง 1,000 รอบ ตัวนับ = ตัวนับ + 10 ; เอ็นด์ไซเคิล ;

วนซ้ำโดยใช้นิพจน์บูลีน

ไวยากรณ์:

ลาก่อน< ЛогическоеВыражение>วงจรEndCycle;

ปฏิเสธ = เท็จ ; GeneratorRandom = NewRandomNumberGenerator(1) ; จนกระทั่งรอบความล้มเหลว RandomNumber = GeneratorRank สุ่มตัวเลข(0, 10); ถ้า RandomNumber > 5 ความล้มเหลว = True ; สิ้นสุดถ้า ; เอ็นด์ไซเคิล ;

นั่นคือการวนซ้ำจะทำงานจนกว่าจะสร้างตัวเลขสุ่มที่มากกว่าห้า

วนซ้ำผ่านคอลเลกชัน

ในภาษาการเขียนโปรแกรม 1C มีสิ่งดังกล่าวเป็นคอลเลกชัน เป็นชุดขององค์ประกอบที่อยู่ภายในวัตถุ

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

แต่ละ< ЭлементКоллекции>จาก< Коллекция>วงจรEndCycle;

ที่นี่ <ЭлементКоллекции> เป็นตัวแปรที่องค์ประกอบจากคอลเลกชันถูกวางตามลำดับ และภายในลูปก็จะถูกประมวลผลตามนั้น
ตามตัวอย่าง ฉันจะให้คุณวนซ้ำในแถวของตารางค่า ให้มันเรียกว่า ตารางผลิตภัณฑ์และมีลักษณะดังนี้:

มาดูตารางนี้แบบวนซ้ำแล้วสำหรับแต่ละแถวเราจะแสดงข้อความพร้อมชื่อและราคาของผลิตภัณฑ์:

สำหรับแต่ละแถวของตารางจากชื่อวงจรผลิตภัณฑ์ตาราง = แถวของตาราง ชื่อ; ราคา = แถวตาราง ราคา; ข้อความ = MessageToUser ใหม่; ข้อความ. ข้อความ = "ชื่อผลิตภัณฑ์:"

ในความเป็นจริงสิ่งเดียวกันนี้สามารถทำได้โดยใช้ตัวเลือกแรกนั่นคือในการวนซ้ำโดยใช้ตัวนับ:

จำนวนแถว = TableProducts ปริมาณ() ; สำหรับตัวนับ = 0 ตามจำนวนแถว - 1 รอบตาราง แถว = TableProducts[ ตัวนับ] ; ชื่อ = แถวของตาราง ชื่อ; ราคา = แถวตาราง ราคา; ข้อความ = MessageToUser ใหม่; ข้อความ. ข้อความ = "ชื่อผลิตภัณฑ์:"+ ชื่อ + "; ราคา: " + ราคา; ข้อความ. เพื่อรายงาน() ; เอ็นด์ไซเคิล ;

แต่อย่างที่เราเห็น การใช้การข้ามองค์ประกอบคอลเลกชันนั้นง่ายกว่าและสะดวกกว่ามาก

ผู้ประกอบการเสริม

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

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

สำหรับตัวนับ = 0 ถึง 100 รอบ ถ้าตัวนับ = 0 ให้ดำเนินการต่อ; สิ้นสุดถ้า ; หากตัวนับ = 4 ให้ยกเลิก ; สิ้นสุดถ้า ; ผลลัพธ์ = 1 / ตัวนับ; ข้อความ = MessageToUser ใหม่; ข้อความ. ข้อความ = สตริง (ผลลัพธ์) ; ข้อความ. เพื่อรายงาน() ; เอ็นด์ไซเคิล ;

เราข้ามศูนย์เพราะว่า คุณไม่สามารถหารด้วยศูนย์ได้ และการวนซ้ำจะถูกดำเนินการทั้งหมดห้าครั้งสำหรับค่าของตัวแปร เคาน์เตอร์จาก 0 ถึง 4

1. ภาษา 1C คืออะไร?
2. วิธีการ ตัวแปร โครงสร้างภาษาอื่นๆ

ภาษา 1C คืออะไร?

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

1. โมดูลแอปพลิเคชัน

2. โมดูลทั่วไป

3. โมดูลวัตถุ

4. โมดูลแบบฟอร์ม

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

วิธีการ ตัวแปร โครงสร้างภาษา

ตัวแปรใช้เพื่อจัดเก็บข้อมูลระหว่างเซสชันผู้ใช้ ตัวแปรคือคำที่ขึ้นต้นด้วยตัวอักษร (ภาษารัสเซียหรืออังกฤษ) หรือขีดล่าง “_” และประกอบด้วยตัวอักษร ตัวเลข และขีดล่าง
ตัวอย่างเช่น :

• นี่คือตัวแปร
• _นี่คือตัวแปร
• _นี่คือ 1_ตัวแปร

ความจริงที่ว่าตัวอักษรอาจเป็นภาษารัสเซียและภาษาอังกฤษสามารถเล่นเป็นเรื่องตลกที่โหดร้ายได้เมื่อใช้ตัวอักษรที่มีการออกแบบคล้ายกันจากภาษาต่างๆ

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

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

ตัวอย่างเช่น: วัตถุ “ใบเสร็จรับเงินการขายหมายเลข 00018 ลงวันที่ 01/01/2548”
เราสามารถแยกความแตกต่างใบเสร็จรับเงินการขายนี้จากใบเสร็จรับเงินการขายอื่น ๆ ตามรายละเอียดที่มีอยู่ นี่คือแอตทริบิวต์ "Number" ที่มีค่า "00018"( ประเภทสตริง ) และแอตทริบิวต์ "วันที่" ( พิมพ์วันที่ ) ด้วยค่า “01/01/2548” สิ่งเดียวที่เราสามารถกำหนดได้จากวัตถุโดยไม่ทราบค่าของรายละเอียดคือประเภท "ใบเสร็จรับเงินการขาย"
วิธีการมีขนาดเล็กและมักจะให้คำแนะนำครบถ้วน

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

โครงสร้างภาษาอื่นๆ (ตัวดำเนินการ การรวบรวมค่า ฯลฯ) คือคำที่สงวนไว้โดยระบบ 1C ที่ช่วยจัดการข้อมูล

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

สำหรับแต่ละองค์ประกอบคอลเลกชันจากชื่อคอลเลกชัน Cycle EndCycle

ตัวอย่างนี้แสดงการออกแบบสำหรับการวนซ้ำองค์ประกอบของคอลเลกชัน การออกแบบนี้มีชื่อว่า วงจร . ประเภทของออบเจ็กต์ส่วนใหญ่ รวมถึงรายละเอียด เป็นคอลเลกชันที่สามารถวนซ้ำในลักษณะข้างต้น และเข้าถึงองค์ประกอบของคอลเลกชันโดยการระบุดัชนี (CollectionName[0]) คอลเลกชันทั้งหมดเริ่มต้นด้วยองค์ประกอบที่มีดัชนี = 0