วันพุธที่ 26 พฤศจิกายน พ.ศ. 2551

การเขียนโปรแกรม

1. ความหมายของโปรแกรม โปรแกรมคอมพิวเตอร์ หมายถึง คำสั่งหรือชุดคำสั่ง ที่เขียนขึ้นมาเพื่อสั่งให้เครื่องคอมพิวเตอร์ทำงานตามที่เราต้องการ เราจะให้คอมพิวเตอร์ทำอะไรก็เขียนเป็นคำสั่ง ซึ่งต้องสั่งเป็นขั้นตอนและแต่ละขั้นตอนต้องทำอย่างละเอียดและครบถ้วน ซึ่งจะเกิดเป็นงานชิ้นหนึ่งขึ้นมามีชื่อเรียกว่า "โปรแกรม" ซอฟต์แวร์จะแบ่งออกเป็นประเภทใหญ่ ๆ ได้ 2 ประเภท คือ 1.1 ซอฟต์แวร์ระบบ (System Software) 1.2 ซอฟต์แวร์ประยุกต์ (Application Software) 1.1 ซอฟต์แวร์ระบบ (System Software) ซอฟต์แวร์ระบบ หมายถึงโปรแกรมที่ทำหน้าที่ควบคุมการทำงานของฮาร์ดแวร์ทุกอย่างและอำนวยความสะดวกให้กับผู้ใช้เครื่องคอมพิวเตอร์ ซึ่งแบ่งแต่ละโปรแกรมตามหน้าที่การทำงานดังนี้ 1.1.1 OS (Operating System) คือโปรแกรมระบบที่ทำหน้าที่ควบคุมการใช้งานส่วนต่างๆของเครื่องคอมพิวเตอร์เช่นควบคุมหน่วยความจำควบคุมหน่วยประมวลผลควบคุมหน่วยรับและควบคุมหน่วยแสดงผล ตลอดจนแฟ้มข้อมูลต่าง ๆ ให้มีประสิทธิภาพสูงที่สุด และสามารถใช้อุปกรณ์ทุกส่วนของคอมพิวเตอร์มาทำงานได้อย่างเต็มที่ นอกจากนั้นยังเข้ามาช่วยจัดสรรการใช้ทรัพยากรในเครื่องและช่วยจัดการกระบวนการพื้นฐานที่สำคัญ ๆ ภายในเครื่องคอมพิวเตอร์ เช่น การเปิดหรือปิดไฟล์การสื่อสารกันระหว่างชิ้นส่วนต่าง ๆ ภายในเครื่อง การส่งข้อมูลออกสู่เครื่องพิมพ์หรือจอภาพ เป็นต้น ก่อนที่เครื่องคอมพิวเตอร์แต่ละเครื่องจะสามารถอ่านไฟล์ต่าง ๆ หรือสามารถใช้ซอฟต์แวร์ต่าง ๆ ได้จะต้องผ่านการดึงระบบปฏิบัติการออกมาฝังตัวอยู่ในหน่วยความจำก่อน ปัจจุบันนี้มีโปรแกรมระบบอยู่หลายตัวด้วยกัน ซึ่งแต่ละตัวนั้นก็เป็นโปรแกรมระบบปฏิบัติการเหมือนกัน แต่ต่างกันที่ลักษณะการทำงานจะไม่เหมือนกัน ดังนี้ - DOS (Disk Operating System) เป็นระบบปฏิบัติการที่นิยมใช้กันมาตั้งแต่ในอดีตออกมาพร้อมกับเครื่องพีซีของไอบีเอ็มรุ่นแรก ๆ จากนั้นก็มีการพัฒนารุ่นใหม่ออกมาเรื่อย ๆ จนกระทั่งถึงเวอร์ชั่นสุดท้ายคือ เวอร์ชั่น 6.22 หลังจากที่มีการประกาศใช้วินโดวส์ 95 ก็คงจะไม่ผลิต DOS เวอร์ชั่นใหม่ออกมาแล้ว โดยทั่วไปจะนิยมใช้วินโดวส์ 3.x ซึ่งถือว่าเป็นโปรแกรมเสริมชนิดหนึ่งที่ใช้ในดอส - UNIX เป็นระบบ ปฏิบัติการที่สามารถใช้ร่วมกันได้หลายคน (Multiuser) หรือเป็นระบบปฏิบัติการแบบเครือข่ายโดยที่ผู้ใช้แต่ละคนจะต้องมีชื่อและพาสเวิร์ดส่วนตัวและสามารถเชื่อมโยงถึงกันได้ถึงทั่วโลกโดยผ่านทางสายโทรศัพท์และมี Modem เป็นตัวกลางในการรับส่งข้อมูลหรือโอนย้ายข้อมูลนิยมใช้แพร่หลายในมหาวิทยาลัยหน่วยงานรัฐบาลหรือบริษัทเอกชนที่มีระบบคอมพิวเตอร์ใหญ่ๆใช้ในระบบยูนิกซ์เองก็มีวินโดวส์อีกชนิดหนึ่งใช้เรียกว่า X Windows สำหรับผู้ที่ต้องการใช้ระบบยูนิกซ์ในเครื่องพีซีที่บ้านก็มีเวอร์ชั่นสำหรับพีซีเรียกว่า Linux ซึ่งจะมีคำสั่งพื้นฐานคล้าย ๆ กับระบบยูนิกซ์ - Linux เป็นระบบปฏิบัติการตัวหนึ่งเช่นเดียวกับ DOS,Windows และ Unix แต่ Linux นั้นจัดว่าเป็นระบบปฏิบัติการ Unix ประเภทหนึ่งในปัจจุบันนี้มีการใช้ Linux กันมากเนื่องจากความสามารถของตัวระบบปฏิบัติการและโปรแกรมประยุกต์ที่ทำงานบนระบบ Linux ได้พัฒนาขึ้นมามากมายโดยเฉพาะอย่างยิ่งโปรแกรมในตระกูลของGNU (GNU's Not UNIX) และสิ่งที่สำคัญที่สุดคือระบบ Linux เป็นระบบปฏิบัติการประเภทฟรีแวร์ (Free Ware) คือไม่เสียค่าใช้จ่ายในการซื้อโปรแกรมระบบ Linux และนอกจากนั้น Linux ยังสามารถทำงานได้บน CPU ทั้ง 3 ตระกูลคือบน CPU ของอินเทล (PCIntel) ดิจิตอลอัลฟาคอมพิวเตอร์ (Digital Alpha Computer) และซันสปาร์ (SUNSPARC) ปัจจุบันนี้ได้มีการนำระบบปฏิบัติการ Linux ไปประยุกต์ใช้เป็นระบบปฏิบัติการแบบเครือข่ายสำหรับงานด้านต่างๆ เช่นงานด้านการคำนวณสถานีงานสถานีบริการต่างๆ ระบบอินเทอร์เน็ตภายในองค์กรใช้ในการเรียนการสอน การทำวิจัยทางคอมพิวเตอร์ การพัฒนาโปรแกรม เป็นต้น - LAN เป็นระบบปฏิบัติการแบบเครือข่ายเช่นเดียวกัน แต่จะใช้เชื่อมโยงกันใกล้ ๆ เช่น ในอาคารเดียวกันหรือระหว่างอาคารที่อยู่ใกล้กัน โดยใช้สาย Lan เป็นตัวเชื่อมโยง - WINDOWS เป็นระบบปฏิบัติการที่กำลังนิยมใช้กันมากในปัจจุบัน ซึ่งพัฒนามาถึงรุ่นแล้ว Windows 2000 แล้ว บริษัทไม่โครซอฟต์ได้เริ่มประกาศใช้ MS Windows 95 ครั้งแรกเมื่อ 24 สิงหาคม ค.ศ. 1995 โดยมีความคิดที่ว่าจะออกมาแทน MS-DOS และ วินโดวส์ 3.x ที่ใช้ร่วมกันอยู่ลักษณะของวินโดวส์ 95 จึงคล้ายกับระบบโอเอสที่มีทั้งดอสและวินโดวส์อยู่ในตัวเดียวกันแต่เป็นวินโดวส์ที่มีลักษณะพิเศษกว่าวินโดวส์เดิม เช่น มีคุณสมบัติเป็น Plug and Play ซึ่งสามารถจะรู้จักฮาร์ดแวร์ต่าง ๆ ที่ติดตั้งอยู่ในเครื่องได้โดยอัตโนมัติ มีลักษณะเป็นระบบ 32 บิต ในขณะที่วินโดวส์เดิมเป็นระบบ 16 บิต เป็น - WINDOWS NT เป็นระบบ OS ที่ผลิตมาจากบริษัท IBM เป็นระบบ 32 บิต ที่มีรูปลักษณ์เป็นกราฟิกที่ต้องใช้เม้าส์ คล้ายกับวินโดวส์ทั่วไปเช่นกัน 1.1.2 Translation Program คือ โปรแกรมระบบที่ทำหน้าที่ในการแปลโปรแกรม หรือชุดคำสั่งที่เขียนด้วยภาษาที่ไม่ใช่ภาษาเครื่องหรือภาษาเครื่องที่ไม่เข้าใจให้เป็นภาษาที่เครื่องเข้าใจ และนำไปปฏิบัติได้ เช่น ภาษาBASIC,COBOL,C,PASCAL, FORTRAN,ASSEMBLY เป็นต้น สำหรับตัวแปลนั้นจะมีอยู่ 3 แบบคือ - Assembler เป็นโปรแกรมที่ใช้แปลภาษาแอสแซมบลี ซึ่งมีลักษณะการแปรทีละคำสั่ง เมื่อทำตามคำสั่งนั้นเสร็จแล้ว ก็จะแปลคำสั่งถัดไปเรื่อย ๆ จนจบ - อินเตอร์พรีเตอร์ (Interpreter) เป็นตัวแปลภาษาระดับสูงเช่นเดียวกับคอมไพล์เลอร์แต่จะแปลพร้อมกับทำงานตามคำสั่งทีละคำสั่งตลอดไปทั้งโปรแกรม ทำให้การแก้ไขโปรแกรมทำได้ง่ายปละรวดเร็ว การแปลโดยใช้อินเตอร์พรีเตอร์จะไม่สร้างโปรแกรมเรียกใช้งาน ดังนั้นจะต้องทำการแปลใหม่ทุกครั้งที่มีการเรียกใช้งาน ตัวอย่างตัวแปลภาษาที่ใช้ตัวแปลอินเตอร์พรีเตอร์ เช่น ภาษาเบสิก (BASIC) - คอมไพเลอร์ (Compiler) เป็นตัวแปลภาษาระดับสูง เช่น ภาษาปาสคาล ภาษาโคบอลและภาษาฟอร์เเทรน การทำงานจะใช้หลักการแปลโปรแกรมต้นฉบับทั้งโปรแกรมให้เป็นโปรแกรมเรียกใช้งาน (executable program) ซึ่งจะถูกบันทึกไว้ในลักษณะของแฟ้มข้อมูลหรือไฟล์ เมื่อต้องการเรียกใช้งานโปรแกรมก็สามารถเรียกใช้จากไฟล์เรียกใช้งานโดยไม่ต้องทำการแปลหรือคอมไพล์อีก ทำให้การทำงานเป็นไปอย่างรวดเร็ว ขณะที่คอมไพล์โปรแกรมต้นฉบับที่เขียนขึ้นด้วยภาษาระดับสูง คอมไพล์เลอร์จะตรวจสอบโครงสร้างไวยกรณ์ของคำสั่งและข้อมูลที่ใช้ในการคำนวณและเปรียบเทียบต่อจากนั้นคอมไพล์เลอร์จะสร้างรายการข้อผิดพลาดของโปรแกรม (Program Listing) เพื่อใช้เก็บโปรแกรมต้นฉบับและคำสั่งที่เขียนไม่ถูกต้องตามกฎหรือโครงสร้างของภาษานั้น ๆ ไฟล์นั้นมีประโยชน์ในการช่วยโปรแกรมเมอร์ในการแก้ไขโปรแกรม (Debug) 1.1.3 Utility Program คือโปรแกรมระบบที่ทำหน้าที่ในการอำนวยความสะดวกให้กับผู้ใช้เครื่องคอมพิวเตอร์ ให้สามารถทำงานได้สะดวก รวดเร็วและง่ายขึ้น เช่น โปรแกรมที่ใช้ในการเรียงลำดับข้อมูล โปรแกรมโอนย้ายข้อมูลจากชนิดหนึ่งไปยังอีกชนิดหนึ่ง โปรแกรมรวบรวมข้อมูล 2 ชุดด้วยกัน โปรแกรมคัดลอกข้อมูล เป็นต้น สำหรับโปรแกรมที่ทำงานในด้านนี้ ได้แก่ Pctools,Sidekick,PKZIP,PKUNZIP Norton Utility เป็นต้น 1.1.4 Diagnostic Program คือโปรแกรมระบบที่ทำหน้าที่ตรวจสอบข้อผิดพลาด ในการทำงานของอุปกรณ์ต่าง ๆ ของเครื่องคอมพิวเตอร์ ได้แก่ โปรแกรม QAPLUS โปรแกรม NORTON เป็นต้น และเมื่อพบข้อผิดพลาดก็จะแจ้งขึ้นมาบนจอภาพให้ทราบ เช่น ถ้ามีการตรวจสอบแล้วปรากฏว่า Keyboard บางปุ่มเสียไปก็จะแจ้งบอกขึ้นมาเป็นรหัสให้ผู้ใช้ทราบ หรือในกรณีที่ Card จอปกติไม่สามารถแสดงภาพได้ ก็จะบอกในลักษณะของเสียงแทน เช่นเดียวกับ RAM ถ้าเสียก็จะมีเสียงบอกขึ้นมา 1.2 ซอฟต์แวร์ประยุกต์ (Application Software) หมายถึง โปรแกรมที่ผู้ใช้คอมพิวเตอร์เป็นผู้เขียนขึ้นมาใช้เองเพื่อสั่งให้เครื่องคอมพิวเตอร์ทำงานอย่างใดอย่างหนึ่งตามที่ต้องการ ซึ่งแบ่งได้ดังนี้ 1.2.1 User Program คือโปรแกรมที่ผู้ใช้เขียนขึ้นมาใช้เองโดยใช้ภาษาระดับต่างๆทางคอมพิวเตอร์เช่นภาษาBASICCOBOL,PASCAL,C,ASSEMBLY,FORTRAN ฯลฯ ซึ่งจะใช้ภาษาใดขึ้นอยู่กับความเหมาะสมของงานเหล่านั้น เช่น โปรแกรมระบบบัญชี,โปรแกรมควบคุมสต็อกสินค้า,โปรแกรมแฟ้มทะเบียนประวัติ,โปรแกรมคำนวณภาษี,โปรแกรมคอดเงินเดือน เป็นต้น 1.2.2 Package Program คือโปรแกรมสำเร็จรูป ซึ่งเป็นโปรแกรมที่ถูกสร้างหรือเขียนขึ้นมาโดยบริษัทต่าง ๆ เสร็จเรียบร้อยแล้วพร้อมที่จะนำมาใช้งานต่าง ๆ ได้ทันที ตัวอย่างเช่น - Word Processer โปรแกรมที่ช่วยในการทำเอกสาร พิมพ์งานต่าง ๆ เช่น เวิร์ดจุฬา,เวิร์ดราชวิถี,Microsoft Word,WordPerfect,Amipro เป็นต้น - Spreadsheet โปรแกรมที่ใช้ในการคำนวณข้อมูล มีลักษณะเป็นตาราง เช่น Lotus 1-2-3,Microsoft Excel เป็นต้น - Database โปรแกรมที่ใช้ในการทำงานทางด้านฐานข้อมูลจะใช้เก็บรวบรวมข้อมูล ต่าง ๆ ที่มีขนาดใหญ่ และมีข้อมูลเป็นจำนวนมาก เช่นdBASEIIIPlus, Foxbase, Microsoft Access Foxpro, Visual Foxpro, Pracle, Infomix, DB2 เป็นต้น - Graphic โปรแกรมที่ใช้ในการทำงานทางด้านสร้างรูปภาพและกราฟิกต่าง ๆ รวมทั้งงานทางด้านสิ่งพิมพ์ การทำโบรชัวร์ แผ่นพับ นามบัตร เช่น CorelDraw, Photoshop, Harvard Graphic, Freelance Graphic, PowerPoint, PageMaker เป็นต้น - Internet โปรแกรมที่ใช้งานบน Internet เท่านั้น โดนจะต้องเรียกใช้ผ่านทาง Browser ซึ่งอาจจะเป็น Netscape Communicator หรือ Internet Explorer โดยการติดตั้งผ่านทางแผ่น CD-Rom หรือ Download ขึ้นมาติดตั้งก็ได้ สำหรับโปรแกรมที่นิยมใช้ในปัจจุบัน
2. ขั้นตอนการพัฒนาระบบ วัฏจักรในการพัฒนาระบบ แบ่งออกเป็น 6 ขั้นตอนคือ 2.1 System investigation เป็นขั้นตอนในการศึกษาความต้องการของผู้ใช้ซึ่งจะนำข้อมูลต่าง ๆ ที่ได้มากำหนดความต้องการของระบบและศึกษาความเป็นไปได้ของการพัฒนาระบบ กรณีที่สามารถพัฒนาระบบงานได้ตามความต้องการของผู้ใช้ จะดำเนินงานตามขั้นตอนขั้นต่อไป 2.2 System analysis เป็นขั้นตอนในการวิเคราะห์ในรายละเอียดถึงความต้องการต่างๆ ของผู้ใช้ระบบรวมทั้งความต้องการของหน่วยงานและระบบอื่นๆ ที่ใช้อยู่ในปัจจุบันในด้านการประมวลผลทางด้านข้อมูลเข้า (input) ข้อมูลออก (output) หน่วยความจำ (storage) และควบคุมให้ได้ตรงตามความต้องการซึ่งเป็นจุดมุ่งหมายของระบบ 2.3 System design เป็นขั้นตอนในการพัฒนาโปรแกรม โดยระบุถึงฮาร์ดแวร์ที่ใช้ในระบบ เช่น อุปกรณ์และสื่อต่างๆ ที่ใช้ รวมทั้งซอฟต์แวร์ เช่น โปรแกรมและวิธีการดำเนินงาน (procedure) เป็นต้น บุคลากรในระบบ เช่น ผู้ใช้และผู้เชี่ยวชาญ รวมทั้งออกแบบโครงสร้างของข้อมูลทั้งในด้านข้อมูลเข้าข้อมูลออก การประมวลผลข้อมูล หน่วยเก็บข้อมูล (storage) และฟังก์ชันควบคุมของระบบใหม่ 2.4 Software development เป็นขั้นตอนในการพัฒนาโปรแกรม โดยสร้างโปรแกรมขึ้นมาเพื่อให้สามารถทำงานได้ตามที่ได้ออกแบบระบบไว้ 2.5 System implementation เป็นขั้นตอนของการใช้งาน โดยการนำเอาโปรแกรมที่พัฒนาสมบูรณ์ไปติดตั้งทำการทดสอบระบบรวมทั้งฝึกฝนให้ผู้ใช้ระบบสามารถปฏิบัติงานโดยใช้ระบบใหม่นี้ได้ 2.6 System maintenance เป็นขั้นตอนในการบำรุงรักษาระบบ โดยตรวจสอบหรือควบคุมการทำงานของระบบคอมพิวเตอร์และแก้ไขระบบเมื่อต้องการ3. ระยะต่าง ๆ ของการเขียนโปรแกรม (The Stages of the Programming Process) การเขียนโปรแกรมคอมพิวเตอร์ คือ วิธีการในการพัฒนาโปรแกรมคอมพิวเตอร์ซึ่งประกอบด้วยกลุ่มของคำสั่งซึ่งสั่งให้เครื่องคอมพิวเตอร์ประมวลผลหรือกิจกรรมต่างๆซึ่งเกี่ยวของกับการเขียนคำสั่งในภาษาโปรแกรมต่าง ๆ ซึ่งสามารถแบ่งได้เป็นหลายระยะคือ 3.1 Program analysis เป็นระยะของการวิเคราะห์ถึงจุดประสงค์ของงานประยุกต์ โดยกำหนดถึงหน้าที่ต่าง ๆ ที่จะให้โปรแกรมทำงานได้ 3.2 Program design เป็นระยะของการวางแผนและออกแบบถึงคุณลักษณะของข้อมูลเข้า (input) ข้อมูลออก (output) หน่วยเก็บข้อมูล วิธีดำเนินการประมวลผล 3.3 Program coding เป็นระยะของการเขียนคำสั่งภาษาโปรแกรมซึ่งเปลี่ยนจาก Program design เป็นโปรแกรมคอมพิวเตอร์ที่สมบูรณ์ 3.4 Program verification เป็นระยะของการตรวจทานทดสอบโปรแกรมที่เขียนขึ้นให้ถูกต้องและสมบูรณ์ตรงตามความต้องการของระบบ ซึ่งเรียกว่า debugging และ testing 3.5 Program documentation เป็นระยะของการบันทึกรายละเอียดของการออกแบบและรายละเอียดของโปรแกรม โดยจัดทำเป็นคู่มือและเอกสารของระบบ 3.6 Program maintenance เป็นระยะของการปรับปรุงหรือสร้างโปรแกรมคอมพิวเตอร์ เพื่อพัฒนาให้ดีขึ้นซึ่งอาจจะขยายขีดความสามารถหรือปรับปรุงให้ถูกต้องยิ่งขึ้น 4. การวิเคราะห์โปรแกรม (Program analysis) การวิเคราะห์โปรแกรมเป็นขั้นตอนแรกในการเขียนโปรแกรมคอมพิวเตอร์โดยการวิเคราะห์ถึงหน้าที่ต่างๆ ของโปรแกรมโดยแบ่งเป็นงานหรือฟังก์ชันฟังก์ชันหนึ่งอาจปฏิบัติการได้ก็ต่อเมื่อปฏิบัติงานอีกฟังก์ชันหนึ่งเสร็จก่อน การวิเคราะห์ปัญหาต่างๆ ของโปรแกรมอาจเป็นปัญหาสั้นๆ พื้นฐานหรือปัญหาทางคณิตศาสตร์ซับซ้อน ซึ่งจะต้องกำหนดปัญหา (Problem Definition) และกำหนดรายละเอียดของปัญหา (Problem Specification) ในการปฏิบัติงานให้ชัดเจน ในกรณีที่งานประยุกต์เป็นงานประมวลผลข้อมูลการวิเคราะห์โปรแกรมควรวิเคราะห์ถึงข้อกำหนดรายละเอียดของซอฟต์แวร์ (Software Specification) ในระยะของการออกแบบ (Design Stage) หรือความต้องการในรายละเอียดของโปรแกรม (Program Specification) อย่างเช่น 1. Output โดยวิเคราะห์ว่าผลลัพธ์ที่ต้องการคืออะไรบ้าง 2. Input โดยวิเคราะห์ว่าข้อมูลที่สามารถเรียกหาได้มีอะไรได้บ้าง 3. Storage โดยวิเคราะห์ว่าข้อมูลจะเก็บ (store) หรือดึง (retrieved) หรือแก้ไขในหน่วยเก็บข้อมูลอะไร 4. Processing โดยวิเคราะห์ถึงวิธีการประมวลผลต่าง ๆ ซึ่งอาจเป็นการคำนวณทางคณิตศาสตร์ การเปรียบเทียบและกรรมวิธีอื่น ๆ 5. Control procedure โดยวิเคราะห์วิธีการควบคุมการทำงานของโปรแกรม 5. การออกแบบโปรแกรม (Program design) ระยะของการออกแบบโปรแกรมเป็นระยะของการวางแผนและออกแบบโดยระบุคุณลักษณะของข้อมูลเข้า (Input) ข้อมูลออก (Output) กรรมวิธีการประมวลกำหนดรายละเอียดของหน่วยเก็บข้อมูลและวิธีการควบคุมซึ่งค่าของความพยายาม (effort) ในการวิเคราะห์และออกแบบโปรแกรมขึ้นอยู่กับความซับซ้อนของงานประยุกต์และจำนวนของงานในระบบโดยปกติจะเป็นการกำหนดกฎเกณฑ์ทงตรรกะและคำสั่งที่ระบุถึงการปฏิบัติงานซึ่งเรียกว่าโมดุล (modules หรือ subdivisions) โดยแต่ละโมดุลจะมีส่วนของการกำหนดค่าเริ่มต้น (initialization) ข้อมูลเข้า (input) ประมวลผล (processing) และส่วนแสดงผล (output) และส่วนของการสิ้นสุดหรือเลิกใช้ (termination) โมดุลโปรแกรมส่วนมากมีโมดุลควบคุมใช้สำหรับตรวจสอบและควบคุมการทำงานต่าง ๆ เช่น 1. ลำดับของการประมวลผล (order of processing) 2. ขั้นตอนการทำงานซ้ำ ๆ (looping) 3. เงื่อนไขยกเว้น เช่น ข้อผิดพลาดต่าง ๆ (errors) 4. สิ่งเบี่ยงเบนจากการประมวลผลปกติ (other deviations form normal processing require) 6. การเขียนคำสั่งโปรแกรม (Program coding) การเขียนคำสั่งโปรแกรมเป็นขั้นตอนในการแปลง (convert) ตรรกะที่ได้ออกแบบในระยะการออกแบบโปรแกรมให้เป็นกลุ่มของคำสั่งโปรแกรมภาษาเพื่อสั่งให้คอมพิวเตอร์ปฏิบัติตามโปรแกรมภาษาในปัจจุบันมีมากมายหลายภาษา ซึ่งเหมาะกับงานด้านต่าง ๆ ซึ่งแต่ละภาษามีการเขียนที่แตกต่างกัน ทั้งรูปแบบ กฎเกณฑ์ต่างๆ ดังนั้นผู้เขียนควรศึกษารูปแบบและกฎเกณฑ์ต่างๆ เหล่านี้ก่อนโปรแกรมใดๆ ที่นิยมใช้ในปัจจุบัน จะประกอบด้วยคำสั่งโครงสร้างพื้นฐาน 3 อย่างคือ 1. แบบลำดับ (Sequence) 2. แบบทางเลือก (Selection) 3. แบบวนรอบ (Loop หรือ Repetition)ซึ่งเป็นส่วนสำคัญในการเขียนโปรแกรมโครงสร้างแบบบนลงล่าง (top-down structure) จะช่วยให้การเขียนโปรแกรมเป็นมาตรฐาน (standardizes) และเข้าใจได้ง่าย รวมทั้งการแก้ไขง่ายอีกด้วย Sequence Structure เป็นโครงสร้างลำดับ ซึ่งแสดงถึงลำดับของคำสั่งหรือการปฏิบัติงานกล่าวคือคำสั่งซึ่งอยู่ก่อนจะถูกปฏิบัติงานก่อนดังนั้นคำสั่งโปรแกรมซึ่งเก็บไว้ในคอมพิวเตอร์ก่อนถูกทำงานก่อน Selection Structure โครงสร้างทางเลือก หรือเรียกว่า decision หรือ IF-THEN-ELSE ก็ได้ เป็นโครงสร้างซึ่งแสดงทางเลือกของการทำงาน โดยขึ้นกับผลของเงื่อนไข โดยเงื่อนไขนี้ผลลัพธ์มี 2 ทางคือ จริง (True) และเท็จ (False) ถ้าเงื่อนไขเป็นจริงจะกระทำอย่างหนึ่ง ถ้าเงื่อนไขเป็นเท็จจะกระทำอีกอย่างหนึ่ง Repetition (Loop) Structure โครงสร้างวนรอบ หรือเรียกว่า DO-WHILE หรือ DO-UNTIL ก็ได้ เป็นโครงสร้างที่กระทำหน้าที่หรือคำสั่งซึ่งขึ้นกับเงื่อนไข โดยการทำงานจะเป็นการทำงานซ้ำ ๆ กัน ซึ่งจะหยุดการทำงานวนรอบก็ต่อเมื่อเงื่อนไขเป็นเท็จ (False)7. การตรวจสอบความถูกต้องของโปรแกรม (Program Verification) การตรวจทานโปรแกรมโดยทั่วไปเรียกว่าdebuggingซึ่งเป็นระยะหนึ่งในการเขียนโปรแกรมรวมถุงการตรวจสอบ (checking) การทดสอบ (testing) และการทำให้ถูกต้อง (correction) เหราะการเขียนคำสั่งโปรแกรมใหม่ ๆ อาจเกิดข้อผิดพลาด (bugs) ได้ง่าย 7.1 ข้อผิดพลาดในการเขียนโปรแกรม (Programming Error) ข้อผิดพลาดในการเขียนโปรแกรมสามารถแบ่งเป็น 3 ชนิดคือsyntaxerrors,logicerrors แล ะsystem design errors Syntax errors เป็นข้อผิดพลาดที่เกิดจากการเขียนคำสั่งโปรแกรมผิดรูปแบบไวยกรณ์ของภาษา Logic errors เป็นข้อผิดพลาดที่เกิดจากการใช้ตรรกะผิดในโปรแกรม ซึ่งเงื่อนไขผิดมีผลให้การกระทำตามเงื่อนไขผิดไปด้วย System design errors เป็นข้อผิดพลาดจากการออกแบบระบบทำให้ผลของการทำงานไม่เป็นที่ยอมรับของผู้ใช้ซึ่งความผิดพลาดนี้ อาจเกิดจากการสื่อสารระหว่างโปรแกรมเมอร์กับผู้วิเคราะห์ระบบหรือผู้ใช้ระบบไม่ดี Syntax errors เป็นความผิดพลาดที่ค้นพบได้ง่ายกว่า logic errors เพราะสามารถตรวจพบได้ในระหว่างการทำการแปลภาษา ส่วน logic errors จะตรวจพบเมื่อโปรแกรมทำงานจนได้ผลลัพธ์ไม่ถูกต้องเท่านั้น 7.2 การตรวจสอบ (checking) การตรวจสอบโปรแกรมต้องมีขึ้นระหว่างการออกแบบโปรแกรม,การเขียนโปรแกรม,การตรวจทานโปรแกรมเพื่อให้แน่ใจว่าสามารถแก้ปัญหาได้ตรงตามความต้องการตามวัตถุประสงค์ที่ได้ตั้งไว้เครื่องมือที่ใช้ในการออกแบบถูกต้องตามตรรกะในการประมวลผลรวมทั้งคำสั่งโปรแกรมที่เขียนขึ้นสามารถแปลได้โดยปราศจากข้อผิดพลาดต่างๆและสามารถทำงานได้อย่างถูกต้องสมบูรณ์ 7.3 Structured walkthroughs เป็นเครื่องมือของการออกแบบ,เขียนคำสั่ง,ตรวจสอบข้อผิดพลาดของการเขียนโปรแกรมที่ดีซึ่งเป็นวิธีการที่ผู้เขียนโปรแกรมแสดงผลงานให้โปรแกรมเมอร์อื่นๆตรวจสอบดูซึ่งการทำงานนี้เป็นแนวคาวมคิดของการเขียนโปรแกรมเป็นทีมงานซึ่งมีการกำหนดให้พัฒนาโปรแกรมเดียวกันภายใต้การควบคุมของหัวหน้าโปรแกรมเมอร์ (chiefprogrammer) โดยสมาชิกในทีมงานจะช่วยกันตรวจดูถึงการออกแบบและการเขียนคำสั่งเป็นช่วงๆ เป็นประจำของแต่ละโมดุล ซึ่งทำให้ค่าใช้จ่ายของการทวนสอบ (Verification) น้อยลง โดยสามารถพบข้อผิดพลาดได้ในระยะเริ่มแรกของการเขียนโปรแกรม โดยไม่ต้องคอยจนกระทั่งตรวจพบในระยะของการทดสอบโปรแกรม ซึ่งเป็นการทราบที่จะทราบว่าจุดใดที่เกิดข้อผิดพลาด ซึ่งมีผลทำให้ค่าใช้จ่ายสูงตามไปด้วย 7.4 การทดสอบ (testing) การทดสอบเป็นการตรวจสอบการทำงานของโปรแกรมโดยใช้ข้อมูลทดสอบ (testdata) เพื่อดูผลลัพธ์จากการทำงานการทดสอบที่ดีนั้นควรใช้ข้อมูลที่แตกต่างกันเพื่อให้สามารถกระทำได้ในทุกๆ เงื่อนไขในการทำงานของโปรแกรมรวมทั้งควรทดลองข้อมูลที่ไม่ถูกต้องด้วยโปรแกรมที่ดีเมื่อใส่ข้อมูลผิดๆ จะไม่เกิด error แต่จะแสดงข้อความเพื่อเตือนเท่านั้นในการเขียนโปรแกรมโครงสร้างที่ใช้โปรแกรมภาษาระดับสูงนั้นผู้ทำการทดสอบโปรแกรมสามารถแบ่งการทดสอบโปรแกรมออกเป็นส่วนๆ ซึ่งเรียกว่า โมดุล เพื่อสะดวกในการทดสอบซึ่งง่ายต่อการค้นหาข้อผิดพลาดและง่ายต่อการแก้ไขให้ถูกต้องด้วยเมื่อทดสอบโมดุลย่อยๆ เหล่านี้จนไม่มีข้อผิดพลาดจึงนำมาเป็นโปรแกรมหลักอีกครั้งหนึ่ง การทดสอบโปรแกรมกรณีที่ต้องให้โปรแกรมที่พัฒนาขึ้นมาแทนที่การประมวลผลเก่าซึ่งกำลังดำเนินอยู่การทดสอบต้องกระทำขนานกันไปกับระบบเก่าซึ่งเรารียกการประมวลผลนี้ว่า parallel processing ดังนั้นการทดสอบระบบต้องทดสอบจนกว่าจะแน่ใจว่าสามารถกระทำแทนที่ระบบเก่าได้จึงจะนำเอาการปฏิบัติงานของระบบเก่าออกไปได้ 8. เอกสารโปรแกรม (Program documentation) เป็นเอกสารซึ่งบันทึกรายละเอียดของการออกแบบการเขียนคำสั่งซึ่งมีประโยชน์ต่อการวิเคราะห์ความผิดพลาดของโปรแกรม การแก้ไขปรับปรุงโปรแกรมหรือการรวมโปรแกรมกรณีเกิดการสูญหาย โดยเฉพาะโปรแกรมเมอร์หลักที่เขียนโปรแกรมเกิดลาออกไป ดังนั้นควรเก็บรวบรวมข้อมูลต่างๆ เอาไว้9. การบำรุงรักษาโปรแกรม (Program maintenance) ขั้นตอนสุดท้ายในการเขียนโปรแกรมคอมพิวเตอร์จะเริ่มหลังจากโปรแกรมคอมพิวเตอร์ที่พัฒนาขึ้นนั้นเป็นที่ยอมรับจากผู้ใช้และได้ปฏิบัติงานมาแล้วชั่วระยะเวลาหนึ่ง ต่อมาเกิดความจำเป็นบางอย่างเกิดขึ้น เช่น ต้องการปรับปรุงระบบให้มีประสิทธิภาพดีขึ้น หรือต้องการแก้ไขหน้าที่บางอย่างหรือต้องการขยายขีดความสามารถของโปรแกรม หรืออาจเกิดจากความผิดพลาดในโปรแกรมต้องการแก้ไขให้ถูกต้อง โดยอาจมีผลมาจากนโยบายของบริษัทที่เปลี่ยนไป หรือระเบียบทางราชการบังคับ หรือการแข่งขันทางธุรกิจ ฯลฯ การเปลี่ยนแปลงอาจเกิดขึ้นได้กับทั้งฮาร์ดแวร์และซอฟต์แวร์ของระบบ การบำรุงรักษาเป็นหน้าที่หลักของการประมวลผลข่าวสารของหน่วยงานเกี่ยวของกับการวิเคราะห์ การออกแบบ การเขียนคำสั่ง การตรวจสอบ การเปลี่ยนแปลงเอกสารให้ทันสมัย ซึ่งจะมี Maintenance Programmers เป็นผู้ที่รับผิดชอบหน้าที่บำรุงรักษาโปรแกรม ซึ่งในความเป็นจริงแล้วผู้เขียนโปรแกรมกับผู้ที่บำรุงรักษาโปรแกรมจะเป็นคนละทีมงานกัน ดังนั้นจึงเป็นการยากที่ต้องแก้ไขโปรแกรมที่ไม่ได้พัฒนาขึ้นมา ดังนั้นสิ่งสำคัญของการเขียนโปรแกรมโครงสร้างจะช่วยให้การเขียนโปรแกรมเป็นมาตรฐานและทำให้ง่ายต่อการอ่านและเข้าใจ
ในภาษาปาสคาล ไฟล์คือโครงสร้างข้อมูลแบบหนึ่ง ซึ่งประกอบด้วยลำดับของข้อมูลที่มีรูปแบบตามชนิดที่กำหนดไว้ล่วงหน้าแล้ว ถูกเก็บอยู่ในหน่วยความจำภายนอก(External Storage) เช่นในฮาร์ดดิสก์ หรือแผ่นฟลอปปี้ดิสก์ เป็นต้น ความจำเป็นเกี่ยวกับไฟล์มีดังนี้
1) การเก็บข้อมูลที่เกี่ยวข้อง และจำเป็นต้องใช้กับโปรแกรมนานๆเพื่อทำให้สามารถเรียกข้อมูลเหล่านั้นกลับมาใช้ได้ใหม่ทุกครั้งที่ต้องการ โดยไม่จำเป็นต้องป้อนข้อมูลนั้นใหม่
2) ข้อมูลมีขนาดใหญ่เกินกว่าหน่วยความจำภายในของเครื่องคอมพิวเตอร์ จึงจำเป็นต้องเก็บข้อมูลบางส่วนไว้ในไฟล์ แล้วจึงเรียกใช้ข้อมูลเฉพาะตัวที่กำลังต้องการใช้งานเท่านั้น
ในเทอร์โบปาสคาล จะมองข้อมูลที่เก็บอยู่ในไฟล์ได้ 3 ลักษณะ คือ


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

