1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
|
---
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/
|
