จากบทความก่อนหน้านี้ได้กล่าวถึงประวัติภาษา C# ตัวแปร และการใช้เครื่องหมายดำเนินการพร้อมตัวอย่างการเขียนโค้ดเบื้องต้นไปแล้ว อันจะพบได้ว่า หลักการทำงานของโค้ดที่เขียนนั้นเป็นการทำงานจากบรรทัดบนลงบรรทัดล่าง โดยทำงานทีละคำสั่ง (แต่ละคำสั่งปิดท้ายด้วยเครื่องหมาย ; ) ในบทความตอนที่ 2 เป็นขั้นที่สูงขึ้น คือ เรียนรู้เกี่ยวกับการควบคุมการทำงานของโค้ดที่เขียนกรณีที่ต้องตัดสินตามเงื่อนไขที่ต้องการตรวจสอบเพื่อให้แยกโค้ดสำหรับทำงานแต่ละกรณี การทำซ้ำเพื่อให้สามารถประมวลผลแถวลำดับ (Array) หรือทำสิ่งซ้ำเดิมเป็นจำนวน N ครั้ง หรือตามสภาพของการเปรียบเทียบ และการสร้างโปรแกรมย่อยเพื่อแยกโค้ดการทำงานให้สามารถนำกลับมาใช้ซ้ำได้
การสร้างเงื่อนไข
การสร้างเงื่อนไขใน C# มีรูปแบบการเขียนด้วยกัน 3 แบบ คือ
1.รูปแบบแรกเป็นการตรวจสอบเงื่อนไข และถ้าเงื่อนไขเป็นจริงจะทำตามโค้ดที่เขียน ดังรูปแบบต่อไปนี้ โดยหลักการทำงานเป็นตามผังงาน
if (เงื่อนไข) { สิ่งที่ทำเมื่อเงื่อนไขเป็นจริง1 สิ่งที่ทำเมื่อเงื่อนไขเป็นจริง2 … สิ่งที่ทำเมื่อเงื่อนไขเป็นจริงn }
2. เป็นการตรวจสอบเงื่อนไข และถ้าเงื่อนไขเป็นจริงจะทำตามโค้ดที่เขียนไว้เพื่อรองรับการทำงานเมื่อไขเป้นจริง แต่ถ้าเงื่อนไขเป็นเท็จจะไปทำงานในส่วนที่อยู่ใน else โดยหลักการทำงานเป็นตามผังงาน
if (เงื่อนไข) { สิ่งที่ทำเมื่อเงื่อนไขเป็นจริง } else { สิ่งที่ทำเมื่อเงื่อนไขเป็นเท็จ }
3. เป็นแบบซ้อนเงื่อนไข คือ ทำการตรวจสอบเงื่อนไขภายใต้ if ถ้าเป็นจริงจะทำตามที่เขียนโค้ดเพื่อตอบสนองกรณีที่ if เป็นจริง แต่ถ้าเป็นเท็จจะดำเนินการตรวจสอบเงื่อนไขที่อยู่หลัง else if ถัดไป ถ้าเงื่อนไขเป็นจริงจะทำคำสั่งภายใต้ else if นั้น แต่ถ้าเป็นเท็จจะข้ามไปตรวจสอบ else if ถัดไปเรื่อย ๆ จนไม่พบ else if จะไปทำใน else โดยหลักการทำงานเป็นตามผังงาน
if ( เงื่อนไข1 ) { สิ่งที่ทำเมื่อเงื่อนไข1เป็นจริง } else if ( เงื่อนไข2 ) { สิ่งที่ทำเมื่อเงื่อนไข2เป็นจริง } … else if ( เงื่อนไขn ) { สิ่งที่ทำเมื่อเงื่อนไขnเป็นจริง } else { สิ่งที่ทำเมื่อเงื่อนไขเป็นเท็จ }
เครื่องหมายดำเนินการด้านการเปรียบเทียบเป็นดังตาราง 1-6 โดยผลลัพธ์ที่ได้จากการเปรียบเทียบเป็นจริงหรือเท็จ (True/False)
ตัวอย่างโปรแกรม 1-4 เป็นการกำหนดให้ตัวแปร x มีค่าเป็น 10 หลังจากนั้นตรวจสอบค่าที่เก็บในตัวแปร x ว่าเป็น 0 หรือไม่ ถ้าใช่จะแสดงคำว่า x == 0 แต่ถ้าไม่ใช่จะแสดง x !=0
โปรแกรม 1-4 ตัวอย่างการตรวจสอบค่าตัวแปร x มีค่าเป็น 0 หรือไม่
using System;
namespace if_else
{
class Program
{
static void Main(string[] args)
{
double x = 10.0;
if (x == 0.0)
{
Console.WriteLine(" x == 0 ");
}
else
{
Console.WriteLine(" x != 0 ");
}
}
}
}ตัวอย่างโปรแกรม 1-5 เป็นการตรวจสอบระดับของผู้เล่นจากค่าที่เก็บในตัวแปร score โดยเงื่อนไขกำหนดไว้ดังนี้
- ถ้าค่าน้อยกว่า 10 เป็น Level 0
- ถ้ามีค่าเป็น 10 ถึง 19 เป็น Level 1
- ถ้ามีค่าเป็น 20 ถึง 29 เป็น Level 2
- ถ้ามีค่าเป็น 30 ถึง 39 เป็น Level 3
- กรณีอื่น ๆ เป็น Level 4
สำหรับกรณีของการเปรียบเทียบความเท่ากันของตัวเลขทศนิยมจะมีปัญหาในบางกรณีตามรูปแบบขชองการใช้เลขทศนิยมแบบ IEEE 754 (The IEEE Standard for Floating-Point Arithmetic) ดังเช่นโค้ดต่อไปนี้จะพบว่าค่าไม่เท่ากันทั้งที่ควรจะเท่ากัน
float a = 0.1f;
float b = 0.2f;
Console.WriteLine("a = ", a);
Console.WriteLine("b = ", b);
Console.WriteLine("a+b = ", (a+b));
if ((a+b) == 0.3)
{
Console.WriteLine("0.3");
}
else
{
Console.WriteLine("???");
}วิธีการแก้ปัญหาคือ ใช้หลักของการหาความแตกต่างของค่า 2 ค่า ถ้าน้อยกว่าค่าที่กำหนด (epsilon) จะถือว่าเป็นค่าเดียวกัน แต่ถ้ามากกว่าหรือเท่ากันกับค่าดังกล่าวจะถือว่าเป็นตัวเลขทศนิยมทั้ง 2 ค่านั้นไม่เท่ากัน ดังตัวอย่างโปรแกรม 1-6
โปรแกรม 1-5 แสดงระดับของผู้เล่นจากตัวแปร score
using System;
namespace level_if
{
class Program
{
public static float score;
static void Main(string[] args)
{
score = 35.0f;
if (score <10) {
Console.WriteLine("Level 0");
} else if (score < 20) {
Console.WriteLine("Level 1");
} else if (score < 30) {
Console.WriteLine("Level 2");
} else if (score < 40) {
Console.WriteLine("Level 3");
} else {
Console.WriteLine("Level 4");
}
}
}
}การทำซ้ำ
การวนรอบหรือทำซ้ำ (repetition) ใน C# เป็นการใช้ชุดคำสั่งเพื่อให้เกิดการทำซ้ำภายใต้เงื่อนไข เช่น ทำถ้าเป็นจริง และทำเรื่อย ๆ จนกว่าเงื่อนไขที่ตรวจสอบจะเป็นเท็จ หรือ ทำเมื่ออยู่ในช่วงที่กำหนด เป็นต้น
while (เงื่อนไข) { สิ่งที่ทำ1 … สิ่งที่ทำn }
ในรูปแบบนี้เป็นการทำซ้ำเมื่อเงื่อนไขเป็นจริง และเมื่อทำในสิ่งที่กำหนดให้ทำจนเสร็จสิ้นจะกลับไปตรวจสอบเงื่อนไขอีกครั้ง ถ้าเงื่อนไขยังคงเป็นจริงจะทำต่อไปตราบจนได้ผลของเงื่อนไขเป็นเท็จจึงออกจากการทำซ้ำ เช่น การแสดงข้อมูล 0, 3, 6, 9 และ 12 สามารถเขียนได้ดังส่วนของโปรแกรมในโปรแกรมการวนซ้ำแบบ while
using System;
namespace loop_while
{
class Program
{
static Int32 x;
static void Main(string[] args)
{
x = 0;
while (x <= 12)
{
Console.WriteLine(x);
x = x + 3;
}
}
}
}กรณีที่ต้องการวนรอบโดยไม่ต้องตรวจสอบเงื่อนไข แต่เป็นการทำซ้ำที่เกิดจากการตรวจสอบค่าจากตัวแปรว่าอยู่ในช่วงค่าที่กำหนดหรือไม่จะใช้รูปแบบคำสั่งทำซ้ำเป็นดังนี้
for ( ค่าเริ่ม; เงื่อนไข; สิ่งที่ก่อนเริ่มรอบใหม่ ) { สิ่งที่ทำ1 … สิ่งที่ทำn }
จากรูปแบบของคำสั่ง for สามารถเขียนขั้นตอนของการทำงานได้ดังนี้
- ทำส่วนของค่าเริ่ม
- ตรวจสอบเงื่อนไข ถ้าเงื่อนไขเป็นจริงจะทำ สิ่งที่ทำ1 ไปจนถึง สิ่งที่ทำn แต่ถ้าเงื่อนไขเป็นเท็จจะข้ามการทำงานของคำสั่ง for
- หลังจากทำสิ่งที่ทำn จะเข้าไปทำ สิ่งที่ก่อนเริ่มรอบใหม่
- กลับไป 2
using System;
namespace loop_for
{
class Program
{
static Int32 x;
static void Main(string[] args)
{
for (x=0; x <= 12; x+=3)
{
Console.WriteLine(x);
}
}
}
}และสำหรับการวนรอบหรือทำซ้ำโดยทำก่อน 1 รอบ หลังจากนั้นทำการตรวจสอบเงื่อนไข และถ้าเงื่อนไขเป็นจริงจะดำเนินการทำซ้ำอีกครั้งตราบเท่าที่เงื่อนไขนั้นเป้นจริง โดยรูปแบบของการใช้คำสั่งเป็นดังนี้
do { สิ่งที่ทำ1 … สิ่งที่ทำn } while (เงื่อนไข);
นอกจากการทำซ้ำยังมีคำสั่งสำหรับออกจากการทำซ้ำ คือ break และคำสั่งสำหรับให้กลับไปตรวจสอบเงื่อนหลัง while โดยให้ข้ามคำสั่งถัดไป คือ continue
โปรแกรมย่อย
โปรแกรมย่อย หรือ ฟังก์ชัน (function) หรือ เมธอด (method) เป็นการสร้างกลุ่มของคำสั่งเพื่อนำกลับมาใช้ในภายหลัง อันจะพบว่า ในโค้ดโปรแกรมที่ได้ศึกษามาในตัวอย่างก่อนหน้านี้มีฟังก์ชันหรือโปรแกรมย่อยชื่อ Main() ซึ่งเป็นโปรแกรมย่อยที่ไม่มีการคืนค่ากลับพร้อมทั้งไม่ต้องการพารามิเตอร์ และเป็นฟังก์ชันที่ถูกกำหนดให้เป็นฟังก์ชันแรกที่ถูกเรียกใช้เมื่อโปรแกรมเริ่มทำงาน โดยประเภทของโปรแกรมย่อยแบ่งเป็นหลายประเภท ได้แก่
- โปรแกรมย่อยที่ไม่คืนค่าและไม่ต้องการพารามิเตอร์
- โปรแกรมย่อยที่ไม่คืนค่าแต่ต้องการพารามิเตอร์
- โปรแกรมย่อยที่คืนค่าแต่ไม่ต้องการพารามิเตอร์
- โปรแกรมย่อยที่คืนค่าและต้องการพารามิเตอร์
โปรแกรมย่อยที่ไม่คินค่าและไม่ต้องการพารามิเตอร์
โปรแกรมย่อยประเภทนี้ไม่ต้องการข้อมูลนำเข้าและไม่คืนค่ากลับ โดยโครงสร้างของโปรแกรมย่อยแบบนี้เป็นดังนี้
void ชื่อโปรแกรมย่อย( ) { คำสั่ง1; คำสั่ง2; … คำสั่งn; }
ตัวอย่างการเขียนโปรแกรมย่อยเพื่อแสดงข้อความ “Hello” สามารถเขียนได้ดังนี้
void say_hello() {
Console.WriteLine( “Helo” );
}โปรแกรมย่อยที่ไม่คืนค่าแต่ต้องการพารามิเตอร์
โปรแกรมย่อยประเภทนี้ต้องการข้อมูลนำเข้าแต่ไม่คืนค่ากลับ ซึ่งข้อมูลนำเข้าเหล่านี้ถูกมองเสมือนเป็นตัวแปรภายในของโปรแกรมย่อยทำให้สามารถนำค่ามาใช้หรือเปลี่ยนแปลงค่าได้ตามความต้องการ โดยโครงสร้างของโปรแกรมย่อยแบบนี้เป็นดังนี้
void ชื่อโปรแกรมย่อย( ประเภทข้อมูล1 ข้อมูล1, ประเภทข้อมูล2 ข้อมูล2, …, ประเภทข้อมูลn ข้อมูลn ) { คำสั่ง1; คำสั่ง2; … คำสั่งn; }
ตัวอย่างโปรแกรมย่อยแสดงผลการบวกระหว่างตัวแปร x และ y ที่เป็น float สามารถเขียนได้ดังนี้
void show_add( float x, float y ) {
Console.WriteLine( x + y );
}โปรแกรมย่อยที่คืนค่าแต่ไม่ต้องการพารามิเตอร์
โปรแกรมย่อยประเภทนี้ไม่ต้องการข้อมูลนำเข้า แต่มีการคืนค่ากลับหลังจากการทำงานเสร็จ เพื่อเปิดโอกาสให้ผู้ใช้งานโปรแกรมย่อยสามารถนำค่าคืนค่ากลับนี้ไปใช้ในการตรวสอบหรือนำไปเก็บในตัวแปรเพื่อนำไปใช้งานต่อไป โดยโครงสร้างของโปรแกรมย่อยแบบนี้เป็นดังนี้
ประเภทข้อมูล ชื่อโปรแกรมย่อย( ) { คำสั่ง1; คำสั่ง2; … คำสั่งn; return ค่าคืนกลับ; }
ตัวอย่างโปรแกรมการส่งค่าคืนกลับเป็นค่า Pi หารด้วย 180 สามารถเขียนได้ดังนี้
float pi_over_180() {
return ( 3.1415296f/180.0f );
}โปรแกรมย่อยที่คืนค่าและต้องการพารามิเตอร์
โปรแกรมย่อยประเภทนี้ต้องการข้อมูลนำเข้า และคืนค่ากลับ ซึ่งข้อมูลนำเข้าเหล่านี้ถูกมองเสมือนเป็นตัวแปรภายในของโปรแกรมย่อยทำให้สามารถนำค่ามาใช้หรือเปลี่ยนแปลงค่าได้ตามความต้องการ พร้อมทั้งเมื่อทำงานเสร็จจะคืนค่ากลับไปให้ระบบ หรือนำไปเก็บในตัวแปรเพื่อเก็บผลลัพธ์ของการทำงานจากโปรแกรมย่อยนี้ต่อไป โดยโครงสร้างของโปรแกรมย่อยแบบนี้เป็นดังนี้
ประเภทข้อมูล ชื่อโปรแกรมย่อย( ประเภทข้อมูล1 ข้อมูล1, ประเภทข้อมูล2 ข้อมูล2, …, ประเภทข้อมูลn ข้อมูลn ) { คำสั่ง1; คำสั่ง2; … คำสั่งn; return ค่าคืนกลับ; }
ตัวอย่างโปรแกรมย่อยแปลงค่ามุมแบบองศาให้เป็นเรเดียนเขียนได้ดังนี้
float degree_to_radian( float degree ) {
return degree * (180.0f/3.1415926f);
}สรุป
จากบทความนี้จะพบว่าโครงสร้างการเขียนโปรแกรม C# โดยพื้นฐานมีความคล้ายกับการเขียนภาษา C/C++/Java/Kotlin คือ มีการประกาศประเภทของข้อมูล การตั้งชื่อ การดำเนินการแบบนิพจน์ การตรวจสอบเงื่อนไข การทำซ้ำ ข้อมูลแบบแถวลำดับ และโปรแกรมย่อย ทำให้เมื่อเข้าใจภาษาใดภาษาหนึ่งจักทำให้สามารถนำไปประยุกต์กับภาษาอื่น ๆ ได้
(C) 2024, โดย จารุต บุศราทิจ
DcG.IT@PBRU