ข้อมูลที่เก็บอยู่ในไฟล์ข้อความจะเป็นข้อมูลที่ถูกสร้างด้วยรหัสASCII เช่นเดียวกับชนิดข้อมูลสตริง ข้อมูลแต่ละบรรทัดในไฟล์ถือเป็นสตริง 1 ตัว โดยข้อมูลที่เก็บอยู่จริงในแต่ละบรรทัดนั้นจะมีจำนวนเท่าที่เป็นจริงแต่ต้องยาวไม่เกิน 255 ตัวอักษร (เนื่องจากตัวแปรที่นำมาใช้รับข้อมูลจากไฟล์ เป็นชนิดสตริงซึ่งเก็บข้อความได้ไม่เกิน255 ตัวอักษร) เพื่อประหยัดเนื้อที่ในการเก็บ โดยมีรหัสเพื่อบอกการสิ้นสุดของข้อมูล(Carriage Return:) ตามด้วยรหัสบอกการขึ้นบรรทัดใหม่(Line Feed:) ปิดท้ายอยู่ในแต่ละบรรทัด และมีรหัสบอกการจบไฟล์(End Of File:) ปิดท้ายไฟล์เพื่อบอกถึงการสิ้นสุดข้อมูล ลักษณะการจัดข้อมูลในไฟล์ตัวอักษร อาจแสดงได้ดังรูปที่ 2
การอ่านข้อมูลจากไฟล์ตัวอักษร เทอร์โบปาสคาลจะอ่านข้อมูลทีละบรรทัด แล้วนำมาเก็บไว้ในตัวแปรที่จองไว้ซึ่งมีชนิดเป็นสตริง โดยการอ่านข้อมูล จะต้องอ่านเรียงลำดับตั้งแต่บรรทัดแรก จนถึงบรรทัดสุดท้ายไม่สามารถอ่านข้ามบรรทัด หรือเลือกอ่านเฉพาะบรรทัดที่ต้องการข้อมูลโดยไม่ผ่านการอ่านบรรทัดที่อยู่ก่อนหน้านั้นได้
รูปที่ 2 การจัดข้อมูลแบบไฟล์ตัวอักษร

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

