mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-27 19:28:51 +00:00
237 lines
17 KiB
Markdown
237 lines
17 KiB
Markdown
---
|
|
language: Pascal
|
|
filename: learnpascal.pas
|
|
contributors:
|
|
- ["Ganesha Danu", "http://github.com/blinfoldking"]
|
|
- ["Keith Miyake", "https://github.com/kaymmm"]
|
|
translators:
|
|
- ["Worajedt Sitthidumrong", "https://bitbucket.org/wrj"]
|
|
lang: th-th
|
|
---
|
|
|
|
> Pascal (ปาสกาล) เป็นภาษาโปรแกรมมิ่งทั้งแบบ imperative และ procedural ที่ออกแบบโดย Niklaus Wirth (นิเคล้า เวิร์ท) เมื่อปี 1968-69 และเผยแพร่ตอน 1970 โดยเน้นให้เป็นภาษาที่เล็ก มีประสิทธิภาพ เพื่อเสริมการเขียนโปรแกรมที่มีแนวปฏิบัติที่ดีด้วยการใช้โครงสร้างของตัวภาษา และโครงสร้างข้อมูลมากำกับ ชื่อของภาษานี้ตั้งเป็นเกียรติให้กับนักคณิตศาสตร์ชาวฝรั่งเศส, นักปรัชญา และนักฟิสิกส์ ชื่อ Blaise Pascal (เบลส ปาสกาล) ข้อมูลจาก : [วิกิพีเดีย][1]
|
|
|
|
การคอมไพล์และรันโค้ดภาษาปาสกาลนี้ สามารถใช้ปาสกาลคอมไพลเลอร์ฟรีชื่อ Free Pascal ได้ โดย [ดาวน์โหลดที่นี่][2]
|
|
|
|
ด้านล่างจะเป็นโครงสร้างภาษาหลัก ๆ ที่ต้องเข้าใจก่อน ปาสกาลจะเป็นภาษาที่เข้มงวดกับโครงสร้างโค้ดมาก
|
|
|
|
```pascal
|
|
//โปรแกรมปาสกาล
|
|
//คอมเม้นต์เขียนแบบนี้ ใช้สแลชสองครั้ง
|
|
{
|
|
แต่ถ้าต้องการคอมเม้นหลาย ๆ บรรทัด
|
|
ให้ใช้ วงเล็บปีกกา (curly brackets)
|
|
เนื้อหาอยู่บรรทัดเดียวกันกับปีกกาได้
|
|
}
|
|
|
|
//อย่างแรก ต้องประกาศ ชื่อโปรแกรม
|
|
program learn_pascal; //<-- ห้ามลืม semicolon
|
|
|
|
const
|
|
{
|
|
ประกาศค่าคงที่ (constant) ในบล็อคนี้
|
|
}
|
|
type
|
|
{
|
|
ประกาศชนิดข้อมูลของเราเองที่นี่ ไม่ว่าจะเป็น ชนิดข้อมูลทั่วไป
|
|
หรือจะเป็นคลาส
|
|
}
|
|
var
|
|
{
|
|
ตัวแปร ในภาษาปาสกาล ไม่เหมือนกับภาษาอื่น ๆ
|
|
เพราะต้องประกาศในบล็อค var ก่อนใช้งานเสมอ
|
|
}
|
|
|
|
//มาถึงส่วนโปรแกรมหลัก หรือ main fucntion นั่นเอง
|
|
begin
|
|
{
|
|
โค้ดเราทำงานอะไร อย่างไร ก็เริ่มรันจากตรงนี้
|
|
}
|
|
end. // จบการทำงานของ _โปรแกรม_ เราจะจบด้วย จุลภาค "."
|
|
```
|
|
|
|
โค้ดต่อจากนี้ จะเป็นการอธิบายประกาศตัวแปรของปาสกาล
|
|
|
|
```pascal
|
|
//การประกาศตัวแปร ทำได้แบบนี้
|
|
//var ชื่อตัวแปร : ชนิด ;
|
|
var a:integer;
|
|
var b:integer;
|
|
|
|
//หรือแบบที่นิยมมากกว่า คือเอามาเก็บในบล็อค var ทั้งหมด
|
|
var
|
|
a : integer;
|
|
b : integer;
|
|
|
|
//ถ้าจะเอาแบบสั้น ๆ บรรทัดเดียว ก็ทำได้ ทำได้พร้อมกันหลาย ๆ ตัวแปรด้วย
|
|
var a,b : integer;
|
|
```
|
|
|
|
โค้ดตัวอย่างนี้เป็นโปรแกรม Learn\_More ที่เป็นโครงสร้างโปรแกรมง่าย ๆ ที่จบสมบูรณ์หนึ่งโปรแกรม มีบล็อค program, const, type, main (Begin..End.)
|
|
|
|
```pascal
|
|
program Learn_More;
|
|
// มาต่อเรื่อง ชนิดของข้อมูล (data types) และ ตัวดำเนินการ (operators)
|
|
|
|
const
|
|
PI = 3.141592654;
|
|
GNU = 'GNU''s Not Unix';
|
|
// ค่าคงที่ ให้ตั้งชื่อเป็น ตัวพิมพ์ใหญ่ ทั้งหมด ใช้กับชนิดข้อมูลใดๆ ก็ได้
|
|
// ค่าคงที่ ก็ตามชื่อเลย กำหนดค่าแล้ว ไม่สามารถเปลี่ยนแปลงได้ขณะรัน
|
|
|
|
// การประกาศชนิดข้อมูลของเราเอง
|
|
// "ชนิด" ของตัวแปรสองแบบนี้ จะนำไปใช้ด้านล่าง
|
|
type
|
|
ch_array : array [0..255] of char;
|
|
// อะเรย์ เป็นชนิดข้อมูลที่มี ความยาว/ช่องเก็บข้อมูล และ ชนิดข้อมูล
|
|
// โค้ดด้านบน เป็นการประกาศอะเรย์ของตัวอักษา 255 ตัวอักษา
|
|
// ซึ่งได้ ความยาว/ช่องเก็บข้อมูลในตัวแปรตัวนี้ 256 ช่องที่เป็นข้อความ
|
|
md_array : array of array of integer;
|
|
// ด้านบนนี้ เป็นตัวอย่าง อะเรย์สองมิติของเลขจำนวนเต็ม
|
|
// อะเรย์ ยังซ้อนกับอะเรย์ได้อีกด้วย ทำให้สร้าง อะเรย์หลายมิติได้
|
|
// เรายังสามารถสร้าง อะเรย์ที่มีความยาวช่องเท่ากับศูนย์ (0) ได้อีกด้วย
|
|
// ซึ่งทำให้เกิด อะเรย์ที่จำนวนช่องยืดหยุ่นได้ (dymaically sized array)
|
|
|
|
// การประกาศตัวแปร : ชื่อตัวแปรเหล่านี้จะนำไปใช้ด้านล่างต่อไป
|
|
var
|
|
int, c, d : integer;
|
|
// ประกาศในบล็อค var มีตัวแปรสามตัวเป็นอินทีเจอร์
|
|
// ชนิดจำนวนเต็ม แบบ 16 bit มีช่วงข้อมูล [-32,768.. 32,767]
|
|
// »int« ในที่นี้เป็น "ชื่อตัวแปร" ที่ต้นฉบับตั้งให้สอดคล้องกับชนิดข้อมูล
|
|
// อย่าสับสนกับบางภาษาที่มีชนิด int ประกาศหน้าชื่อตัวแปร
|
|
r : real;
|
|
// ตัวแปร r เป็นชนิดเรียล (real) หรือเลขทศนิยม
|
|
// real มีช่วงข้อมูล [3.4E-38..3.4E38]
|
|
bool : boolean;
|
|
// ข้อมูลชนิดบูเลียน (boolean) มีค่าได้สองแบบ คือ True/False
|
|
ch : char;
|
|
// ตัวแปร ch เป็นชนิดตัวอักษร (ชาร์? คาร์?) หรือคาแรกเตอร์
|
|
// ตัวอักษรเป็นแบบ ASCII 8 bit ดังนั้นจะไม่ใช่ UTF, Unicode
|
|
str : string;
|
|
// ตัวแปรสตริงจะเก็บข้อความ หรือ char หลาย ๆ ตัว
|
|
// ชนิดข้อมูลนี้ไม่เป็นมาตรฐานภาษาแต่คอมไพเลอร์ปาสกาลก็มักจะมีให้
|
|
// ทั่ว ๆ ไปแล้ว จะเป็นอะเรย์ของ char ความยาวตั้งต้น 255
|
|
s : string[50];
|
|
// แบบนี้คือ กำหนดความยาว string เอง ให้เก็บ char 50 ตัว
|
|
// แบบนี้ก็ทำให้ประหยัดหน่วยความจำมากขึ้นนั่นเอง
|
|
my_str: ch_array;
|
|
// ชนิดตัวแปร ใช้เป็นชนิดที่เรากำหนดเองก็ได้ อย่างตอนนี้
|
|
// ch_array เป็น "ชนิดข้อมูล" ที่เราสร้างขึ้นมาในบล็อค type
|
|
my_2d : md_array;
|
|
// ตัวแปรแบบอะเรย์ที่ไม่ประกาศขนาด (dynamically sized array)
|
|
// ก่อนเอาไปใช้จริงต้องระบุขนาดก่อนใช้เสมอ
|
|
|
|
// ชนิดข้อมูลแบบ integer เพิ่มเติม
|
|
b : byte; // มีช่วงข้อมูล [0..255]
|
|
shi : shortint; // มีช่วงข้อมูล [-128..127]
|
|
smi : smallint; // มีช่วงข้อมูล [-32,768..32,767] (standard Integer)
|
|
w : word; // มีช่วงข้อมูล [0..65,535]
|
|
li : longint; // มีช่วงข้อมูล [-2,147,483,648..2,147,483,647]
|
|
lw : longword; // มีช่วงข้อมูล [0..4,294,967,295]
|
|
c : cardinal; // ก็คือ longword
|
|
i64 : int64; // มีช่วงข้อมูล
|
|
// [-9223372036854775808..9223372036854775807]
|
|
qw : qword; // มีช่วงข้อมูล [0..18,446,744,073,709,551,615]
|
|
|
|
// ชนิดข้อมูลแบบ real เพิ่มเติม
|
|
rr : real; // มีช่วงข้อมูลที่ขึ้นกับระบบปฏิบัติการ
|
|
// (เช่นเป็นแบบ 8-bit, 16-bit, ฯลฯ)
|
|
rs : single; // มีช่วงข้อมูล [1.5E-45..3.4E38]
|
|
rd : double; // มีช่วงข้อมูล [5.0E-324 .. 1.7E308]
|
|
re : extended; // มีช่วงข้อมูล [1.9E-4932..1.1E4932]
|
|
rc : comp; // มีช่วงข้อมูล [-2E64+1 .. 2E63-1]
|
|
|
|
Begin
|
|
// การกำหนดค่าตัวแปรให้ขณะประกาศ
|
|
int := 1;
|
|
r := 3.14;
|
|
ch := 'a'; // ใช้ single quote เหมือนกันทั้ง char และ string
|
|
str := 'apple';
|
|
bool := true;
|
|
// ภาษาปาสกาล มอง "ชื่อเฉพาะ" แบบไม่สนพิมพ์ใหญ่พิมพ์เล็ก
|
|
// (case-insensitive language)
|
|
// ตัวดำเนินการแบบคณิตศาสตร์ (arithmethic operation)
|
|
int := 1 + 1; // int = 2 ซึ่งจะกำหนดทับค่าเดิมด้านบนที่เคยประกาศ
|
|
int := int + 1; // int = 2 + 1 = 3 นำค่าตอนนี้ (2) มา +1 ได้ 3
|
|
int := 4 div 2; // int = 2 หารด้วย div จะได้ผลเป็น integer เสมอ
|
|
int := 3 div 2; // int = 1
|
|
int := 1 div 2; // int = 0
|
|
|
|
bool := true or false; // bool = true
|
|
bool := false and true; // bool = false
|
|
bool := true xor true; // bool = false
|
|
|
|
r := 3 / 2; // หารด้วย / จะได้ผลเป็น real เสมอ
|
|
r := int; // เรากำหนดค่า integer ให้ตัวแปร real ได้
|
|
// แต่ทำกลับกัน โดยกำหนด real ให้ integer ไม่ได้
|
|
|
|
c := str[1]; // กำหนดค่าแรกใน array str ให้ตัวแปร c ที่เป็น char
|
|
str := 'hello' + 'world'; // เรารวม string เข้าด้วยกันด้วย +
|
|
|
|
my_str[0] := 'a'; // กำหนดค่าให้ string เฉพาะตำแหน่งแบบอะเรย์ทั่วไป
|
|
|
|
setlength(my_2d,10,10); // ปรับขนาดอะเรย์ 2 มิติให้เป็นขนาด 10x10
|
|
// โดยตัวแปร my_2d นี้สร้างแล้วด้านบน
|
|
for c := 0 to 9 do // อะเรย์เริ่มจาก 0 และจบที่ ความยาว-1
|
|
for d := 0 to 9 do // ตัวนับ (counter) จำเป็นต้องประกาศก่อนใช้
|
|
my_2d[c,d] := c * d;
|
|
// กำหนดอะเรย์หลายมิติ ด้วยการใช้วงเล็บก้ามปู (square brackets)
|
|
|
|
End.
|
|
// จบโปรแกรมบริบูรณ์ ด้วย "."
|
|
```
|
|
|
|
ด้านล่าง เป็นตัวอย่างการเขียนโปรแกรมปาสกาลชื่อ Functional\_Programming
|
|
|
|
```pascal
|
|
program Functional_Programming;
|
|
|
|
Var
|
|
i, dummy : integer;
|
|
|
|
function factorial_recursion(const a: integer) : integer;
|
|
{ ทำการคำนวณแฟคทอเรียลซ้ำ ๆ ของเลขจำนวนเต็ม โดยผ่านพารามิเตอร์ a
|
|
ถ้าจะประกาศตัวแปรโลคอลในฟังก์ชั่น ก็ทำได้ โดยการใช้บล็อค var ภายในฟังก์ชั่น
|
|
เช่น :
|
|
var
|
|
local_a : integer;
|
|
}
|
|
Begin
|
|
If a >= 1 Then
|
|
{ ฟังก์ชั่นนี้คืนค่ากลับ โดยการกำหนดค่าที่ผ่านทางพารามิเตอร์ a
|
|
นำมาคูณกับฟังก์ชั่นที่ผ่าน a-1 สุดท้ายก็กำหนดค่าลงไปให้กับฟังก์ชั่นตรงๆ }
|
|
factorial_recursion := a * factorial_recursion(a-1)
|
|
Else
|
|
factorial_recursion := 1;
|
|
End; // จบ ฟังก์ชั่น ด้วย ";" หลัง End ไม่เหมือนกับจบ โปรแกรม ที่จะใช้ "."
|
|
|
|
procedure get_integer(var i : integer; dummy : integer);
|
|
{ เรารับ input จากผู้ใช้มาเก็บใน parameter i ที่เป็น integer ที่ตั้งขึ้นใน
|
|
พารามิเตอร์ โดยใช้ var ประกาศ ทำให้ค่าที่รับเข้ามาจะเปลี่ยนปรับได้จาก
|
|
ภายนอกการประกาศพารามิเตอร์นี้ ส่วน dummy เป็นตัวแปรที่ปรับเปลี่ยนได้
|
|
"เฉพาะจากภายในฟังก์ชั่น,โพรซีเยอร์นั้น ๆ }
|
|
Begin
|
|
write('Enter an integer: ');
|
|
readln(i);
|
|
dummy := 4; // dummy จะไม่ทำให้ค่าที่ได้รับมาครั้งแรกใน main block เปลี่ยน
|
|
End;
|
|
|
|
//--------------------//
|
|
// main program block
|
|
//--------------------//
|
|
Begin
|
|
dummy := 3;
|
|
get_integer(i, dummy);
|
|
writeln(i, '! = ', factorial_recursion(i));
|
|
// พิมพ์ค่า i!
|
|
writeln('dummy = ', dummy); // จะให้ค่าเป็น '3' เสมอ
|
|
// เพราะจะไม่เปลี่ยนเนื่องด้วย
|
|
// การประกาศพารามิเตอร์ใน
|
|
// โพรซีเยอร์ get_integer ด้านบน
|
|
End.
|
|
|
|
```
|
|
|
|
[1]: https://en.wikipedia.org/wiki/Pascal_(programming_language)
|
|
[2]: https://www.freepascal.org/
|