PROCEDURE assign(VAR filevar:Filetype, filename:string);
คำสั่งนี้เป็นการบอกให้โปรแกรมได้รู้ว่า ตัวแปรไฟล์ที่จะนำไปใช้ในโปรแกรมนั้นแท้ที่จริงแล้วตรงกับไฟล์ชื่อใดที่เก็บอยู่ในแผ่นดิสก์ เนื่องจากว่า ในดิสก์แผ่นหนึ่งๆ นั้นสามารถเก็บไฟล์ข้อมูลได้หลายไฟล์ และในโปรแกรมหนึ่งๆ สามารถติดต่อกับไฟล์ข้อมูลได้หลายๆ ไฟล์พร้อมกัน จึงต้องมีการระบุชื่อ ตำแหน่งที่เก็บข้อมูลว่าด้วยว่าอยู่ในดิสก์ไดร์ฟ (Drive) ใด ไดเรคทอรี่ (Directory) ไหนชื่อไฟล์อะไร
Filevar คือตัวแปรไฟล์ที่เราจะใช้ในโปรแกรมซึ่งเราได้จองไว้แล้วในส่วนประกาศตัวแปร โดยทั่วไปแล้ว Filevar จะทำหน้าที่เป็นตัวชี้ตำแหน่งในไฟล์ หรือที่เรียกว่าไฟล์พอยต์เตอร์ด้วย
Filename คือชื่อไฟล์จริงที่เก็บอยู่ในดิสก์ ซึ่งจะต้องเราต้องเขียนอยู่ในรูปของสตริง หรืออาจใช้ตัวแปรที่มีชนิดเป็นสตริง ในการเก็บชื่อไฟล์ก็ได้ซึ่งชื่อไฟล์นี้อาจจะประกอบด้วยส่วนของชื่อ ไดร์ฟ ชื่อไดเรคทอรี่ และส่วนชื่อไฟล์ที่เก็บด้วย

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

PROCEDURE rewrite(var filevar : Filetype);
คำสั่ง rewrite นี้ใช้ติดต่อกับในกรณีที่ต้องการสร้างไฟล์ใหม่โดยยังไม่มีไฟล์ข้อมูลอยู่ หรือกรณีที่มีไฟล์ข้อมูลอยู่แล้วแต่ต้องการยกเลิกลบทิ้งข้อมูลเดิมทั้งหมดเพื่อเขียนข้อมูลใหม่ (เปิดไฟล์ใหม่เพื่อทำการเขียน)
ผลจากการใช้คำสั่งนี้ โปรแกรมจะทำการสร้างไฟล์ใหม่ที่ยังไม่มีข้อมูลใดๆเก็บไว้ในดิสก์ ตามที่กำหนดไว้ในคำสั่ง assign
ข้อควรระวังคือ การใช้คำสั่ง rewrite กับไฟล์ที่มีอยู่แล้ว โปรแกรมจะลบข้อมูลที่มีอยู่เดิมทั้งหมด ดังนั้นจึงต้องแน่ใจว่าไม่ต้องการข้อมูลเดิมที่มีอยู่จึงจะใช้คำสั่งนี้

Procedure read(filevar, datavar:datatype);
เป็นคำสั่งที่ใช้ในการอ่านไฟล์ข้อมูล โดยทั่วไปแล้วจะใช้คำสั่งนี้เพื่ออ่านไฟล์ประเภทไฟล์กำหนดชนิด คำสั่งนี้จะทำการอ่านข้อมูลที่มีอยู่ในไฟล์ที่ถูกระบุโดยตัวแปร filevar แล้วนำไปเก็บไว้ในตัวแปร datavar
ตัวแปร datavar จะต้องมีรูปแบบของข้อมูลเป็นแบบเดียวกันกับข้อมูลที่เก็บอยู่ในไฟล์ จึงจะสามารถอ่านไฟล์ได้โดยไม่มีข้อผิดพลาด

Procedure readln(filevar, datavar:String);
เป็นคำสั่งที่ใช้ในการอ่านข้อมูลเช่นเดียวกันกับคำสั่ง Read แต่จะใช้คำสั่งนี้เฉพาะกับไฟล์ชนิดไฟล์ข้อความเท่านั้น โดยคำสั่งนี้จะอ่านไฟล์ข้อความขี้นมาครั้งละบรรทัดแล้วเก็บลงในตัวแปร datavar ซึ่งมีชนิดเป็น String

Procedure blockread(filevar,DataArray,SizeofRead,NumRead);
เป็นคำสั่งที่ใช้ในการอ่านข้อมูลจากไฟล์ประเภทไม่กำหนดชนิด โดยจะทำการอ่านข้อมูลจากไฟล์ที่ถูกชี้ด้วยตัวแปร filevar แล้วไปเก็บไว้ในตัวแปร DataArray

Procedure write(filevar,datavar:datatype);
เป็นคำสั่งที่ใช้ในการเขียนข้อมูลลงในไฟล์ โดยทั่วไปแล้วจะใช้คำสั่งนี้เขียนไฟล์ประเภทไฟล์กำหนดชนิด คำสั่งนี้จะเขียนข้อมูลที่เก็บอยู่ในตัวแปร datavar ไปเขียนลง ณ ตำแหน่งที่ตัวแปร filevar ชี้อยู่ในขณะนั้น

Procedure writeln(filevar,datavar:String);
เป็นคำสั่งที่ทำหน้าที่เขียนข้อมูลลงในไฟล์เช่นเดียวกันกับคำสั่ง writeแต่โดยปกติแล้วจะใช้คำสั่ง writeln นี้เพื่อเขียนข้อมูลประเภท Stringลงในไฟล์ข้อความเท่านั้น คำสั่ง writeln จะเขียนข้อความที่ถูกเก็บอยู่ในตัวแปร datavar ลงในไฟล์ที่ถูกชี้โดยตัวแปร filevar แล้วทำการใส่รหัสขึ้นบรรทัดใหม่ (CR/LF)

Procedure blockwrite(filevar,DataArray,SizeOfWrite,NumWrite);
คำสั่ง blockwrite นี้เป็นคำสั่งที่ใช้ในการเขียนไฟล์ประเภทไม่กำหนดชนิดโดยจะเขียนข้อมูลที่เก็บอยู่ในตัวแปร DataArray ลงในไฟล์ที่ถูกชี้ด้วยตัวแปร filevar

FUNCTION eof(VAR filevar : filetype) : boolean;
การอ่านข้อมูลจากไฟล์ โดยปกติโปรแกรมจะอ่านข้อมูลทีละชุดเรียงลำดับตั้งแต่ข้อมูลชุดแรกจนกระทั่งถึงข้อมูลชุดสุดท้าย โดยมีรหัสบอกการจบไฟล์ปรากฏอยู่ต่อท้ายไฟล์นั้น โปรแกรมสามารถตรวจสอบได้ว่าขณะนี้ข้อมูลหมดหรือยังโดยใช้ฟังก์ชัน eof ซึ่งมีรูปแบบดังนี้
ฟังก์ชัน eof(filevar) จะให้ค่ากลับมาเป็นตรรกเป็น TRUE หรือ FALSEถ้า eof(filevar) เป็น FALSE แสดงว่า ยังมีข้อมูลให้อ่านได้อยู่ ดังนั้นโปรแกรมสามารถอ่านข้อมูลที่ตำแหน่งนั้นได้ แต่ถ้า eof(filevar) เป็นTRUE นั้นหมายถึงข้อมูลหมดแล้ว ไม่สามารถอ่านข้อมูลได้อีก การพยายามอ่านข้อมูลที่ตำแหน่งนี้จะทำให้เกิดความผิดพลาด ขึ้นได้
ส่วนในกรณีที่ต้องการเขียนข้อมูลลงในไฟล์ เราสามารถเขียนข้อมูลลงไนไฟล์ได้ทันทีโดยไม่ต้องตรวจสอบตำแหน่งการจบไฟล์ ซึ่งตำแหน่งการจบไฟล์จะเปลี่ยนไปโดยอัตโนมัติทุกครั้งที่มีการเขียนข้อมูลเพิ่มเติม

PROCEDURE close(VAR filevar : Filetype);
เป็นคำสั่งที่ใช้ในการบอกยกเลิกการใช้งานใดๆ ที่เกี่ยวข้องกับไฟล์นั้นโดย หรืออาจเรียกง่ายๆ ว่าเป็นการปิดไฟล์ก็ได้
ในการทำงานเกี่ยวกับไฟล์ ผู้ใช้สามารถเปิดไฟล์เพื่อใช้งานได้ทีละหลายไฟล์พร้อมกันได้ โดย กำหนดตัวแปรไฟล์หลายๆ ตัวเท่ากับจำนวนไฟล์ที่ต้องการเปิด แล้วกำหนดชื่อไฟล์ให้กับตัว
ไฟล์กำหนดชนิดก็คือไฟล์ที่เก็บข้อมูลตามชนิดของข้อมูลในภาษาปาสคาล (Type) ซึ่งจะมีรูปแบบการกำหนดตัวแปรไฟล์ดังนี้
<> : File of <>
กำหนดให้
เป็นตัวแปรไฟล์ (Identifier)เป็นชนิดของข้อมูล เช่น Integer, Real เป็นต้น
ตัวอย่างเช่น
filept1 : File of Integer;
กำหนดให้ตัวแปร filept1 เป็นตัวแปรไฟล์ซึ่งเก็บข้อมูลชนิด Integer
filept2 : File of Real;
กำหนดให้ตัวแปร filept2 เป็นตัวแปรไฟล์ซึ่งเก็บข้อมูลชนิด Real
โดยทั่วไปแล้วไฟล์กำหนดชนิดมักจะมีชนิดของข้อมูลเป็นแบบเรคอร์ดดังนั้นในการใช้งานไฟล์กำหนดชนิดนี้จึงจำเป็นจะต้องทำการกำหนดชนิดของข้อมูลแบบเรคอร์ดขึ้นมาใหม่ ดังตัวอย่าง เช่น ถ้าต้องการเก็บข้อมูลของนักศึกษาห้องหนึ่งที่ลงทะเบียนเรียนวิชาแคลคูลัส ซึ่งนักศึกษาแต่ละคนจะมีข้อมูลประจำตัวดังนี้
· รหัสประจำตัวนักศึกษา
· ชื่อและนามสกุลนักศึกษา
· ปีการศึกษาที่เริ่มเข้าศึกษา
· คะแนนสอบ
การกำหนดชนิดข้อมูลแบบเรคอร์ด ตัวแปรที่ใช้เก็บข้อมูล และตัวแปรไฟล์สำหรับข้อมูลข้างต้นจะเป็นดังต่อไปนี้
TYPE
{กำหนดชนิดข้อมูลแบบเรคอร์ด}Student_Record = RECORDId : String[8];Name : String[35];StartingYear : Integer;Score : Real;END;{สิ้นสุดการกำหนดข้อมูลแบบเรคอร์ด}
VAR
{กำหนดตัวแปรไฟล์กำหนดชนิดของ Student_Record}StFile : File of Student_Record;{กำหนดตัวแปรที่มีชนิดเป็น Student_Record}St : Student_Record;
โปรแกรมที่ 10.1PROGRAM WriteStudent;CONST
MaxStudent = 100;
TYPE
{กำหนดชนิดข้อมูลแบบเรคอร์ด}Student_Record = RECORDId : String[8];Name : String[35];StartingYear : Integer;Score : Real;END;{สิ้นสุดการกำหนดข้อมูลแบบเรคอร์ด}St_Array : Array [1..MaxStudent] of Student_Recored;
VAR
{กำหนดตัวแปรที่มีชนิดเป็น Student_Record}Student : St_Array;St_Count : Integer;filename : String[15];again : Char;
PROCEDURE WriteStudentToFile (St:St_Array; Count:Integer;fname:String);VAR
{กำหนดตัวแปรไฟล์กำหนดชนิดของ Student_Record}St_File : File of Student_Record;I : Integer;
BEGIN
assign(St_File,fname);rewrite(St_File);FOR I := 1 TO Count DOwrite(St_File,St[I]);Close(St_File);
END;
BEGIN
{รับชื่อไฟล์จากผู้ใช้}write(‘New file name: ‘);readln(filename);again := ‘Y’;St_Count := 0; {กำหนดจำนวนข้อมูลเริ่มต้นเท่ากับ 0}{เริ่มต้นวนรอบรับข้อมูลนักศึกษาแต่ละคน}WHILE again in [‘Y’, ’y’] DOBEGIN
St_Count := St_Count+1;write(‘ID: ‘);readln(Student[St_Count].Id);write(‘Name: ‘);readln(Student[St_Count].Name);writeln(‘Starting Year: ‘);readln(Student[St_Count].StartingYear);writeln(‘Score: ‘);readln(Student[St_Count].Score);REPEAT
writeln(‘Next Student (Y/N): ‘);readln(again);
UNTIL again in [‘Y’, ‘y’, ‘N’, ‘n’];
END;{เขียนข้อมูลที่รับได้ทั้งหมดเก็บลงในไฟล์}WriteStudentToFile(Student,St_Count,filename);
END.
สำหรับโปรแกรมที่ 10.1 นี้เป็นตัวอย่างการเขียนโปรแกรมเพื่อเปิดไฟล์ประเภทกำหนดชนิดเพื่อทำการเขียนข้อมูลลงในไฟล์ ขั้นตอนการทำงานของโปรแกรมสามารถอธิบายเป็นขั้นตอนได้ดังต่อไปนี้
1. รับชื่อไฟล์ที่ต้องการบันทึกข้อมูลจากผู้ใช้
2. วนรอบรับข้อมูลนักศึกษาทีละคนมาเก็บไว้ในตัวแปรอาร์เรย์ ที่ชื่อ Student
3. เรียก Procedure WriteStudentToFile ซึ่ง Procedure นี้จะทำการเปิดไฟล์ตามชื่อที่กำหนดไว้จากข้อ 1 แล้วทำการเขียนข้อมูลลงไป
4. จบโปรแกรม
สำหรับ Procedure WriteStudentToFile นี้สามารถเขียนเป็น Flowchartการทำงานได้ดังผังงานที่ 10.1
ผังงานที่ 10.1
โปรแกรมที่ 10.2PROGRAM ReadStudent;CONST
MaxStudent = 100;
TYPE
{กำหนดชนิดข้อมูลแบบเรคอร์ด}Student_Record = RECORDId : String[8];Name : String[35];StartingYear : Integer;Score : Real;END;{สิ้นสุดการกำหนดข้อมูลแบบเรคอร์ด}St_Array : Array [1..MaxStudent] of Student_Recored;
VAR
{กำหนดตัวแปรที่มีชนิดเป็น Student_Record}Student : St_Array;filename : String[15];St_Count : Integer;i, j : Integer;
Procedure ReadStudentFromFile (VAR St:St_Array;VAR
Count : Integer;fname : String);
VAR
{กำหนดตัวแปรไฟล์กำหนดชนิดของ Student_Record}StFile : File of Student_Record;
BEGIN
assign(St_File,fname);reset(St_File);Count := 0;WHILE NOT(eof(St_File)) DOBEGIN
Count := Count+1;Read(St_file,Student[Count]);
END;close(St_File);
END;
BEGIN
{รับชื่อไฟล์จากผู้ใช้}write(‘New file name: ‘);readln(filename);ReadStudentFromFile(Student,St_Count,filename);{พิมพ์ข้อมูลขึ้นบนหน้าจอครั้งละ 24 บรรทัด}FOR i := 1 TO (St_Count div 24) DOBEGIN
FOR j := 1 to 24 DO WITH Student[j] DO
writeln(Id,’ ‘,Name,’ ‘,StartingYear,’ ‘,Score);
writeln(‘Press any key to continue’);REPEAT UNTIL KEYPRESSED;
END;IF (St_Count mod 24) > 0 THEN
FOR i := 1 TO (St_Count mod 24) DO
writeln(Id,’ ‘,Name,’ ‘,StartingYear,’ ‘,Score);
END.
โปรแกรมที่ 10.2 นี้แสดงถึงการเปิดไฟล์ประเภทกำหนดชนิดเพื่อทำการอ่านข้อมูล โดยโปรแกรมจะทำการอ่านข้อมูลจากไฟล์ที่ถูกสร้างขึ้นจากโปรแกรมที่ 10.1 ไปเก็บไว้ในตัวแปรอาร์เรย์ หลังจากนั้นจึงทำการนำขึ้นแสดงบนหน้าจอครั้งละ 24 บรรทัด จนครบนักศึกษาทุกคน
ในความเป็นจริงแล้วสำหรับโปรแกรมที่ 10.2 นี้อาจไม่จำเป็นที่จะต้องอ่านข้อมูลขึ้นมาไว้ในตัวแปรอาร์เรย์จนกระทั่งครบทุกตัวก่อนที่จะแสดงข้อมูลทีละบรรทัดขึ้นจอภาพ เราอาจเขียนโปรแกรมนี้โดยทำการวนรอบอ่านข้อมูลจากไฟล์ที่ละชุดแล้วแสดงผลบนจอภาพทันที โดยไม่ต้องเก็บไว้ในตัวแปรอาร์เรย์ก่อน
สำหรับขั้นตอนการทำงานของ PROCEDURE ReadStudentFromFileสามารถแสดงเป็นผังงานได้ดังต่อไปนี้
ผังงานที่ 10.2
ต่อไปนี้เป็น Function และ Procedure เพิ่มเติมที่ใช้สำหรับไฟล์กำหนดชนิด

FUNCTION filepos(VAR filevar:FileType):Longint;
เป็นฟังก์ชันที่ให้ค่าตำแหน่งปัจจุบันของไฟล์พอย์เตอร์ เช่นจากตัวอย่างที่ผ่านมาถ้าเราเรียกข้อมูลของนักศึกษาแต่ละคนเป็น 1 เรคอร์ด ฟังก์ชัน Filepos จะให้ผลลัพท์เป็นหมายเลขเรคอร์ดปัจจุบันของไฟล์พอยต์เตอร์

FUNCTION filesize(filevar:Typefile):Longint;
เราสามารถหาจำนวนเรคอร์ดทั้งหมดที่เก็บอยู่ในไฟล์ได้โดยใช้ฟังก์ชัน Filesizeโดยกำหนดให้ตำแหน่งแรกของไฟล์คือตำแหน่งที่ 0 ดังนั้นผลลัพท์ของฟังก์ชันนี้จะเท่ากับ n-1 เมื่อ n คือจำนวนเรคอร์ดทั้งหมดที่เก็บอยู่ในไฟล์

PROCEDURE seek(VAR filevar:Typefile; index:Longint);
เป็นการเลื่อนตำแหน่งของไฟล์พอยต์เตอร์ไปยังตำแหน่งเรคอร์ดที่ต้องการโดยไม่ต้องการให้โปรแกรมอ่านข้อมูลในตำแหน่งที่ไม่จำเป็น เช่นถ้าต้องการข้อมูลในตำแหน่งที่ 20 ของไฟล์ข้อมูล (จะเท่ากับเรคอร์ดหมายเลข 19 ของไฟล์ เพราะเริ่มต้นนับเรคอร์ดแรกเป็นหมายเลข 0) ดังนั้นสามารถเขียนเป็นคำสั่งได้เป็นseek(stfile,19);
จากคำสั่งที่เพิ่มเติมขึ้นมานี้ทำให้เราพบว่า ถ้าหากต้องการเขียนโปรแกรมย่อยเพื่อที่จะเพิ่มข้อมูลเข้าไปที่ท้ายไฟล์ครั้งละ 1 ชุดได้ดังโปรแกรมย่อยต่อไปนี้
Procedure ADD_Student_File(X : ST_REC; filename : string);VAR ST_FILE : ST_REC_FILE;BEGIN
assign(St_File,filename);reset(St_file);seek(St_file,filesize(St_file));write(St_file,Student[i]);close(St_File);
END;
การจัดข้อมูลแบบไฟล์ข้อความ สามารถทำได้ดังขั้นตอนต่อไปนี้
การประกาศโครงสร้างข้อมูลและจองตัวแปร ในกรณีที่ต้องการจัดโครงสร้างข้อมูลแบบไฟล์ข้อความ ต้องกำหนดชนิดของข้อมูลในไฟล์ คือTEXT (เป็นชนิดข้อมูลที่มีอยู่แล้วไม่จำเป็นต้องประกาศใหม่) ดังนั้น เราจึงกำหนดชนิดตัวแปรที่จะใช้งานเป็น TEXT และกำหนดชนิดของตัวแปรข้อมูลที่อ่านได้จากไฟล์เป็น STRING เช่น
VAR
datafile : text;
{ตัวแปรไฟล์ที่จะใช้งาน}
data : string;
{ตัวแปรข้อมูลที่อ่านได้จากไฟล์}
filename : string;
{ตัวแปรที่ใช้ในการเก็บชื่อไฟล์}
การกำหนดชื่อไฟล์ข้อมูลที่อยู่ในจานข้อมูลแม่เหล็ก ให้ใช้คำสั่ง
assign(datafile,filename)
การเปิดไฟล์เพื่อใช้งาน ใช้คำสั่งดังนี้
เปิดเพื่ออ่านข้อมูลจากไฟล์
reset(datafile);
เปิดไฟล์เพื่อบันทึกข้อมูล
rewrite(datafile);
เปิดไฟล์เพื่อพิมพ์ข้อมูลเพิ่ม
append(datafile);
การอ่านหรือเขียนข้อมูล ข้อมูลที่เก็บอยู่ในไฟล์ข้อความ จะเก็บเป็นข้อมูลชนิดสตริง ในลักษณะเป็นบรรทัดของสตริง ซึ่งความยาวของแต่ละบรรทัดจะไม่เท่ากัน ดังนั้นโปรแกรมจะไม่สามารถคำนวณหาจำนวนบรรทัด หรือ ตำแหน่งที่อยู่ของบรรทัดที่เราต้องการได้ การอ่านจะต้องอ่านข้อมูลทีละบรรทัดไปเรื่อยๆ จนกระทั่งถึง ตำแหน่งข้อมูลที่เราต้องการ หรือจนกระทั่งพบรหัสบอกการจบไฟล์จะต้องเลิกอ่านข้อมูลต่อเพราะข้อมูลหมดแล้ว ดังนั้นถ้าต้องการวนอ่านข้อมูลจากไฟล์ไปใช้งานจะทำได้ดังนี้
linecount := 0;
{ตั้งค่าตัวนับเป็นศูนย์}
WHILE NOT eof(filevar) DO
{วนรอบเช็คว่ายังมีข้อมูลให้อ่านได้}
BEGIN

linecount := linecount + 1;
{เพิ่มค่าตัวนับทีละหนึ่ง}
readln(filevar,Data);
{อ่านข้อมูลจากไฟล์}
..............................;
{นำข้อมูลที่อ่านได้ไปใช้งาน}
..............................;

END;

กรณีเขียนข้อมูลจากตัวแปรไปเก็บไว้ในไฟล์ให้ใช้คำสั่ง
writeln(filevar,Data);
ถ้าต้องการเขียนข้อความที่อยู่ในตัวแปร data[] ตั้งแต่ตัวที่ 1 ถึง n เพิ่มเติมลงในไฟล์ที่มีอยู่แล้ว อาจเขียนโปรแกรมได้ดังนี้
assign(filevar,filename);append(filevar);FOR i := 1 TO n DO
writeln(filevar,data[i]);
close(filevar);
การปิดไฟล์ เลิกใช้งาน ให้ใช้คำสั่ง
close(filevar);
ตัวอย่างโปรแกรมที่ 10.3 จงเขียนโปรแกรมเพื่ออ่าน ไฟล์ที่เก็บอยู่ในไดร์ฟ A ชื่อ 'REPORT.TXT' ซึ่งมีรูปแบบข้อมูลเป็นไฟล์ข้อความ แล้วทำการแปลงข้อมูลที่อ่านได้เฉพาะที่เป็นตัวอักษรภาษาอังกฤษตัวเล็ก('a'..'z') เป็นตัวอักษรตัวใหญ่ ('A'..'Z') แล้วสั่งพิมพ์ข้อมูลนั้นออกทางเครื่องพิมพ์
จากข้อกำหนดของโปรแกรม เราสามารถเขียนเป็นผังงานได้ ดังผังงานที่ 10.3
ผังงานที่ 10.3
จากผังงานที่ 10.3 เราสามารถเขียนโปรแกรมได้ ดังโปรแกรมที่ 10.4
โปรแกรมที่ 10.4 Print_TEXT_File_to_UpperCasePROGRAM Print_TEXT_File_to_UpperCase;VAR
filevar : text; i : integer;
BEGIN
assign(filevar,'A:\REPORT.TXT');reset(filevar);WHILE NOT eof(filevar) DOBEGIN
readln(filevar,data);FOR i := 1 TO LENGTH(data) DO
data[i] := upcase(data[i]);
writeln(LST,data);
END;close(filevar);
END.
ตัวอย่างโปรแกรมที่ 10.4 จงเขียนโปรแกรมเพื่ออ่านไฟล์ที่เก็บอยู่ในไดร์ฟ A ชื่อ 'UPPER.TXT' ซึ่งมีรูปแบบข้อมูลเป็นชนิดไฟล์ข้อความแล้วทำการแปลงข้อมูลที่อ่านได้เฉพาะที่เป็นตัวอักษรภาษาอังกฤษที่เป็นตัวใหญ่ ('A'..'Z') ไปเป็นตัวอักษรตัวเล็ก ('a'..'z') แล้วเก็บข้อมูลนั้นไว้ในไฟล์ชื่อ 'LOWER.TXT' จากโจทย์ เราสามารถเขียนผังงานได้ดังผังงานที่ 10.4
ผังงานที่ 10.4
จากผังงานที่ 10.4 เราสามารถเขียนเป็นโปรแกรมภาษาปาสคาลได้ดังโปรแกรมที่ 10.5
โปรแกรมที่ 10.5 Program Convert_Text_File_to_Lower_Case;PROGRAM Convert_Text_File_to_Lower_Case;VAR
file1,file2 : text;i : integer;
BEGIN
assign(file1,'A:\UPPER.TXT');assign(file2,'A:\LOWER.TXT');reset(file1);rewrite(file2);WHILE NOT eof(file1) DOBEGIN
readln(file1,data);FOR i := 1 TO length(data) DOIF data[i] in ['A'..'Z'] THENdata[i] := chr(ord(data[i])+32);writeln(file2,data);
END;close(file1);close(file2);
END.
ตัวอย่างโปรแกรมที่ 10.5 จากข้อกำหนดและตัวอย่างโปรแกรมที่ 9.1จงเขียนโปรแกรมย่อยเพื่อทำการแปลงข้อมูลที่อยู่ในอาเรย์ของตัวแปรStudent ให้เป็นข้อมูลแบบไฟล์ข้อความ โดยกำหนดให้คั่นข้อมูลแต่ละฟิล์ดด้วยเครื่องหมาย ","
จากโจทย์ เราสามารถเขียนเป็นผังงานได้ ดังผังงานที่ 10.5 และสามารถเขียนเป็นโปรแกรมภาษาปาสคาลได้ ดังโปรแกรมที่ 10.6
โปรแกรมที่ 10.6 Procedure Write_to_SDFPROCEDURE Write_to_SDF(var Student : St_Array; ST_Count : integer;
SDF_Name : string);
VAR
SDF_File : text;i : integer;
BEGIN
assign(SDF_File,SDF_Name);rewrite(SDF_File);FOR i := 1 TO ST_Count DOBEGIN
WITH Student[i] DOwriteln(Id,',',Name,',',Score,',',Grade);
END;close(SDF_File);
END;
ผังงานที่ 10.5
ตัวอย่างโปรแกรมที่ 10.6 แฟ้มข้อมูลไฟล์หนึ่งมีลักษณะข้อมูลเป็นไฟล์ข้อความ ซึ่งมีรูปแบบการเก็บข้อมูลบรรทัดละ 1 เรคอร์ด โดยใช้เครื่องหมาย "," ขั้นระหว่างฟิลด์ โดยมีโครงสร้างการเก็บข้อมูลในแต่ละบรรทัดดังนี้
รหัสประจำตัว,ชื่อ-สกุล,คะแนน,เกรด
จงเขียนโปรแกรมย่อย เพื่อดึงข้อมูลดังกล่าวเข้ามาเก็บไว้ในอาเรย์ของตัวแปร Student
จากโจทย์สามารถเขียนเป็นผังงานได้ดังผังงานที่ 10.6
ผังงานที่ 10.6
จากผังงานที่ 10.6 ในส่วนของโปรแกรมย่อยในการถอดรหัสข้อมูลเราสามารถเขียนผังงาน ได้ดังผังงานที่ 10.7
ผังงานที่ 10.7
โปรแกรมที่ 10.7PROCEDURE Deletespace(VAR buff:string);VAR
i : integer;
BEGIN
WHILE buff[1] = ' ' DO delete(buff,1,1);
END;
FUNCTION Get_Field(VAR buff : string) : string;VAR
compos : INTEGER;
BEGIN
deletespace(buff);compos := pos(',',buff);Get_Field := copy(buff,1,compos-1);delete(buff,1,compos);
END;
ในส่วนของผังงานที่ 10.6 สามารถเขียนเป็นโปรแกรมภาษาปาสคาลได้ดังโปรแกรมที่ 10.8
โปรแกรมที่ 10.8 Procedure Read_FROM_SDFPROCEDURE Read_From_SDF(VAR Student : St_Array; VAR St_Count :
integer; SDF_Name : string);
VAR
SDF_File : text;buff : string;i,err : integer;score : real;
BEGIN
assign(SDF_File,SDF_Name);reset(SDF_File);ST_Count := 0;WHILE NOT eof(SDF_File) DOBEGIN
Readln(SDF_File,buff);IF buff <> '' THENBEGIN
St_Ccount := ST_Count + 1;Student[ST_Count].Id := Get_Field(Buff);Student[ST_Count].Name := Get_Field(buff);val(Get_Field(buff),score,err);Student[St_Count].Score := score;Student[St_Count].Grade := buff[1];
END;
END;close(SDF_File);
END;

ในการอ่านข้อมูลจากไฟล์ข้อความตามที่ได้กล่าวมาแล้วนั้น เราจะอ่านข้อมูลจาก ไฟล์ข้อความนั้นทีละ 1 บรรทัด แล้วจึงนำมาตีความหมายของข้อมูลนั้นๆ ว่าควรประกอบด้วยข้อมูลย่อยๆ แต่ละตัวเป็นอะไรมีชนิดเป็นข้อมูลแบบใด ยังมีกรณีพิเศษอีกกรณีหนึ่ง สำหรับในภาษาปาสคาลกล่าวคือ ถ้าข้อมูลที่อยู่ในไฟล์ข้อความนั้น เป็นข้อมูลของตัวเลขเพียงอย่างเดียว เช่น '0'..'9','+','-','.' ฯลฯ การอ่านแบบเดิมจะได้ข้อมูลเป็นสตริง ซึ่งผู้ใช้จะต้องนำข้อความนั้นมาวิเคราะห์แล้วแปลงเป็นตัวเลขที่ต้องการ แต่ถ้าผู้ใช้แน่ใจว่าข้อมูลใน ไฟล์ข้อความนั้นเป็นข้อความของตัวเลขล้วนๆแล้ว ผู้ใช้สามารถใช้คำสั่ง Read(filevar,N) กับ ไฟล์ข้อความนั้นได้ทันที โดยที่ N เป็นตัวแปร ชนิด จำนวนจริง หรือ จำนวนเต็มก็ได้(ต้องจองตัวแปรให้สอดคล้องกับข้อมูลที่อ่านได้จากไฟล์ข้อความนั้น)ปาสคาลสามารถจะอ่านหรือค้นหาข้อมูลตัวเลขชุดแรกที่พบเห็นเข้ามาในตัวแปร N ได้ทันที (ในกรณีที่มีข้อมูลหลายๆตัวอยู่ในไฟล์ข้อความนั้นโปรแกรมจะใช้เครื่องหมายช่องว่าง ' ' หรือ การขึ้นบรรทัดใหม่เป็นตัวคั่นระหว่างข้อมูลแต่ละชุด) และถ้าเราอ่านซ้ำข้อมูลไปเรื่อยๆ ก็จะได้ตัวแปรชุดถัดไปทีละชุดจนหมด โดยผู้ใช้ไม่ต้องสนใจการจัดรูปแบบตัวเลขที่อยู่ในไฟล์นั้นเลย เช่น
การอ่านข้อมูลจากไฟล์ข้อความนี้ จะอ่านได้เป็น 5,8,16,14,6,9,7,12,11,4,1 ตามลำดับ
ข้อควรระวัง ในการอ่านข้อมูลแบบนี้ ผู้ใช้จำเป็นต้องรู้จำนวนข้อมูลที่จะถูกอ่านด้วยเพื่อป้องกันข้อผิดพลาดจากการอ่านในตำแหน่งสิ้นสุดไฟล์เนื่องจากข้อมูลตัวเลขนั้นอาจหมดก่อนที่จะปิดไฟล์(จากตัวอย่างข้อมูลมีตัวเลข 11 ตัว ตัวเลขสุดท้ายคือเลข 1 แต่ยังมีบรรทัดว่างๆ อีก 2 บรรทัดดังนั้นเมื่ออ่านข้อมูลเลข 1 ไปแล้ว โปรแกรมจะถือว่ายังไม่จบ file เนื่องจากยังมีบรรทัดว่างๆอยู่ แต่ถ้าผู้ใช้อ่านตัวเลขซ้ำอีก โปรแกรมก็จะพยายามหาตัวเลขถัดไปที่อยู่หลังจากเลข 1 ซึ่งจะไม่มีเนื่องจากข้อมูลหมดแล้วดังนั้นจึงเกิดข้อผิดพลาดจากกรณีนี้ได้
ตัวอย่างโปรแกรมที่ 10.7 ไฟล์ที่เก็บข้อมูลเมตริกซ์(MATRIX) ประกอบด้วยตัวเลขล้วนๆ ในรหัสแอสกี ดังมีรูปแบบการจัดเก็บดังนี้
ตัวเลขตัวแรกที่อ่านได้คือ จำนวนแถวนอนของเมตริกซ์นั้นตัวเลขตัวที่สองที่อ่านได้คือ จำนวนแถวหลักของเมตริกซ์นั้นตัวเลขตัวถัดๆมา คือข้อมูลในแต่ละอิลิเมนต์ ของเมตริกซ์นั้น
จงเขียนโปรแกรมเพื่ออ่านไฟล์ข้อมูลที่เก็บอยู่ในไดรฟ์ A ซึ่งประกอบด้วยไฟล์ข้อความของเมตริกซ์ A ชื่อ 'MA.TXT' และของเมตริกซ์ B 'MB.TXT'แล้วอ่านข้อมูลจากเมตริกซ์ทั้งสองนำมาคูณกัน หลังจากนั้นให้สร้างไฟล์ใหม่ชื่อ 'MC.TXT' ซี่งได้จาก [MA]*[MB] และมีรูปแบบการจัดเก็บข้อมูลเช่นเดียวกับเมตริกซ์ MA
จากโจทย์ เราสามารถนำมาเขียนผังงานหลักได้ ดังผังงานที่ 10.8
ผังงานที่ 10.8
จากผังงานที่ 10.8 ในส่วนของผังงานย่อยการอ่านข้อมูลจากเมตริกซ์ Aและ B สามารถเขียนเป็นผังงานได้ ดังผังงานที่ 10.9
ผังงานที่ 10.9
จากผังงานที่ 10.8 ในส่วนของผังงานสำหรับเขียนข้อมูลลงในเมตริกซ์ Cสามารถเขียนเป็นผังงานได้ ดังผังงานที่ 10.10
ผังงานที่ 10.10
จากผังงาน 10.8-10.10 ที่ได้ทั้งหมด เราสามารถนำมาเขียนโปรแกรมภาษาปาสคาลทั้งหมดได้ดังโปรแกรมที่ 10.9
โปรแกรมที่ 10.9 PROGRAM TEST_NUMBER_TEXT_FILE;PROGRAM TEST_NUMBER_TEXT_FILE;USES DOS;CONST
Maxrow = 20;maxcol = 20;
TYPE
Matrix = ARRAY [1..Maxrow,1..Maxcol] of real;
VAR
Ma,Mb,Mc : Matrix;m,n,o,p,q,r : integer;Success : boolean;
PROCEDURE Read_Matrix_File(VAR M : Matrix; VAR row,col : integer;
filename : string);
VAR
datafile : text; i,j : integer;
BEGIN
assign(datafile,filename);reset(datafile);Read(datafile,row);Read(datafile,col);FOR i := 1 TO row DO
FOR j := 1 TO col DO
read(datafile,M[i,j]);
close(datafile);
END;
PROCEDURE Write_Matrix_File(M : Matrix; row,col : integer;
filename : string);
VAR
datafile : text;i,j : integer;
BEGIN
assign(datafile,filename);rewrite(datafile);writeln(datafile,row);writeln(datafile,col);For i := 1 TO row DOBEGIN
FOR j := 1 TO col DO
write(datafile,M[i,j]:10:4,' ');
writeln(datafile);
END;close(datafile);
END;
PROCEDURE Multiply_Matrix (Ma : Matrix; m,n : integer;
Mb : Matrix; o,p : integer; VAR Mc : Matrix;VAR q,r : integer; VAR Success : boolean);
VAR
i,j,k : integer;
BEGIN
IF n = o THENBEGIN
Success := TRUE;q := m;r := p;FOR i := 1 TO m DOFOR j := 1 TO p DOBEGIN
Mc[i,j] := 0;FOR k := 1 TO m DOMc[i,j] := Mc[i,j] + Ma[i,k] * Mb[k,j];
END;
END ELSESuccess := FALSE;
END;
BEGIN {Main Program}
Read_Matrix_File(Ma,m,n,'A:\MA.TXT');Read_Matrix_File(Mb,m,n,'A:\MB.TXT');Multiply_Matrix(Ma,m,n,Mb,o,p,Mc,q,r,Success);IF Success THEN
Write_Matrix_File(MC,q,r,'A:\MC.TXT')
ELSE
Writeln('ERROR CANNOT MULTIPLY MATRIX');
END.
การจัดการกับไฟล์ไม่กำหนดชนิด มีขั้นตอนการทำงานดังต่อไปนี้
การประกาศโครงสร้างข้อมูลและจองตัวแปร ในกรณีของการทำงานเกี่ยวกับไฟล์ไม่กำหนดชนิด เนื่องจากโปรแกรมยังไม่ทราบลักษณะโครงสร้างของข้อมูลที่อ่านมาได้ ดังนั้น การจองตัวแปร ปาสคาลให้กำหนดชนิดตัวแปรไฟล์ ให้เป็น FILES และกำหนดชนิดของข้อมูลที่อ่านได้เป็นByte หรือ Char ก็ได้ และในการอ่านข้อมูล เราสามารถอ่านข้อมูลเข้ามาทีละเป็นจำนวนมากก็ได้ (ไม่จำเป็นต้องอ่านทีละตัว) ดังนั้นจึงกำหนดชนิดของตัวแปรที่ใช้เก็บข้อมูลที่อ่านได้เป็น ARRAY [1..Max] of Byte;หรือ ARRAY[1..Max] of char; ข้อมูลที่อ่านได้ก็จะเป็น กลุ่มของตัวอักษรหรือ กลุ่มของตัวเลข ตามที่เราจองไว้ เช่น
CONST




Maxbuff
=
10000;
VAR




Datafile
:
FILE;

Data
:
ARRAY[1...Maxbuff] OF byte;
ขนาดของอาร์เรย์ที่ต้องจองไว้สำหรับเก็บข้อมูลที่อ่านได้ ขึ้นอยู่กับความต้องการในการใช้งานและขนาดของไฟล์ที่จะอ่านเข้ามา เช่นจองอาร์เรย์ขนาด 1...10000 นั้นหมายความว่า เราจองเนื้อที่ในการเก็บข้อมูลที่อ่านได้ไม่เกิน 10,000 ไบท์ ซึ่งถ้าไฟล์ที่ต้องการอ่านมีขนาดเล็กกว่า10,000 ไบท์ เราอาจจะอ่านข้อมูลทั้งหมดมาไว้ในตัวแปรของเรา แต่ถ้าไฟล์ข้อมูลที่ต้องการอ่านมีขนาดใหญ่กว่า 10,000 ไบท์ จะต้องทยอยอ่านมาใช้งานทีละส่วน โดยที่แต่ละส่วนต้องมีขนาดไม่เกิน 10,000ไบท์ เป็นต้น ในการจองตัวแปร อาร์เรย์นี้ ผู้ใช้สามารถจองได้ไม่เกิน64 กิโลไบท์ (ปาสคาลยอมให้ใช้ตัวแปรทั้งหมดรวมกันในแต่ละโปรแกรมมีขนาดรวมกันไม่เกิน 64 กิโลไบท์)
การกำหนดไฟล์ข้อมูลที่อยู่ใน DISK ใช้คำสั่งดังนี้
assign(filevar,filename)
การเปิดไฟล์เพื่อใช้งาน ใช้คำสั่งดังนี้
reset(filevar,reoord_size);rewrite(filevar,record_size);
ในการเปิดไฟล์ชนิดที่เป็นไฟล์ไม่กำหนดชนิดในเทอร์โบปาสคาล จะต้องบอกขนาดของเรคอร์ด ที่อ่านจะอ่านหรือเขียนด้วย ซึ่งในกรณีของข้อมูลชนิดไบท์ หรือ อักขระ ขนาดของข้อมูล 1 ตัว จะมีขนาด 1 ไบท์เท่ากันดังนั้นเราจึงกำหนดขนาดของ Record_Size เป็น 1 จะได้ว่า
reset(filevar,1);rewrite(filevar,1);
การอ่านและเขียนข้อมูล
กรณีอ่านข้อมูลเข้ามาเก็บไว้ใน อาร์เรย์ ใช้คำสั่ง blockreadซึ่งมีรูปแบบ ดังนี้
PROCEDURE blockread(VAR filevar : file; VAR Byte_Array : Array_Of_Byte;
SizeofRead : word; VAR NumRead : word);
คำสั่ง blockread เป็นการสั่งให้โปรแกรมอ่านข้อมูลจากไฟล์ เข้าไปเก็บไว้ในตัวแปร Byte_Array จำนวนที่สั่งให้อ่านครั้งละเท่ากับ SizeofReadตัว และคำสั่งนี้จะส่งค่าตัวแปล NumRead กลับมาเป็นจำนวนที่โปรแกรมอ่านได้จริงเท่ากับ NumRead ตัว
จำนวนข้อมูลที่กำหนดให้อ่านกับที่อ่านได้จริงอาจจะไม่เท่ากันก็ได้ เช่นกรณีที่มีข้อมูลเหลืออยู่ในไฟล์น้อยกว่าจำนวนข้อมูลที่เราสั่งให้อ่านโปรแกรมก็จะอ่านข้อมูลได้เท่าที่มีอยู่จริง ฯลฯ ดังนั้นจึงต้องมีการส่งตัวแปลกลับมาบอกให้โปรแกรมได้ทราบเพื่อให้โปรแกรมรู้จำนวนข้อมูลที่มีอยู่จริง
กรณี เขียนข้อมูลจากอาร์เรย์ลงมาเก็บในไฟล์ ใช้คำสั่ง blockwriteซึ่งมีรูปแบบดังนี้
PROCEDURE blockwrite(VAR filevar : FILE; VAR Byte_Array : Array_Of_Byte;
SizeofWrite : word; VAR NumWrite : word);
คำสั่ง blockwrite เป็นการสั่งให้โปรแกรมเขียนข้อมูลที่เก็บอยู่ใน Byte_Arrayตั้งแต่ตัวแรกลงไปเก็บไว้ในไฟล์ จำนวนเท่ากับ SizeofWrite ตัว และคำสั่งนี้จะส่งค่าตัวแปล NumWrite กลับมาเป็นจำนวนข้อมูลที่เขียนลงไปได้จริง
จำนวนข้อมูลที่กำหนดให้เขียนอาจไม่เท่ากับจำนวนข้อมูลที่เขียนได้จริงเช่นกรณีที่เกิดการผิดพลาดเนื่องมาจากดิสก์เต็มก่อนที่จะเขียนข้อมูลได้หมด เป็นต้น ทำให้โปรแกรมทราบว่าข้อมูลที่ต้องการเก็บลงไปในดิสก์นั้นมีความผิดพลาด ไม่สามารถเก็บข้อมูลได้ครบถ้วนตามที่เราสั่ง
การอ่านและเขียนข้อมูลในไฟล์ไม่กำหนดชนิดเข้าไปในตัวแปรByte_Array นี้ จะเริ่มกระทำตั้งแต่ตัวแรกของตัวแปร Byte_Arrayจนกระทั่งถึงตัวสุดท้ายของตัวแปร หรือได้ครบตามจำนวนที่กำหนดไว้ใน SizeofRead หรือ SizeofWrite
การปิดไฟล์ เลิกใช้งาน ใชคำสั่งดังนี้
close(filevar);
ตัวอย่างโปรแกรมที่ 10.8 จงเขียนโปรแกรมชื่อ FCOPY.PASเพื่อทำการ COPY ไฟล์ใดๆ แล้วแปล (Compile) โปรแกรมให้เป็น FCOPY.EXE โดยการทำงานของโปรแกรม FCOPY นี้จะต้องรับข้อมูลเป็นชื่อไฟล์จาก พารามิเตอร์ 2 ชุดที่ผู้ใช้พิมพ์ใส่เมื่อตอนเรียกโปรแกรม เช่น
FCOPY [ชื่อไฟล์ต้นฉบับ] [ชื่อไฟล์สำเนา]
การเขียนโปรแกรมโดยรับข้อมูลจากพารามิเตอร์ในขณะเรียกใช้โปรแกรม มีคำมาตรฐาน(Standard Word) ที่เกี่ยวข้องอยู่ 2 คำ คือ
Paramcount ใช้ตรวจสอบว่าในขณะเรียกโปรแกรมมีการใส่พารามิเตอร์กี่ตัว
Paramstr(n) เป็นพารามิเตอร์ที่ผู้ใช้ใส่เข้าไป ซึ่ง n เป็นตัวเลขแทนลำดับที่ของพารามิเตอร์ที่คีย์นั้น ในการแปลโปรแกรม FCOPY.PASให้เป็น FCOPY.EXE เราจะต้องเลือกทางเลือกในขณะที่ทำการแปลโปรแกรม โดยเลือก Destination ให้เป็น DISK
โปรแกรม FCOPY สามารถเขียนผังงานได้ดังโปรแกรมที่ 10.10 และผังงานที่ 10.11
โปรแกรมที่ 10.10 CopyFilePROGRAM CopyFile;VAR
Inputfile, Outputfile : file;NumRead, NumWritten : word;buf : ARRAY[1..10000] OF char;
BEGIN
assign(Inputfile, ParamStr(1));reset(Inputfile, 1); {Record size = 1}assign(Outputfile, ParamStr(2));rewrite(Outputfile, 1); {Record size = 1}REPEAT
blockread(Inputfile,buf,SizeOf(buf),NumRead);blockwrite(Outputfile,buf,NumRead,NumWritten);
UNTIL (NumRead = 0) OR (NumWritten <> NumRead);close(Inputfile);close(Outputfile);
END.
ผังงานที่ 10.11

ไม่มีความคิดเห็น: