แบบทดสอบ O-net วิชา การงานอาชีพและเทคโนโลยี (คอมพิวเตอร์)
1.ข้อใดไม่ใช่ระบบปฏิบัติการที่นำมาใช้บนอุปกรณ์พกพา
ประเภท Smartphone.
1. Ubumtu 2. Iphone os
3. Android 4. Symbian
เฉลยข้อ 1
2.ไฟล์ประเภทใดในข้อต่อไปนี้เก็บข้อมูลในลักษณะตัวอักษร.
1. ไฟล์เพลง MP 3 (mp 3)
2. ไฟล์รูปประเภท JPEG (jpeg)
3. ไฟล์แสดงผลหน้าเว็บ (html)
4. ไฟล์วีดีโอประเภท Movie (movie)
เฉลยข้อ 3
3.ลิขสิทธิ์โปรแกรมประเภทรหัสเปิด(Open Source)อนุญาต
ให้ผู้ใช้ทำอะไรได้บ้าง.
ก. นำโปรแกรมมาใช้งานโดยไม่ต้องเสียค่าลิขสิทธิ์
ข. ทดลองใช้โปรแกรมก่อนถ้าพอใจจึงจ่ายค่าลิขสิทธิ์
ค. แก้ไขปรับปรุงโปรแกรมเองได้
1. ข้อ ก กับ ข้อ ค 2. ข้อ ข กับ ข้อ ค
3. ข้อ ข อย่างเดียว 4. ข้อ ก อย่างเดียว
เฉลยข้อ 4
4.ระบบกระดานสนทนาหรือเว็บบอร์ดแห่งหนึ่งมีความต้องการดังนี้
ก. ต้องให้ผู้ใช้สามารถตั้งกระทู้โต้ตอบกันได้โดยผู้ใช้ต้องแสดง
ตัวตน(ล็อกอิน)เพื่อเข้าระบบก่อน
ข. ผู้ใช้สามารถตั้งกระทู้หรือเข้าไปตอบกระทู้ที่ตั้งไว้แล้วได้
ค. ระบบจะบันทึกชื่อผู้ตั้งและผู้ตอบไว้ด้วย
ในการออกแบบฐานข้อมูลดังกล่าวข้อใดกล่าวได้ถูกต้อง.
1. ต้องสร้างตารางผู้ใช้ ตารางกระทู้และตารางคำตอบ
2. ไม่ต้องสร้างตารางผู้ใช้เนื่องจากสามารถบันทึกชื่อผู้ใช้ในตาราง
กระทู้และตารางคำตอบได้เลย
3. ต้องสร้างตารางผู้ใช้และตารางกระทู้ส่วนคำตอบจะอยู่ในตาราง
กระทู้อยู่แล้ว
4. ไม่ต้องสร้างตารางกระทู้เพราะสามารถบันทึกกระทู้ที่ผู้ใช้ตั้งใน
ตารางผู้ใช้ได้เลย
เฉลยข้อ 4
5.ข้อใดเป้นการปฏิบัติที่ถูกต้องตามหลักวิชาการเมื่อค้นคว้า
หาข้อมูลจากอินเทอร์เนตมาทำรายงาน.
1. คัดลอกเนื้อหาจากเว็บไซต์
2. ใช้เนื้อหาจากกระดานสนทนา(Web board)มาใส่ในรายงาน
3. นำรูปภาพจากเว็บไซต์มาใส่ในรายงาน
4. อ้างอิงชื่อผู้เขียนบทความ
เฉลยข้อ 4
6.ห้องสมุดแห่งหนึ่งต้องการพัมนาระบบยืมหนังสือโดยสามารถ
บันทึกข้อมูลการยืมหนังสือลงบนบัตรอิเลคโทรนิกส์โดยไม่ต้อง
เขียนด้วยมือระบบนี้ควรใช้เทคโนโลยีในข้อใด.
1. Smart Card 2. Fingerprint
3. Barcode 4. WiFi
เฉลยข้อ 3
7.ผู้ประกอบอาชีพเป็นผู้พัฒนาเว็บไซต์ต้องเชี่ยวชาญความรู้
ด้านใดบ้างจากตัวเลือกต่อไปนี้.
ก. ฮาร์แวร์คอมพิวเตอร์ ข. ระบบปฎิบัติการ
ค. เว็บเซิร์ฟเวอร์ ง. HTML
จ. ระบบฐานข้อมูล ฉ. ภาษาจาวา(Java)
1. ข้อ ก และ ค 2. ข้อ ข และ จ
3. ข้อ ค และ ง 4. ข้อ ค และ ฉ
เฉลยข้อ 3
8.ข้อใดเป็นเทคโนโลยีการเชื่อมต่อข้อมูลไร้สายทั้งหมด.
1. Wi-Fi , IP 2. Wi-Fi ,Bluetooth
3. 3G ADSL 4. 3G Ethernet
เฉลยข้อ 2
9.ข้อใดไม่ใช่ข้อเสียของการละเมิดลิขสิทธิ์ซอฟต์แวร์.
1. การทำผิดกฏหมายลิขสิทธิ์มีความผิดทางอาญา
2. เป็นช่องทางหนึ่งในการระบาดของไวรัสคอมพิวเตอร์
3. ผู้ใช้จะไม่ได้รับการบริการจากผู้พัมนาถ้าหากมีปัญหาการใช้งาน
4. ทำให้ผู้พัมนาซอฟแวร์ไม่มีรายได้เพื่อประกอบการและพัฒนาต่อไปได้
เฉลยข้อ 2
10.ข้อใดต่อไปนี้ถูกต้องที่สุด.
1. การบันทึกข้อมูลลงแผ่นดีวีดีใช้เทคโนโลยีแบบแม่เหล็ก
2. หมายเลขไอพีเป็นหมายเลขที่ใช้กำกับ Network Interce Card
3. หน่วยความจำสำรองเป็นหน่วยความจำที่มีคุณลักษณะแบบ Volntile
4. รหัส ACIIและEBCIDICเป็นการวางรหัสตัวอักษรที่ใช้ขนาด 8 บิด
เฉลยข้อ 3
ที่มา : https://krupaga.wordpress.com/category
วันจันทร์ที่ 15 ธันวาคม พ.ศ. 2557
คำสั่ง SQL
ในส่วนการสรุปรูปแบบทั่วไปของประโยคคำสั่ง SQL แต่ระบบฐานข้อมูลแต่ละระบบอาจจะสนับสนุนหรือไม่สนับสนุนต้องดูคู่มือของ่ร ะบบฐานข้อมูลนั้นประกอบด้วย
ALTER TABLE tablename [ADD| DROP| MODIFY] columnname; (ดูเพิ่มเติม1, ดูเพิ่มเติม2 ) ใช้สำหรับการเพิ่ม, แก้ไข หรือลบ คอลัมน์ของ table และเปลี่ยนข้อความ เช่น ประเภทข้อมูล ของคอลัมน์ที่มีอยู่ การเลือก ADD, DROP หรือ MODIFY เลือกได้อย่างเดียว
COMMIT; (ดูเพิ่มเติม) บันทึกการเปลี่ยนแปลงเข้าสู่ฐานข้อมูล
CREATE [UNIQUE] INDEX indexname
ON tablename (columnname); (ดูเพิ่มเติม1, ดูเพิ่มเติม2 ) UNIQUE เป็นตัวเลือกการสร้างดัชนีแบบไม่ซ้ำ
CREATE TABLE tablename
(columnname1 datatype [size] [constraint], columnname2 datatype [size] [constraint], . .); (ดูเพิ่มเติม1, ดูเพิ่มเติม2) เป็นคำสั่งสร้าง table การกำหนด size ขึ้นกับประเภทข้อมูล constraint ที่สามารถกำหนดได้ คือ NULL หรือ NOT NULL, UNIQUE (บังคับให้ค่าไม่ซ้ำ), PRIMARY KEY (ระบุ primary key ของ table), CHECK (การยอมให้ตรวจสอบข้อมูลที่มีการเปลี่ยนแปลง), DEFULT (ให้แทรกค่าเมื่อมีการเพิ่มแถวข้อมูล), FOREIGN KEY (กำหนด foreign key ของ table)
CREATE VIEW tablename AS select statement; (ดูเพิ่มเติม) สร้าง view
DELETE FROM tablename WHERE condition; (ดูเพิ่มเติม) ลบข้อมูล
INSERT INTO tablename (column1, column2,..)
VALUES (value1, value2,..); (ดูเพิ่มเติม)
ROLLBACK;(ดูเพิ่มเติม) เรียกข้อมูลเดิมกลับมา จากการเปลี่ยนแปลงข้อมูลที่เกิดขึ้น โดยสามารถเรียกกลับจาก COMMIT ครั้งสุดท้าย
SELECT [ALL | DISTINCT] column1[,column2]
FROM table1[,table2]
[WHERE conditions]
[GROUP BY column-list]
[HAVING conditions]
[ORDER BY column-list [ASC | DESC] ]; (ดูเพิ่มเติม) โดย ASC | DESC ให้เลือกวิธีเรียงลำดับข้อมูล
UPDATE tablename
SET column1 = value1, column2 = value2, ..
[WHERE condition]; (ดูเพิ่มเติม) ถ้าไม่มี WHERE clause จะเปลี่ยนค่าตามที่กำหนดทั้งหมด
วันจันทร์ที่ 1 ธันวาคม พ.ศ. 2557
Root คืออะไร
Root ในภาษาของคนใช้ Linux ทั่วไป มันคือ Default Super User นั่นเองครับ หลังจากเราลง Linux หรือญาติของ Linux ตัวอื่นๆอย่าง Ubuntu, FreeBSD และ Fedora มันจะมี User ที่ขื่อว่า Root เป็น Super User ที่สามารถแก้ไขไฟล์และตั้งค่าระบบต่างๆในเครื่องได้ ถ้าจะพูดกันให้เข้าใจแบบบ้านๆกับคนใช้ Windows บ่อยๆ Super User ก็คือ Adminstrator นั่นล่ะครับ
การ Jailbreak บน iOS ก็คือการทำให้ได้มาซึ่งสิทธิของ Super User เช่นเดียวกับ การ Root บน Android ครับ ทำให้หลังจากที่เราทำการ Jailbreak บน iOS แล้วเราจะสามารถแก้ไขส่วนต่างๆของระบบได้เช่นเดียวกับ Android ที่ทำการ Root พูดง่ายๆก็คือ Jailbreak(iOS) = Root(Android) นั่นเอง แต่ทว่า Android นั้นเค้าไม่ได้ล้อคการติดตั้งแอพฯที่ไม่รู้แหล่งที่มาหรือแอพฯนอก Market ( Unknow Source ) ทำให้ Android สามารถติดตั้งแอพฯที่เป็นไฟล์ .apk ได้เลย ต่างจาก Apple ที่ล้อคการติดตั้งเอาไว้ ทำให้ผู้ที่ต้องการลงแอพฯไฟล์ .ipa นั้นจำเป็นต้อง Root เพื่อแก้ไขระบบก่อน จึงจะสามารถลงแอพฯจากไฟล์ได้
Root แล้วได้อะไร?
มีหลายๆคนมักจะเข้าใจผิดกันไปต่างๆนาๆว่า Root แล้วเครื่องจะเร็วขึ้น Root แล้วเครื่องจะเสถียรขึ้น Root แล้วเครื่องจะประหยัดแบตขึ้น ต้องบอกว่านั่นไม่ใช่สิ่งที่ได้มาจากการ Root ครับ แต่มันจะได้มาหลังจากการ Root ต่างหากล่ะครับ บางคนอาจจะคิดง่ายๆว่าอยาก Overclock CPU ก็ Root แล้วลงแอพฯ Overclock ก็จบแล้ว จริงๆมันไม่ใช่ครับ บางเครื่องอาจจะง่ายๆแค่นั้น บางเครื่องก็ถึงกับต้องลง Custom ROM หรือยัด Kernel ที่ Support การ Overclock ลงไป ถึงจะสามารถ Overclock ได้ เพราะฉะนั้นถ้าหากเราต้องการจะใช้อะไรหลังจากการ Root ให้ไปดูวิธีทำไว้ก่อนว่ามันยากเกินกว่าเราจะทำได้มั้ย หรือมันสามารถทำได้รึเปล่า เพราะเครื่องบางเครื่องมันก็ Overclock ไม่ได้นะครับ
เรื่องที่ทำให้เครื่องเสถียรขึ้นก็เช่นกัน การที่ทาง Google จำเป็นต้องปิด Super user ไว้ไม่ให้เราใช้กันก็เพราะมันจะมีผลกับความเสถียรของเครื่องที่เราใช้อยู่นี่ล่ะครับ ถ้าหากเรามี Super user อยู่ในมือเราก็สามารถแก้ไขตัวระบบได้ แน่นอนว่ามันอาจจะทำให้เครื่องเสถียรขึ้นหรือลดความเสถียรลงก็ได้ เพราะฉะนั้นก่อนการ Root ทำใจเรื่องนี้กันไว้ด้วยนะครับ
ทำไมต้อง Root?
แน่นอนว่าเพื่อทำให้เราสามารถแก้ไขตัวระบบ และเพิ่มความสามารถให้กับตัวระบบของเราได้นั่นเองครับ ลองมาดูตัวอย่างฟังชั่นที่มีประโยชน์ที่เราได้มาหลังจากการ Root กันดีกว่า - การแชร์ไฟล์แบบ NFS ( Network File Sharing ) ด้วย Samba File Sharing การแชร์ไฟล์ลักษณะนี้จะเหมือนกับการแชร์ไฟล์ระหว่าง Windows กับ Windows ผ่าน Wireless เลยล่ะครับ
- การ Fake Legion บน Android Market เนื่องจากแอพฯใน Market บางตัวนั้นจะล้อคเอาไว้สำหรับประเทศของตัวเองเท่านั้น ยกตัวอย่างเช่นประเทศญี่ปุ่นครับ แอพฯเค้าเยอะมาก แต่เราโหลดไม่ได้เพราะเค้าล้อคโซนเอาไว้ ก็ใช้พวก Market Enabler นี่ล่ะครับ Fake Legion ไปโหลดกัน - Overclock CPU อันนี้เอาสะใจครับ เอาไว้ Overclock วัด Quadrant ให้มันดูเยอะเล่นๆไปงั้นเอง สำหรับคนใช้ Galaxy S2 หรืิอ Galaxy Note ที่ใช้ Stock ROM สามารถโหลด Tegrak Overclock มาใช้ได้เลย - Droid Firewall เอาไว้บล้อคอินเตอร์เน็ตเป็นรายแอพฯไป อย่างเช่นผมเห็นว่า Whatsapp มันส่งข้อมูลบ่อยกินแบต หรืออยากจะออฟไลน์ Whatsapp ก็ใช้เจ้าตัวนี้ล่ะครับ
Connect and Pconnect
มีข้อแตกต่างกันอยู่ 2 หลัก คือ
1.mysql_pconnect จะตรวจสอบก่อนทำการเชื่อมต่อฐานข้อมูลก่อนว่ามีการเชิ่อมต่อเดิมอยู่หรือไม่ ถ้ามีก็การเชื่อมต่อเดิมอยู่แล้วจะใช้การการเชื่อมต่อเดิมนั้นแทนโดยไม่ต้องเชื่อมต่อใหม่ทุกครั้งเหมือน mysql_connect
2. การเชิ่อมต่อไปยัง SQL server ด้วย mysql_pconnect จะไม่ปิดลงหลักจากสคริปสิ้นสุดการทำงานแล้ว แต่การเชิ่อมต่อนั้นจะยังคงเปิดไว้ใช้ต่อไป การปิดการเชื่อมต่อด้วย คำสั่ง mysql_close() จะใช้ไม่ได้กับการเชื่อมต่อแบบ mysql_pconnect แต่การเชื่อมต่อแบบ mysql_pconnect จะปิดลงเมื่อมีการปิดบราวเซอร์นั้นๆ ลง
1.mysql_pconnect จะตรวจสอบก่อนทำการเชื่อมต่อฐานข้อมูลก่อนว่ามีการเชิ่อมต่อเดิมอยู่หรือไม่ ถ้ามีก็การเชื่อมต่อเดิมอยู่แล้วจะใช้การการเชื่อมต่อเดิมนั้นแทนโดยไม่ต้องเชื่อมต่อใหม่ทุกครั้งเหมือน mysql_connect
2. การเชิ่อมต่อไปยัง SQL server ด้วย mysql_pconnect จะไม่ปิดลงหลักจากสคริปสิ้นสุดการทำงานแล้ว แต่การเชิ่อมต่อนั้นจะยังคงเปิดไว้ใช้ต่อไป การปิดการเชื่อมต่อด้วย คำสั่ง mysql_close() จะใช้ไม่ได้กับการเชื่อมต่อแบบ mysql_pconnect แต่การเชื่อมต่อแบบ mysql_pconnect จะปิดลงเมื่อมีการปิดบราวเซอร์นั้นๆ ลง
echo คืออะไร
Echo
รูปแบบของฟังก์ชัน echo()
echo (string $arg1 [, string $...])
การพิมพ์ค่าใดๆที่เก็บอยู่ในตัวแปร ถ้าชื่อของตัวแปรอยู่ในสตริงค์ระหว่าง double quote เวลาสร้างเอาพุตแล้ว จะอ่านค่าของตัวแปรนั้นก่อนแล้วจึงแทนที่ลงในข้อความ แต่ถ้านำหน้าด้วย backslash (\) ก็จะไม่มีการอ่านค่าของตัวแปร เช่น “\$a” จะให้ผลต่างจาก “$a”? สังเกตได้จากตัวอย่างต่อไปนี้
Print
คำสั่ง Print จะทำงานเหมือนกับคำสั่ง Echo แต่คำสั่ง Print นั้นสามารถแสดงค่าได้ครั้งหนึ่งค่าเท่านั้น ในขณะที่คำสั่ง Echo สามารถแสดงค่าได้หลาย ๆ ค่า
รูปแบบของฟังก์ชัน Print
ภาษา PHP มีฟังก์ชันมาตรฐานในการแสดงค่า หรือข้อความหลัก ๆ อยู่ 2 ตัวคือ echo() และ print() ความเหมือนกันก็คือเป็นคำสั่งที่ใช้แสดงผลลัพธ์จากโปรแกรมออกมา ส่วนข้อแตกต่างนั้นมีนิดเดียวตรงที่ ฟังก์ชัน print() จะใช้ในการสร้างข้อความให้กับ Text File ได้ด้วย เพราะฉะนั้นหากต้องการสร้าง Text File ด้วย Code ภาษา PHP ท่านต้องใช้ print() ส่วนการแสดงผลออกทางหน้าเว็บจะใช้ echo() หรือ print() ก็ได้ ไม่แตกต่างอะไร
คำสั่ง echo()
หน้าที่
เป็นคำสั่งที่ใช้ในการแสดงผลออกทางหน้าเว็บ
รูปแบบคำสั่ง
แบบที่ 1
echo"ข้อความที่ต้องการแสดง";
แบบที่ 2
echo("ข้อความที่ต้องการแสดง");
ตัวอย่าง
<?php
echo"Hello<br>";
ฟังก์ชันของ PHP
ฟังก์ชันในโปรแกรมส่วนใหญ่ได้รับการเรียกคำสั่งเพื่อทำงานอย่างเดียว สิ่งนี้ทำให้คำสั่งอ่านได้ง่ายและยอมให้ใช้คำสั่งใหม่แต่ละครั้งเมื่อต้อง การทำงานเดียวกัน
ฟังก์ชันเป็นโมดูลเก็บคำสั่งที่กำหนดการเรียกอินเตอร์เฟซ ทำงานเดียวกัน และตัวเลือกส่งออกค่าจากการเรียกฟังก์ชัน คำสั่งต่อไปเป็นการเรียกฟังก์ชันอย่างง่าย
my_function ();
คำสั่งเรียกฟังก์ชันชื่อ my_function ที่ไม่ต้องการพารามิเตอร์ และไม่สนใจค่าที่อาจจะส่งออกโดยฟังก์ชันนี้
ฟังก์ชันจำนวนมากได้รับการเรียกด้วยวิธีนี้ เช่น ฟังก์ชัน phpinfo () สำหรับแสดงเวอร์ชันติดตั้งของ PHP สารสนเทศเกี่ยวกับ PHP การตั้งค่าแม่ข่ายเว็บ ค่าต่างๆ ของ PHP และตัวแปร ฟังก์ชันนี้ไม่ใช้พารามิเตอร์และโดยทั่วไปไม่สนใจค่าส่งออก ดังนั้นการเรียก phpinfo () จะประกอบขึ้นดังนี้
phpinfo ();
การกำหนดฟังก์ชันและการเรียกฟังก์ชัน
การประกาศฟังก์ชันเริ่มต้นด้วยคีย์เวิร์ด function กำหนดชื่อฟังก์ชัน พารามิเตอร์ที่ต้องการ และเก็บคำสั่งที่จะประมวลผลแต่ละครั้งเมื่อเรียกฟังก์ชันนี้
<?php
function function_name(parameter1,…)
{
ชุดคำสั่ง …
}
?>
ชุดคำสั่งต้องเริ่มต้นและสิ้นสุดในวงเล็บปีกกา ({ }) ตัวอย่างฟังก์ชัน my_function
<?php
function my_function()
{
$mystring =<<<BODYSTRING
my function ได้รับการเรียก
BODYSTRING;
echo $mystring;
}
?>
การประกาศฟังก์ชันนี้ เริ่มต้นด้วย function ดังนั้นผู้อ่านและตัวกระจาย PHP ทราบว่าต่อไปเป็นฟังก์ชันกำหนดเอง ชื่อฟังก์ชันคือ my_function การเรียกฟังก์ชันนี้ใช้ประโยคคำสั่งนี้
my_function ();
การเรียกฟังก์ชันนี้จะให้ผลลัพธ์เป็นข้อความ "my function ได้รับการเรียก " บน browser
การตั้งชื่อฟังก์ชัน
สิ่งสำคัญมากในการพิจารณาเมื่อตั้งชื่อฟังก์ชันคือชื่อต้องสั้นแต่ มีความหมาย ถ้าฟังก์ชันสร้างส่วนตัวของเพจควรตั้งชื่อเป็น pageheader () หรือ page_header ()
ข้อจำกัดในการตั้งชื่อคือ
ฟังก์ชันไม่สามารถมีชื่อเดียวกับฟังก์ชันที่มีอยู่
ชื่อฟังก์ชันสามารถมีได้เพียงตัวอักษรตัวเลข และ underscore
ชื่อฟังก์ชันไม่สามารถเริ่มต้นด้วยตัวเลข
หลายภาษายอมให้ใช้ชื่อฟังก์ชันได้อีก ส่วนการทำงานนี้เรียกว่า function overload อย่างไรก็ตาม PHP ไม่สนับสนุน function overload ดังนั้นฟังก์ชันไม่สามารถมีชื่อเดียวกันกับฟังก์ชันภายใน หรือฟังก์ชันกำหนดเองที่มีอยู่
หมายเหตุ ถึงแม้ว่าทุกสคริปต์ PHP รู้จักฟังก์ชันภายในทั้งหมด ฟังก์ชันกำหนดเองอยู่เฉพาะในสคริปต์ที่ประกาศสิ่งนี้หมายความว่า ชื่อฟังก์ชันสามารถใช้ในคนละไฟล์แต่อาจจะไปสู่ความสับสน และควรหลีกเลียง
ชื่อฟังก์ชันต่อไปนี้ถูกต้อง
name ()
name2 ()
name_three ()
_namefour ()
ชื่อไม่ถูกต้อง
5name ()
Name-six ()
fopen ()
การเรียกฟังก์ชันไม่มีผลจากชนิดตัวพิมพ์ ดังนั้นการเรียก function_name (), Function_Name() หรือ FUNCTION_NAME() สามารถทำได้และมีผลลัพธ์เหมือนกัน แต่แบบแผนการกำหนดชื่อฟังก์ชันใน PHP ให้ใช้ตัวพิมพ์เล็ก
ชื่อฟังก์ชันแตกต่างจากชื่อตัวแปร โดยชื่อตัวแปรเป็นชนิดตัวพิมพ์มีผล ดังนั้น $Name และ $name เป็น 2 ตัวแปร แต่ Name () และ name () เป็นฟังก์ชันเดียวกัน
การหยุดประมวลผลภายในฟังก์ชัน
คีย์เวิร์ด return หยุดการประมวลผลฟังก์ชัน ฟังก์ชันสิ้นสุดได้เพราะประโยคคำสั่งทั้งหมดได้รับการประมวลผล หรือ ใช้คีย์เวิร์ด return การประมวลผลกลับไปยังประโยคคำสั่งต่อจากการเรียกฟังก์ชัน
<?php
function division($x, $y)
{
if ($y == 0 || !isset($y))
{
echo " ตัวหาร y ต้องไม่เป็นศูนย์หรือไม่มีค่า" ;
return;
}
$result = $x / $y;
echo $result;
}
?>
ถ้าประโยคคำสั่ง return ได้รับการประมวลผล บรรทัดคำสั่งต่อไปในฟังก์ชันจะถูกข้ามไป และกลับไปยังผู้เรียกฟังก์ชันนี้ ในฟังก์ชันนี้ ถ้า y เป็น 0 จะหยุดการประมวลผล ถ้า y ไม่เท่ากับ 0 จะคำนวณผลหาร
สมมติป้อนค่าเป็น
x = 4, y = 0
x = 4
x = 4, y = 2
ผลลัพธ์ของคำสั่ง คือ
x = 4, y = 0 ผลลัพธ์ ตัวหาร y ต้องไม่เป็นศูนย์หรือไม่มีค่า
x = 4, y = ผลลัพธ์ ตัวหาร y ต้องไม่เป็นศูนย์หรือไม่มีค่า
x = 4, y = 2 ผลลัพธ์ 2
การเรียกฟังก์ชัน
เมื่อฟังก์ชันได้รับการประกาศหรือสร้างขึ้นแล้ว การเรียกฟังก์ชันสามารถเรียกมาจากที่ใดๆ ภายในสคริปต์ หรือ จากไฟล์ที่มีการรวมด้วยประโยคคำสั่ง include() หรือ require()
ตัวอย่าง ฟังก์ชัน show_message() เก็บอยู่ในไฟล์ fn_ 03 _keeper.php ส่วนผู้เรียกอยู่ในสคริปต์ fn_ 03 _caller.php
<?php
include("fn_ 03 _keeper.php");
show_message();
?>
พารามิเตอร์
ตามปกติฟังก์ชันส่วนใหญ่ต้องการรับสารสนเทศจากผู้เรียกสำหรับการประมวลผล โดยทั่วไปเรียกว่า พารามิเตอร์
ไวยากรณ์พื้นฐาน
การกำหนดฟังก์ให้รับพารามิเตอร์ส่งผ่านโดยการวางข้อมูล ชื่อตัวแปรที่เก็บข้อมูลภายในวงเล็บหลังชื่อฟังก์ชัน การเรียกฟังก์ชันที่ประกอบด้วยพารามิเตอร์เขียนดังนี้
<?php
function show_parameter($param1, $param2, $param3)
{
echo <<<PARAM
รายการพารามิเตอร์ <br/>
param1: $param1 <br/>
param2: $param2 <br/>
param3: $param3 <br/>
PARAM;
}
?>
พารามิเตอร์ที่ส่งไปยังฟังก์ชันแยกกันเครื่องหมายจุลภาคภายในวง เล็บ โดยสามารถส่งเป็นนิพจน์สำหรับแต่ละพารามิเตอร์ด้วย ตัวแปร ค่าคงที่ ผลลัพธ์จากการคำนวณ รวมถึงการเรียกฟังก์ชัน
scope ของพารามิเตอร์จำกัดภายในฟังก์ชัน ถ้าชื่อตัวแปรเหมือนกับตัวแปรใน scope ระดับอื่น พารามิเตอร์นี้ "ระบุ" เป็นตัวแปรภายในที่ไม่มีผลกับตัวแปรภายนอกฟังก์ชัน
การส่งผ่านโดยค่า(By Value)
ตามปกติการส่งผ่านพารามิเตอร์ไปยังฟังก์ชันเป็นการส่งผ่านค่า การเปลี่ยนแปลงจะจำกัดภายในเฉพาะภายในฟังก์ชัน
ตัวอย่างฟังก์ชัน new_value () ที่ยอมให้เพิ่มค่า อาจจะเขียนคำสั่งดังนี้
<?php
function new_value($value, $increment= 1)
{
$value = $value + $increment;
}
$value = 10 ;
new_value($value);
echo "$value<br/>\n";
?>
คำสั่งนี้ใช้ไม่ได้ ผลลัพธ์จะเป็น "10" ค่าใหม่ของ $value ไม่มีการเปลี่ยนแปลง
สิ่งนี้เป็นเพราะกฎ scope คำสั่งนี้สร้างตัวแปรเรียกว่า $value เป็น 10 เมื่อเรียกฟังก์ชัน new_value () ตัวแปร $value ในฟังก์ชันได้รับการสร้างเมื่อเรียกฟังก์ชัน ค่า 1 ได้รับการเพิ่มให้กับตัวแปร ดังนั้นค่าของ $value คือ 11 ภายในฟังก์ชัน จนกระทั่งสิ้นสุดฟังก์ชัน แล้วกลับไปยังคำสั่งที่เรียกภายในคำสั่งนี้ ตัวแปร $value เป็นอีกตัวแปร global scope และไม่มีการเปลี่ยนแปลง
การส่งผ่านโดยการอ้างอิง (By Reference)
ตามตัวอย่างฟังก์ชัน new_value ถ้าต้องการให้ฟังก์ชันเปลี่ยนแปลงค่าได้ มีวิธีหนึ่งในการแก้ไขคือ ประกาศ $value ในฟังก์ชันเป็น global แต่หมายความว่าในการใช้ฟังก์ชันนี้ ตัวแปรที่ต้องการเพิ่มค่าต้องตั้งชื่อเป็น $value แต่มีวิธีดีกว่าคือ ใช้การส่งผ่านโดยการอ้างอิง
การอ้างอิงไปตัวแปรต้นทางแทนที่มีค่าของตัวเอง การปรับปรุงไปยังการอ้างอิงจะมีผลกับตัวแปรต้นทางด้วย
การระบุพารามิเตอร์ที่ใช้การส่งผ่านโดยการอ้างอิงให้วาง ampersand (&) หน้าชื่อพารามิเตอร์ในข้อกำหนดฟังก์ชัน
ตัวอย่าง new_value () ได้รับปรับปรุงให้มี 1 พารามิเตอร์ส่งผ่านโดยการอ้างอิงและทำงานได้อย่างถูกต้อง
<?php
function new_value(&$value, $increment=1)
{
$value = $value + $increment;
}
?>
คำสั่งทดสอบฟังก์ชัน ให้พิมพ์ 10 ก่อนการเรียก increment () และ 11 ภายหลัง
ในการส่งค่าโดยการอ้างอิงต้องส่งเป็นตัวแปรไม่สามารถกำหนดค่าคงที่โดยตรง
จำนวนตัวแปรของพารามิเตอร์
การส่งผ่านพารามิเตอร์ไปยังฟังก์ชันนั้น การควบคุมของ PHP ได้กำหนดฟังก์ชันจำนวนหนึ่งให้ยอมรับจำนวนตัวแปรของพารามิเตอร์ ได้แก่ func_num_args, func_get_arg และ func_get_args
func_num_args() บอกจำนวนพารามิเตอร์ไปยังฟังก์ชันที่เรียก func_get_arg() แสดงค่าของพารามิเตอร์ตามดัชนี และ func_get_args() ส่งออก array ของพารามิเตอร์
<?php
function show_pass_value()
{
$idx = count(func_get_args());
echo " จำนวนพารามิเตอร์ $idx <br/>\n";
if ($idx > 0)
echo ">> ใช้ฟังก์ชัน func_get_arg<br/>\n";
for ($i = 0 ; $i < $idx; $i++)
{
echo " พารามิเตอร์ที่ $i ค่า: ". func_get_arg($i)."<br/>\n";
}
if ($idx > 0)
echo ">> ใช้ฟังก์ชัน func_get_args<br/>\n";
$params = func_get_args();
foreach ($params as $index => $val)
{
echo " พารามิเตอร์ที่ $index ค่า: $val<br/>\n";
}
echo " *********<br/>\n";
}
$x = 4 ;
show_pass_value("one", "two", 3 , $x, " ห้า" , " หก") ;
show_pass_value();
?>
ผลลัพธ์
จำนวนพารามิเตอร์ 6
>> ใช้ฟังก์ชัน func_get_arg
พารามิเตอร์ที่ 0 ค่า: one
พารามิเตอร์ที่ 1 ค่า: two
พารามิเตอร์ที่ 2 ค่า: 3
พารามิเตอร์ที่ 3 ค่า: 4
พารามิเตอร์ที่ 4 ค่า: ห้า
พารามิเตอร์ที่ 5 ค่า: หก
>> ใช้ฟังก์ชัน func_get_args
พารามิเตอร์ที่ 0 ค่า: one
พารามิเตอร์ที่ 1 ค่า: two
พารามิเตอร์ที่ 2 ค่า: 3
พารามิเตอร์ที่ 3 ค่า: 4
พารามิเตอร์ที่ 4 ค่า: ห้า
พารามิเตอร์ที่ 5 ค่า: หก
*********
จำนวนพารามิเตอร์ 0
*********
Scope
เมื่อต้องการใช้ตัวแปรภายในไฟล์ที่รวม ต้องมีการประกาศตัวแปรเหล่านั้นก่อนประโยคคำสั่ง require () หรือ include () แต่เมื่อใช้ฟังก์ชันจะเป็นการส่งผ่านตัวแปรเชิงประจักษ์เหล่านั้นไปยัง ฟังก์ชัน บางส่วนเป็นเพราะไม่มีกลไกส่งผ่านตัวแปรเชิงประจักษ์ไปยังไฟล์ที่รวม และบางส่วนเป็นเพราะ scope ของตัวแปรของฟังก์ชันแตกต่างกัน
การควบคุม scope ของตัวแปรเป็นการทำให้ตัวแปรมองเห็นได้ ใน PHP มีกฎตั้งค่า scope ดังนี้
การประกาศตัวแปรภายในฟังก์ชันอยู่ใน scope จากประโยคคำสั่งซึ่งตัวแปรให้รับการประกาศภายในวงเล็บปีกกา สิ่งนี้เรียกว่า function scope ตัวแปรเรียกว่า local variable
การประกาศตัวแปรภายนอกฟังก์ชันอยู่ใน scope จากประโยคคำสั่งซึ่งตัวแปรได้รับการประกาศที่สิ้นสุดแต่ไม่ใช้ภายในฟังก์ชัน สิ่งนี้เรียกว่า global scope ตัวแปรเรียกว่า global variable
การใช้ประโยคคำสั่ง require () และ include () ไม่มีผลกับ scope ถ้าประโยคคำสั่งได้รับการใช้ภายในฟังก์ชัน ประยุกต์ด้วย function scope ถ้าไม่ได้อยู่ภายในฟังก์ชัน ประยุกต์ด้วย global scope
คีย์เวิร์ด global สามารถระบุได้เองเพื่อกำหนดหรือใช้ตัวแปรภายในฟังก์ชันให้มี scope เป็น global
ตัวแปร สามารถลบโดยการเรียก unset ($variable_name) และตัวแปรที่ unset จะไม่มี scope
ตัวแปรระดับ superglobal สามารถเข้าถึงได้ทุกส่วนในสคริปต์
ตัวแปรระดับฟังก์ชัน
ตัวแปรระดับฟังก์ชันหรือ local variable เป็นการประกาศเพื่อใช้เฉพาะภายในฟังก์ชัน ไม่สามารถเรียกจากภายนอกฟังก์ชันได้
<?php
$newline = <<<NLSTRING
<br/>\n
NLSTRING;
$var_global = 10 ;
function show_value()
{
global $newline;
$var_local= 75 ;
echo "\$var_local 1: $var_local";
echo $newline;
}
show_value();
echo "\$var_global : $var_global";
echo $newline;
echo "\$var_local 2: $var_local";
echo $newline;
?>
ผลลัพธ์
$var_global 1 :
$var_local 1: 75
$var_global 2: 10
$var_local 2:
ตามตัวอย่างนี้ ตัวแปรระดับฟังก์ชัน $var_local ไม่สามารถแสดงผลในการพิมพ์ภายนอกฟังก์ชัน show_value() และ $var_global ที่เป็นตัวแปรระดับ global ไม่สามารถแสดงผลภายใน show_value() เพราะมี scope ต่างกัน
ตัวแปรระดับ global
ถ้าต้องการนำตัวแปรระดับ global มาใช้ภายในฟังก์ชันต้องประกาศด้วยคีย์เวิร์ด global ก่อนประโยคคำสั่งที่ใช้ตัวแปรนั้น ตัวอย่าง ฟังก์ชัน show_value() ใช้ $newline จากภายนอกฟังก์ชัน
global $newline;
ตัวแปรสถิตย์
การประกาศตัวแปรสถิตย์ใช้ คีย์เวิร์ด static เมื่อมีการเรียกใช้ฟังก์ชัน โปรแกรมจะกำหนดค่าตัวแปรตามที่ระบุเพียงครั้งเดียว ถ้าเรียกซ้ำอย่างต่อเนื่องค่านี้จะเปลี่ยนแปลงตามการคำนวณ
<?php
function increment()
{
static $increase = 5 ;
$increase++;
echo $increase."<br/>\n";
}
$end = 5 ;
for ($i = 1 ; $i < $end; $i++)
increment();
?>
ผลลัพธ์
6
7
8
9
ค่าของตัวแปรสถิตย์ได้รับการตั้งทุกครั้งเมื่อเรียกใช้ในครั้งต่อไป
การส่งออกค่าจากฟังก์ชัน
การส่งค่าออกจากฟังก์ชันใช้คีย์เวิร์ด return เช่นเดียวกับการออกจากฟังก์ชันได้ ถ้าไม่มีการระบุส่งออกฟังก์ชันจะส่งค่า NULL
ตัวอย่าง ฟังก์ชัน get_larger () สาธิตการส่งออกค่า
<?
function get_larger($x=NULL, $y=NULL)
{
if (!isset($x) || !isset($y))
return " ไม่มีการส่งค่า" ;
if ($x > $y)
return $x;
else if ($x < $y)
return $y;
else
return " ค่าเท่ากัน" ;
}
$sends = array();
$sends[0] = array('x' =>5);
$sends[1] = array('x' =>9, 'y'=>3);
$sends[2] = array('x' =>5, 'y'=>8);
$sends[3] = array('x' =>4, 'y'=>4);
foreach ($sends as $send)
{
echo "x = ".$send['x']." y = ".$send['y']." : ค่า - > "
.get_larger($send['x'], $send['y']);
echo "<br/>\n";
}
?>
ผลลัพธ์
x = 5 y = : ค่า - > ไม่มีการส่งค่า
x = 9 y = 3 : ค่า - > 9
x = 5 y = 8 : ค่า - > 8
x = 4 y = 4 : ค่า - > ค่าเท่ากัน
ฟังก์ชันที่ทำงานอาจเดียว แต่ไม่จำเป็นต้องส่งออกค่า มักจะส่งออก TRUE หรือ FALSE เพื่อระบุความสำเร็จหรือล้มเหลว ค่า TRUE หรือ FALSE สามารถได้รับการแสดงแทนด้วย 1 หรือ 0
Recursion
recursion ได้รับการสนับสนุนใน PHP ฟังก์ชันชนิดนี้เป็นการเรียกตัวเองและเป็นประโยชน์กับการบังคับโครงสร้าง ข้อมูลไดนามิคส์ เช่น รายการเชื่อมโยงและโครงสร้างต้นไม้ (tree)
โปรแกรมประยุกต์เว็บจำนวนไม่มากต้องการโครงสร้างข้อมูลซับซ้อนมาก และจำกัดการใช้ เนื่องจาก recursion ช้ากว่าและใช้หน่วยความจำมากกว่าการทำงานวนรอบ ดังนั้นควรเลือกการทำงานแบบวนรอบปกติ ถ้าเป็นไปได้
ตัวอย่างการประยุกต์แบบย้อนกลับตัวอักษร
<?php
function word_reverse_r($str)
{
if (strlen($str)>0)
word_reverse_r(substr($str, 1));
echo substr($str, 0, 1);
return;
}
function word_reverse_i($str)
{
for ($i=1; $i<=strlen($str); $i++)
{
echo substr($str, -$i, 1);
}
return;
}
?>
รายการคำสั่งของ 2 ฟังก์ชันนี้จะพิมพ์ข้อความย้อนกลับ ฟังก์ชัน word_reverse_r เป็น recursion ฟังก์ชัน word_reverse_i เป็นการวนรอบ
ฟังก์ชัน word_reverse_r ใช้ข้อความเป็นพารามิเตอร์ เมื่อมีการเรียกฟังก์ชันนี้ จะเกิดการเรียกตัวเองแต่ละครั้งส่งผ่านตัวอักษรที่ 2 ไปถึงตัวอักษรสุดท้าย
การเรียกฟังก์ชันแต่ละครั้งจะทำสำเนาใหม่ของคำสั่งในหน่วยความจำ ของแม่ข่าย แต่ด้วยพารามิเตอร์ต่างกัน ดังนั้นจึงเหมือนกับการเรียกคนละฟังก์ชัน
วันพุธที่ 5 พฤศจิกายน พ.ศ. 2557
หน่วยรับข้อมูล
หน่วยรับข้อมูล (Input Unit)
หน่วยรับข้อมูล (Input Unit) ฮาร์ดแวร์ที่ทำหน้าที่เป็นหน่วยรับข้อมูลมีหลากหลายอุปกรณ์ ได้แก่
1) คีย์บอร์ด (Keyboard)
อุปกรณ์รับข้อมูลจากการกดแป้นแล้วทำการเปลี่ยนเป็นรหัส เพื่อบอกให้คอมพิวเตอร์รู้ว่ามีการกดตัวอักษรอะไร แผงแป้นอักขระส่วนใหญ่เป็นไปตามมาตรฐานของเครื่องพิมพ์ดีด ซึ่งระบบรับรหัสตัวอักขระที่ใช้ในทางคอมพิวเตอร์เป็นรหัส 7 หรือ 8 บิต (Operator)
|
2) เมาส์ (Mouse) |
| -แบบทางกล (Mechanical) ใช้ลูกกลิ้งกลม |
| -แบบใช้แสง (Optical mouse) |
| -แบบไร้สาย (Wireless Mouse) |
3) OCR (Optical Character Reader) |
4) OMR (Optical Mark Reader) |
| 5) เครื่องอ่านพิกัด (Digitizer) เป็นอุปกรณ์รับข้อมูล มีลักษณะเป็นแผ่นกระดานสี่เหลี่ยม มีสายไฟฟ้าและอุปกรณ์คล้ายแว่นขยายที่มีเครื่องหมายกากบาทตรงกลาง พร้อมกับปุ่มสำหรับกด โดยปกติมักใช้ในการอ่านจุดพิกัดของแผนที่ หรือตำแหน่งของภาพกราฟิกต่างๆ |
6) สแกนเนอร์ (Scanner) |
| แบบเลื่อนกระดาษ (Sheet-Fed Scanner) สแกนเนอร์แบบนี้จะรับกระดาษแล้วค่อย ๆ เลื่อนหน้ากระดาษให้ผ่านหัวสแกนซึ่งอยู่กับที่ |
| แบบแท่นนอน (Flatbed scanner) สแกนเนอร์แบบนี้จะมีกลไกคล้ายกับเครื่องถ่ายเอกสาร เหมาะสำหรับใช้กับเอกสารทั้งที่เป็นแผ่นเดียวและเอกสารที่เป็นเล่ม |
| แบบมือถือ (Hand-held Scanner) สแกนเนอร์แบบมือถือได้รวมเอาข้อดีของสแกนเนอร์ ทั้งสองแบบเข้าไว้ด้วยกัน |
7) ปากกาแสง (Light Pen) |
| 8) จอยสติก (Joy Sticks) เป็นอุปกรณ์ที่ใช้ในการควบคุมทิศทางของวัตถุบนหน้าจอคอมพิวเตอร์ ส่วนใหญ่จะใช้ในการเล่นเกมคอมพิวเตอร์ มีทั้งที่เป็นแบบแบน แบบคันโยก หรือ แบบพวงมาลัย |
9) จอสัมผัส (Touch Screen) |
10) เครื่องเทอร์มินัล (Point of Sale Terminal) |
11) แผ่นสัมผัส (Touch Pads) |
12) กล้องดิจิทัล (Digital Camera) |
13) อุปกรณ์รับข้อมูลเสียง (Voice Input Devices)หรือเรียกอีกอย่างหนึ่งว่า ไมโครโฟน
 |
วันเสาร์ที่ 1 พฤศจิกายน พ.ศ. 2557
Php myadmin
|
 การเริ่มต้นใช้งาน phpMyAdminการเข้าใช้งานโปรแกรม phpMyAdmin จะใช้งานผ่านโปรแกรม Web Browser เช่น Internet Explorer และพิมพ์ URL ไปยังไดเรกทอรีของ phpMyAdmin เป็น http://pontus2.csloxinfo.com เป็นต้น ซึ่งหน้าจอแรกในการใช้งาน แสดงดังรูปที่ 1 |
รูปที่ 1 หน้าจอแรกของโปรแกรม phpMyAdmin
 |
| จากรูปที่ 1 จะเห็นได้ว่าโปรแกรมได้แบ่งส่วนของการแสดงผลออกเป็น 2 ส่วน คือ ส่วนซ้าย (เลข 1) และ ส่วนขวา (เลข 2, 3) ซึ่งจะอธิบายได้ดังนี้ หมายเลข 1 ใช้สำหรับ เลือก/เปลี่ยน จัดการกับฐานข้อมูลเดิมที่มีอยู่แล้วซึ่งทาง csloxinfo จะทำการสร้างฐานข้อมูลให้กับลูกค้า 1 ฐานข้อมูลเท่านั้น หมายเลข 2 สำหรับใส่ชื่อฐานข้อมูลที่ต้องการสร้างใหม่ หมายเลข 3 สำหรับเลือกภาษาที่ต้องการให้แสดงภายในโปรแกรม phpMyAdmin |
| การสร้างฐานข้อมูลใหม่ ก่อนที่จะเก็บข้อมูลลงใน MySQL จะต้องเลือกเสียก่อนว่า จะสร้างฐานข้อมูลชื่ออะไร จากนั้น จึงทำการสร้างตาราง และ ฟิลด์ เพื่อบันทึกข้อมูล ในอันดับแรกจะเป็นการทดลองสร้างฐาน ข้อมูลขึ้นมา ใหม่ โดยจะยกตัวอย่างฐานข้อมูลเกี่ยวกับสินค้า ซึ่งมีชื่อฐานข้อมูลว่า “product” ดังรูปที่ 2 |
รูปที่ 2 สร้างฐานข้อมูลใหม่ชื่อ product
|
| จากรูปที่ 2 อธิบายขั้นตอนการสร้างฐานข้อมูลใหม่ตามลำดับ ได้ดังนี้ 1. ใส่ชื่อของฐานข้อมูลที่ต้องการสร้าง ในที่นี้ให้ชื่อว่า product 2. คลิกที่ปุ่ม สร้าง เพื่อสร้างฐานข้อมูล |
| การสร้างตารางใหม่ ภายหลังจากที่สร้างฐานข้อมูลเรียบร้อยแล้ว phpMyAdmin จะแจ้งให้เราทราบว่า ได้ทำการ สร้างฐานข้อมูล product เรียบร้อยแล้ว และท่านใช้งานฐานข้อมูล product อยู่ ยังไม่มีตาราง ใดๆ อยู่เลยในที่นี้จะสร้างตารางสำหรับเก็บข้อมูลสินค้า โดยรายละเอียดในตารางจะมี 3 ฟิลด์ ดังนี้ - name ชื่อสินค้า - cost ราคาสินค้า - quan จำนวนสินค้า (ย่อมาจาก quantity แต่เขียนให้ง่ายและสั้นขึ้น) ทำการสร้างตารางใหม่ โดยมีขั้นตอนดังนี้ 1. ใส่ชื่อตารางที่ต้องการสร้าง 2. ใส่จำนวนฟิลด์ของตาราง สำหรับตาราง stock จะมีจำนวน 3 ฟิลด์ 3. คลิกปุ่ม ลงมือ เพื่อดำเนินการขั้นต่อไป |
รูปที่ 3 การสร้างตาราง
|
| ขั้นตอนต่อไป ภายหลังจากคลิกปุ่ม ลงมือในขั้นตอนก่อนหน้า จะเป็นการกำหนด ชื่อฟิลด์ ชนิดของข้อมูลที่เก็บ และรายละเอียดอื่นๆ ซึ่งจะอธิบายในส่วนต่างๆ ได้ดังนี้ - ฟิลด์ สำหรับใส่ชื่อฟิลด์ - ชนิด สำหรับเลือกชนิดของข้อมูลที่ต้องการเก็บในฟิลด์นั้น- ความยาว/เซต สำหรับกำหนด ขนาดของข้อมูล - แอตทริบิวต์ สำหรับเลือกลักษณะเฉพาะของข้อมูลที่จะเก็บ เช่น ตัวเลขแบบคิด เครื่องหมาย บวกหรือลบ เป็นต้น - ค่าว่าเปล่า (null) สำหรับเลือกว่า ฟิลด์นั้นสามารถใส่ค่าว่างได้หรือไม่ - ค่าปริยาย สำหรับกำหนดค่าเริ่มต้นของฟิลด์ (ค่า Default) - เพิ่มเติม สำหรับกำหนดค่าเพิ่มเติม เช่น กรณีที่ฟิลด์เก็บข้อมูลตัวเลขจำนวนเต็ม (Integer) จะสามารถเลือกให้มีการเพิ่มค่าอัตโนมัติ (auto_increment) ได้ เป็นต้น - ไพรมารี เลือกเมื่อต้องการกำหนดให้ฟิลด์นั้นๆ เป็นไพรมารีคีย์ (Primary Key) - ดัชนี เลือกเมื่อต้องการสร้างฟิลด์นั้นๆ เป็นดัชนี (Index) - เอกลักษณ์ เลือกเมื่อต้องการให้ฟิลด์นั้นเป็น Unique |
| คำอธิบายของชนิดข้อมูลแต่ละชนิดที่สามารถเลือกได้ VARCHAR : สำหรับเก็บข้อมูลประเภทตัวอักษร ทุกครั้งที่เลือกชนิดของฟิลด์เป็นประเภทนี้ จะต้องมี การกำหนดความยาวของข้อมูลลงไปด้วย ซึ่งสามารถกำหนดค่าได้ตั้งแต่ 1 - 255 ฟิลด์ชนิดนี้ เหมาะสำหรับการเก็บข้อมูลสั้นๆ เช่น ชื่อ นามสกุล หรือหัวข้อต่างๆ เป็นต้น... ในส่วนฟิลด์ประเภทนี้จะสามารถเลือก "แอตทริบิวต์" เป็น BINARY ได้ โดยปกติแล้วการจัดเรียง ข้อมูลเวลาสืบค้น (query) สำหรับ VARCHAR จะเป็นแบบ case-sensitive (ตัวอักษรใหญ่ และเล็กมีความหมายแตกต่างกัน) แต่ หากระบุ "แอตทริบิวต์" เป็น BINARY ปุ๊บ การสืบค้นจะไม่คำนึงตัวอักษรว่าจะเป็นตัวใหญ่หรือ ตัวเล็ก CHAR : สำหรับเก็บข้อมูลประเภทตัวอักษร แบบที่ถูกจำกัดความกว้างเอาไว้คือ 255 ตัวอักษร ไม่สามารถปรับเปลี่ยนได้เหมือนกับ VARCHAR หากทำการสืบค้นโดยเรียงตามลำดับ ก็จะเรียง ข้อมูลแบบ case-sensitive เว้นแต่จะกำหนดแอตทริบิวต์เป็น BINARY ที่จะทำให้การเรียงข้อมูล เป็นแบบ non case-sensitive เช่นเดียวกับ VARCHAR TINYTEXT : ในกรณีที่ข้อความยาวๆ หรือต้องการที่จะค้นหาข้อความ โดยอาศัยฟีเจอร์ FULL TEXT SEARCH ของ MySQL เราอาจจะเลือกที่จะไม่เก็บข้อมูลลงในฟิลด์ประเภท VARCHAR ที่มีข้อจำกัดแค่ 256 ตัวอักษร แต่เราจะเก็บลงฟิลด์ประเภท TEXT แทน โดย TINYTEXT นี้จะ สามารถเก็บข้อมูล ได้ 256 ตัวอักษร ซึ่งมองเผินๆ ก็ไม่ต่างกับเก็บลงฟิลด์ประเภท CHAR หรือ VARCHAR(255) เลย แต่จริงๆ มันต่างกันตรงที่ มันทำFULL TEXT SEARCH ได้ TEXT : สำหรับเก็บข้อมูลประเภทตัวอักษร เช่นเดียวกับ TINYTEXT แต่สามารถเก็บได้มาก ขึ้นโดยสูงสุดคือ 65,535 ตัวอักษร หรือ 64KB เหมาะสำหรับเก็บข้อมูลพวกเนื้อหาต่างๆ ที่ยาวๆ MEDIUMTEXT เก็บข้อมูลประเภทตัวอักษร เช่นเดียวกับ TINYTEXT แต่เก็บข้อมูลได้ 16,777,215 ตัวอักษร LONGTEXT : เก็บข้อมูลประเภทตัวอักษร เช่นเดียวกับ TINYTEXT แต่เก็บข้อมูลได้ 4,294,967,295 ตัวอักษร TINYINT : สำหรับเก็บข้อมูลชนิดตัวเลขที่มีขนาด 8 บิต ข้อมูลประเภทนี้เราสามารถกำหนด เพิ่มเติม ในส่วนของ "แอตทริบิวต์" ได้ว่าจะเลือกเป็น UNSIGNED หรือ UNSIGNED ZEROFILL โดยจะมีความแตกต่างดังนี้ UNSIGNED : จะหมายถึงเก็บค่าตัวเลขแบบไม่มีเครื่องหมาย แบบนี้จะทำใหสามารถเก็บค่าได้ ตั้งแต่ 0 - 255 UNSIGNED ZEROFILL : เหมือนข้างต้น แต่ว่าหากข้อมูลที่กรอกเข้ามาไม่ครบตามจำนวน หลัก ที่เรากำหนด ตัว MySQL จะทำการเติม 0 ให้ครบหลักเอง เช่น ถ้ากำหนดให้ใส่ได้ 3 หลัก แล้ว ทำการเก็บข้อมูล 25 เข้าไป เวลาที่สืบค้นดู เราจะได้ค่าออกมาเป็น 025 หากไม่เลือก "แอ ตทริบิวต์" สิ่งที่เราจะ ได้ก็คือSIGNED นั่นก็คือต้องเสียบิตนึงไปเก็บเครื่องหมาย บวก/ลบ ทำ ให้สามารถเก็บข้อมูลได้ อยู่ในช่วง -128ถึง 127 เท่านั้น SMALLINT : สำหรับเก็บข้อมูลประเภทตัวเลขที่มีขนาด 16 บิต จึงสามารถเก็บค่าได้ตั้งแต่ -32768 ถึง 32767 (ในกรณีแบบคิดเครื่องหมาย) หรือ 0 ถึง 65535 (ในกรณี UNSIGNED หรือไม่ คิดเครื่องหมาย)ซึ่งสามารถเลือก Attribute เป็น UNSIGNED และ UNSIGNED ZEROFILL ได้เช่นเดียวกับ TINYINT MEDIUMINT : สำหรับเก็บข้อมูลประเภทตัวเลขที่มีขนาด 24 บิต นั่นก็หมายความว่าสามารถเก็บ ข้อมูล ตัวเลขได้ตั้งแต่ -8388608 ไปจนถึง 8388607 (ในกรณีแบบคิดเครื่องหมาย) หรือ 0 ถึง 16777215 (ในกรณีที่เป็น UNSIGNED หรือไม่คิดเครื่องหมาย) ซึ่งสามารถเลือก Attribute เป็น UNSIGNED และ UNSIGNED ZEROFILL ได้เช่นเดียวกับ TINYINT INT : สำหรับเก็บข้อมูลประเภทตัวเลขที่มีขนาด 32 บิต หรือสามารถเก็บข้อมูลได้ตั้งแต่ -2147483648 ไปจนถึง 2147483647 ครับ (ในกรณีแบบคิดเครื่องหมาย) หรือ 0 ถึง 4294967295 (ในกรณีที่เป็นUNSIGNED หรือไม่คิดเครื่องหมาย) ซึ่งสามารถเลือก Attribute เป็น UNSIGNED และ UNSIGNED ZEROFILL ได้เช่นเดียวกับ TINYINT BIGINT : สำหรับเก็บข้อมูลประเภทตัวเลขที่มีขนาด 64 บิต สามารถเก็บข้อมูลได้ตั้งแต่ - 9223372036854775808 ไปจนถึง 9223372036854775807 เลยทีเดียว (แบบคิดเครื่องหมาย) หรือ 0 ถึง 18446744073709551615 (ในกรณีที่เป็น UNSIGNED หรือไม่คิด เครื่องหมาย) ซึ่งสามารถเลือก Attribute เป็น UNSIGNED และ UNSIGNED ZEROFILL ได้เช่น เดียวกับ TINYINT FLOAT[(M,D)] : ที่กล่าวถึงไปทั้งหมด ในตระกูล INT นั้นจะเป็นเลขจำนวนเต็ม หากเราบันทึกข้อมูล ที่มีเศษทศนิยม มันจะถูกปัดทันที ดังนั้นหากต้องการจะเก็บค่าที่เป็นเลขทศนิยม ต้องเลือกชนิดขอฟิลด์ เป็น FLOAT โดยจะเก็บข้อมูลแบบ 32 บิต คือมีค่าตั้งแต่ -3.402823466E+38 ไปจนถึง -1.175494351E- 38, 0 และ 1.175494351E-38 ถึง 3.402823466E+38 DOUBLE[(M,D)] : สำหรับเก็บข้อมูลประเภทตัวเลขทศนิยม เช่นเดียวกับ FLOAT แต่มีขนาดเป็น 64 บิต สามารถเก็บได้ตั้งแต่ -1.7976931348623157E+308 ถึง -2.2250738585072014E-308, 0 และ 2.2250738585072014E-308 ถึง 1.7976931348623157E+308 DECIMAL[(M,D)] : สำหรับเก็บข้อมูลประเภทตัวเลขทศนิยม เช่นเดียวกับ FLOAT แต่ใช้กับข้อมูลที่ ต้องการความละเอียดและถูกต้องของข้อมูลสูง ข้อสังเกต เกี่ยวกับข้อมูลประเภท FLOAT, DOUBLE และ DECIMAL ก็คือ เวลากำหนดความ ยาวของข้อมูลในฟิลด์ จะถูกกำหนดอยู่ในรูปแบบ (M,D) ซึ่งหมายความว่า ต้องมีการระบุว่า จะให้มี ตัวเลขส่วนที่เป็นจำนวนเต็มกี่หลัก และมีเลขทศนิยมกี่หลัก เช่น ถ้าเรากำหนดว่า FLOAT(5,2) จะ หมายความว่า เราจะเก็บข้อมูลเป็นตัวเลขจำนวนเต็ม 5 หลัก และทศนิยม 2 หลัก ดังนั้นหากทำการใส่ ข้อมูล 12345.6789 เข้าไป สิ่งที่จะเข้าไปอยู่ในข้อมูลจริงๆ ก็คือ 12345.68 (ปัดเศษให้มีจำนวนหลัก ตามที่กำหนดไว้) DATE : สำหรับเก็บข้อมูลประเภทวันที่ โดยเก็บได้จาก 1 มกราคม ค.ศ. 1000 ถึง 31 ธันวาคม ค.ศ. 9999 โดยจะแสดงผลในรูปแบบ YYYY-MM-DD DATETIME : สำหรับเก็บข้อมูลประเภทวันที่ และเวลา โดยจะเก็บได้ตั้งแต่ 1 มกราคม ค.ศ. 1000 เวลา 00:00:00 ไปจนถึง 31 ธันวาคม ค.ศ. 9999 เวลา 23:59:59 โดยรูปแบบการแสดงผล เวลาที่ทำการสืบค้น (query) ออกมา จะเป็น YYYY-MM-DD HH:MM:SS TIMESTAMP[(M)] : สำหรับเก็บข้อมูลประเภท วันที่ และเวลาเช่นกัน แต่จะเก็บในรูปแบบของ YYYYMMDDHHMMSS หรือ YMMDDHHMMSS หรือ YYYYMMDD หรือ YYMMDD แล้วแต่ ว่าจะระบุค่า M เป็น 14, 12, 8 หรือ 6 ตามลำดับ สามารถ เก็บได้ตั้งแต่วันที่ 1 มกราคม ค.ศ. 1000 ไป จนถึงประมาณปี ค.ศ. 2037 TIME : สำหรับเก็บข้อมูล ประเภทเวลา มีค่าได้ตั้งแต่ -838:59:59 ไปจนถึง 838:59:59 โดยจะแสดงผล ออกมาในรูปแบบ HH:MM: SS YEAR[(2/4)] : สำหรับเก็บข้อมูลประเภทปี ในรูปแบบ YYYY หรือ YY แล้วแต่ว่าจะเลือก 2 หรือ 4 (หากไม่ระบุ จะถือว่าเป็น 4 หลัก) โดยหากเลือกเป็น 4 หลัก จะเก็บค่าได้ตั้งแต่ ค.ศ. 1901 ถึง 2155 แต่ หากเป็น 2 หลัก จะเก็บตั้งแต่ ค.ศ. 1970 ถึง 2069 ข้อสังเกต ค่าที่เก็บในข้อมูลประเภท TIMESTAMP และ YEAR นั้นจะมีความสามารถพอๆ กับ การเก็บข้อมูลวันเดือนปี และเวลา ด้วยฟิลด์ชนิด VARCHAR แต่ต่างกันตรงที่ จะใช้เนื้อที่เก็บข้อมูล น้อยกว่า... ทว่า ฟิลด์ประเภท TIMESTAMP นั้นจะมีข้อจำกัดใน เรื่องของเวลาที่สามารถเก็บได้ คือ จะต้องอยู่ในระหว่าง 1 มกราคม ค.ศ. 1000 ไปจนถึงแถวๆ ค.ศ. 2037 อย่างที่บอก แต่หากเก็บเป็น VARCHAR นั้นจะไม่ติดข้อจำกัดนี้ ฟิลด์ชนิด YEAR ก็เช่นกันครับ... ใช้เนื้อที่แค่ 1 ไบต์เท่านั้นในการ เก็บข้อมูล แต่ข้อจำกัดจะอยู่ที่ ปี ค.ศ. 1901 ถึง 2155 เท่านั้น (หรือ ค.ศ. 1970 ถึง 2069 ในกรณี 2 หลัก) แต่หากเก็บเป็น VARCHAR จะได้ตั้งแต่ 0000 ถึง 9999 เลย อันนี้เลยอยู่ที่ความจำเป็นมากกว่าครับ (แต่ ด้วยความที่ว่า ปัจจุบันฮาร์ดดิสก์ราคาถูกมากๆ ผมเลย ไม่ติดใจอะไรที่จะใช้ VARCHAR แทน เพื่อ ความสบายใจ อิอิ เพราะสมมติว่ากินเนื้อที่ต่างกัน 3 ไบต์ ต่อ 1 ระเบียน มีข้อมูล 4 ล้านระเบียน ก็เพิ่ง ต่างกัน 12 ล้านไบต์ หรือ 12 เมกะไบต์เท่านั้นเอง ซึ่งหาก เทียบกับปริมาณข้อมูลทั้งหมดของข้อมูล 4 ล้านระเบียน ผมว่ามันต้องมีอย่างน้อยเป็นกิกะไบต์ ดังนั้น ความแตกต่างที่ไม่กี่เมกะไบต์จึงไม่มากมาย) TINYBLOB : สำหรับเก็บข้อมูลประเภทไบนารี ได้แก่ ไฟล์ข้อมูลต่างๆ, ไฟล์รูปภาพ, ไฟล์มัลติมีเดีย เป็นต้น คือไฟล์อะไรก็ตามที่อัพโหลดผ่านฟอร์มอัพโหลดไฟล์ในภาษา HTML โดย TINYBLOB นั้น จะมีเนื้อที่ให้เก็บข้อมูลได้ 256 ไบต์ BLOB : สำหรับเก็บข้อมูลประเภทไบนารี เช่นเดียวกับ TINYBLOB แต่สามารถเก็บข้อมูลได้ 64KB MEDIUMBLOB : สำหรับเก็บข้อมูลประเภทไบนารี เช่นเดียวกับ TINYBLOB แต่เก็บข้อมูลได้ 16MB LONGBLOB : สำหรับเก็บข้อมูลประเภทไบนารี เช่นเดียวกับ TINYBLOB แต่เก็บข้อมูลได้ 4GB ข้อสังเกต ข้อมูลประเภท BLOB นั้น แม้จะมีประโยชน์ในเรื่องของการเก็บข้อมูลประเภท BINARY ให้อยู่กับตัวฐานข้อมูล ทำให้สะดวกเวลาสืบค้นก็ตาม แต่มันก็ทำให้ฐานข้อมูลมีขนาดใหญ่ เกินความ จำเป็นด้วย ทำให้เกิดความไม่สะดวกในการสำรองฐานข้อมูลในกรณีที่ มีข้อมูลอัพโหลดไป เก็บมากๆ โดยปกติแล้ว จะใช้วิธีการอัพโหลดไปเก็บไว้ในโฟลเดอร์ แล้วเก็บลิงก์ไปยังไฟล์เหล่านั้น เป็นฟิลด์ชนิด VARCHAR มากกว่า SET : สำหรับเก็บข้อมูลที่เป็นกลุ่มของข้อมูลที่ยอมให้เลือกได้ 1 ค่าหรือหลายๆ ค่า ซึ่งสามารถกำหนด ได้ถึง 64 ค่า |
| ขั้นต่อไปให้กรอกรายละเอียดต่างๆ ให้ครบ เช่น สร้างฟิลด์ 3 ฟิลด์ เราต้องระบุชื่อฟิลด์ ชนิด ของข้อมูล ที่จัดเก็บ หรือรายละเอียดอื่นๆ ให้ครบทั้ง 3 ฟิลด์ก่อน เมื่อเรียบร้อยแล้วคลิกที่ปุ่ม บันทึก เพื่อ สร้างตาราง ใหม่ตามรายละเอียดที่ได้กำหนดไว้ ดังรูปที่ 4 |
รูปที่ 4 การกำหนดรายละเอียดของฟิลด์ต่างๆ ภายในตาราง  |
| หลังจากคลิกที่ปุ่ม บันทึก แล้ว โปรแกรมจะแจ้งให้ทราบว่า ได้สร้างตาราง stock เรียบร้อยแล้ว และจะ เข้าสู่หน้าจอหน้าจอสำหรับการจัดการตาราง ภายในหน้าจอจะมีเมนูต่างๆ หลายเมนู ซึ่งจะ อธิบายใน ลำดับถัดไป และ มีการแจ้งให้ผู้ใช้ทราบรายละเอียดอื่นๆ ที่เกี่ยวข้องกับตารางนั้น ๆ เช่น ดัชนี เนื้อที่ที่ ใช้งาน ค่าสถิติต่างๆ เป็นต้น ดังรูปที่ 5 |
รูปที่ 5 หน้าจอภายหลังสร้างตารางใหม่
|
| การจัดการกับฟิลด์และข้อมูลของตาราง 1. การเรียกดูโครงสร้างของตาราง เราจะต้องอยู่ในหน้าจอการ จัดการตารางก่อน (รูปที่ 5) ซึ่งการเข้า มายังหน้าจอนี้ได้ มี 2 วิธี คือ คลิก จากชื่อตารางซึ่งแสดงอยู่ส่วนซ้ายของโปรแกรม แสดงดังรูปที่ 6 หรือ ภายหลังจากสร้างตารางใหม่ก็จะเข้ามายังหน้าจอจัดการตาราง เช่นเดียวกัน |
รูปที่ 6 รายชื่อตารางภายในฐานข้อมูล คลิกเพื่อจัดการตาราง
|
| ภายในหน้าจอจัดการตาราง โปรแกรมจะแสดงโครงสร้างของตารางเป็นหน้าจอแรก หรือ เรา สามารถคลิก ที่ เมนู โครงสร้าง เพื่อแสดงโครงสร้างของข้อมูลได้เช่นเดียวกัน ดังรูปที่ 7 โปรแกรมจะ แสดงโครงสร้าง ของตารางนั้นๆ อันประกอบไปด้วย ชื่อฟิลด์ ชนิดของข้อมูล แอตทริบิวต์ การใส่ค่าว่าง และไอคอนสำหรับ จัดการ ดังนี้  สำหรับแก้ไข ชื่อฟิลด์ ชนิดของข้อมูลที่เก็บ ไพรมารีคีย์ หรือค่าเริ่มต้นอื่นๆ สำหรับลบฟิลด์นั้นๆ ออกจากตาราง สำหรับกำหนดให้ฟิลด์นั้นๆ เป็นไพรมารีคีย์ (Primary Key) สำหรับกำหนดให้ฟิลด์นั้นๆ เป็นดัชนี (Index) สำหรับกำหนดให้ฟิลด์นั้นๆ เป็นเอกลักษณ์ (Unique) |
รูปที่ 7 หน้าจอการจัดการตาราง ในส่วนการแสดงโครงสร้างตาราง
|
| 2. การเปิดดูข้อมูลภายในตาราง การเปิดดูข้อมูลภายในตาราง ทำได้โดยคลิกที่เมนู เปิดดู ซึ่งจะคลิกได้ก็ ต่อเมื่อมีข้อมูล ภายในตารางแล้วเท่านั้น สำหรับเมนู เปิดดู แสดงดังรูปที่ 8 และ 9 |
รูปที่ 8 แสดงเมนู เปิดดู
|
รูปที่ 9 ข้อมูลภายในตาราง ภายหลังคลิกเมนู เปิดดู
|
| 3. การเปิดดูข้อมูลภายในตารางด้วยคำสั่ง SQL ในหัวข้อที่ผ่านมา (2) เป็นการเปิดดูข้อมูลโดยดูข้อมูลทั้ง หมด ในการใช้งานจริงจะมีการ เลือกดูข้อมูลแบบมีเงื่อนไข ซึ่งสามารถเลือกดูได้ในโปรแกรม โดยคลิกที่ เมนู SQL จากนั้นจะปรากฏ text area สำหรับพิมพ์คำสั่ง SQL ลงไป เมื่อเรียบร้อยแล้วคลิกที่ปุ่ม ลงมือ เพื่อรันคำสั่ง SQL ดังแสดง ในรูปที่ 10 |
รูปที่ 10 การใช้คำสั่ง SQL เพื่อเปิดดูข้อมูลภายในตาราง
|
| 4. การค้นหา ภายในเมนูค้นหา มีความหมายเดียวกับการใช้คำสั่ง SQL สำหรับเปิดดูข้อมูล แต่ ในเมนูการ ค้นหานี้ จะเป็น user interface ให้ ผู้ใช้เลือก ทำให้ง่ายต่อผู้ใช้ที่ต้องการความ สะดวก และ ง่ายต่อการใช้ งาน สำหรับ หน้าจอของเมนู การค้นหา แสดงดังรูปที่ 11 |
 รูปที่ 11 หน้าจอการค้นหา |
| จากรูปที่ 11 นำมาอธิบายการใช้งานการค้นหา ได้ดังนี้ 1. เลือกฟิลด์ที่ต้องการแสดงข้อมูล (เลือกอย่างน้อยหนึ่งฟิลด์) 2. กำหนดจำนวนระเบียนที่ต้องการแสดงใน 1 หน้า 3. กรอกเงื่อนไขในการค้นหา (ถ้ามี) 4. ระบุเงื่อนไขของฟิลด์ต่างๆ 5. การเพิ่มข้อมูลลงยังตาราง สามารถทำได้โดยคลิกที่เมนู แทรก โปรแกรมจะแสดงหน้าจอ สำหรับเพิ่มข้อมูลดังรูปที่ 12 จากนั้นให้กรอกข้อมูลที่ต้องการลงไปในคอลัมน์ ค่า (Value) เมื่อกรอก ข้อมูลเรียบร้อยแล้ว หากต้องการกลับมาเพิ่มข้อมูลในแถวต่อไปเลย ให้คลิกที่ แทรกระเบียนใหม่ จากนั้นคลิกที่ ลงมือ |
รูปที่ 12 การเพิ่มข้อมูลลงยังตาราง
|
6. การลบข้อมูลในตาราง คลิกที่เมนู เปิดดู โปรแกรมจะแสดงรายการข้อมูล จากนั้น คลิกที่รูป
เพื่อลบข้อมูล ดังรูปที่ 13 (สามารถให้คำสั่ง SQL ในการลบข้อมูลได้อีกวธีหนึ่ง) 
รูปที่ 13 การลบข้อมูลภายในตาราง
|
| 7. การแก้ไขข้อมูลในตาราง คลิกที่เมนู เปิดดู โปรแกรมจะแสดงรายการข้อมูล จากนั้น คลิกที่รูป เพื่อ แก้ไขข้อมูล ดังรูปที่ 14 (สามารถให้คำสั่ง SQL ในการลบข้อมูลได้อีกวิธีหนึ่ง) เมื่อคลิก ที่รูปแก้ไขแล้ว จะปรากฏหน้าจอสำหรับแก้ไขข้อมูลดังรูปที่ 15 เป็นช่องสำหรับแก้ไข โดยจะแสดงทุกๆ ฟิลด์ ภายในตาราง และหน้าจอแก้ไขนี้สามารถบันทึก หรือ แทรกข้อมูลเป็นแถวใหม่ได้ ด้วย |
รูปที่ 14 การแก้ไขข้อมูลในตาราง
|
| 8. การลบตาราง ทำได้โดยคลิกที่ชื่อฐานข้อมูลทางด้านซ้ายของโปรแกรม เพื่อแสดงตาราง ทั้งหมดขึ้น มา จากนั้นเลือกคลิกที่รูป เพื่อลบตารางที่ต้องการ แสดงการลบตาราง ดังรูปที่ 16 |
 รูปที่ 15 การแก้ไขข้อมูลในตาราง |
| จากรูปที่ 16 เป็นหน้าจอแสดงการลบตาราง และยืนยันการลบตาราง ถ้าต้องการลบตาราง ให้คลิกที่ OK ถ้าไม่ต้องการลบตารางให้คลิกที่ Cancel 9. การ Export ข้อมูล (ส่งออก) ทำได้โดย คลิกที่เมนู ส่งออก จากนั้นโปรแกรมจะแสดง หน้าจอสำหรับตั้งค่าการ Export ต่างๆ ดังรูปที่ 17 |
รูปที่ 16 การลบตารางออกจากฐานข้อมูล
|
รูปที่ 17 การส่งออก (Export) ข้อมูล
จากรูปที่ 17 เป็นหน้าจอสำหรับการตั้งค่าต่างๆ ของการ Export ซึ่งประกอบไปด้วย ส่วนต่าง ๆ ดังนี้ - ส่งออก ใช้สำหรับเลือกชนิดของข้อมูลที่จะส่งออก เช่น SQL, XML เป็นต้น - โครงสร้าง เพิ่มคำสั่ง drop table ใช้ในกรณีที่ต้องการให้ลบตารางเก่าก่อนสร้างตารางใหม่ ในขณะ ที่ นำไฟล์มา Import Add AUTO_INCREMENT value ใช้เพิ่มข้อมูลประเภท auto_increment ในขณะ สร้าง ตาราง ในกรณีที่นำไฟล์มา Import ใส่ backquote ให้กับชื่อตารางและฟิลด์ - ข้อมูล คำสั่ง INSERT เต็มรูปแบบ แทรกหลายระเบียนในคราวเดียว Export Type เป็นการเลือก เฉพาะชนิดของคำสั่งที่ต้องการ ได้แก่ INSERT UPDATE และ REPLACE - ส่งมาเป็นไฟล์ ให้คลิกที่ checkbox ด้านหน้าด้วย - ใส่รูปแบบของชื่อไฟล์ เป็นการใส่ชื่อไฟล์ที่ต้องการ |
| เมื่อกำหนดค่าการ Export ต่างๆ เรียบร้อยแล้ว ให้คลิกที่ ลงมือ จะปรากฏหน้าต่าง สำหรับเลือกว่าจะ บันทึกไฟล์ หรือเปิดไฟล์ ให้คลิกที่ SAVE หลังจากนั้นเลือก location ภายในเครื่องเพื่อแจ้งให้ โปรแกรมทราบว่าจะเซฟไฟล์ไว้ที่ใด เมื่อเรียบร้อยแล้วคลิก ที่ SAVE เพื่อบันทึกไฟล์ข้อมูลลงเครื่องดัง รูปที่ 18 |
รูปที่ 18 หน้าต่างสำหรับเลือกบันทึกไฟล์
|
| 10. การนำเข้า (Import) ข้อมูล จะทำงานผ่าน เมนู SQL เมื่ออยู่ในหน้าจอ SQL แล้วให้คลิกที่ Browseเพื่อ เลือกไฟล์ Export ที่ต้องการจากนั้น คลิกที่ ลงมือ เพื่อนำข้อมูลในไฟล์ Import ลงยัง ฐานข้อมูล ดังรูปที่ 19 |
รูปที่ 19 การนำเข้า (Import) ข้อมูล
|
| 11. การเพิ่มฟิลด์ใหม่ลงไปในตารางที่มีอยู่แล้ว จะดำเนินการผ่านเมนู โครงสร้าง ขั้นแรกให้ คลิกที่เมนู โครงสร้าง จะพบส่วนของการเพิ่มฟิลด์ใหม่ ซึ่งต้องระบุจำนวนฟิลด์ที่ต้องการเพิ่ม และ ระบุ ว่าจะเพิ่ม ฟิลด์ใหม่ ไว้หน้าหรือหลังฟิลด์ใดในตาราง การเพิ่มฟิลด์ใหม่ ดังรูปที่ 20 uคลิก SQL คลิกปุ่ม Browse.. เลือกตำแหน่งที่อยู่ของไฟล์ เลือกชื่อไฟล์ คลิก Open คลิก ลงมือ |
 
รูปที่ 20 ขั้นตอนการเพิ่มฟิลด์ใหม่
|
| จากรูปที่ 20 เป็นหน้าจอสำหรับใส่รายละเอียดของฟิลด์ใหม่ โดยผู้ใช้ต้องกรอกชื่อฟิลด์ ชนิดของข้อมูล ที่จะเก็บ ความยาว และค่าอื่นๆ เมื่อกรอกข้อมูลเรียบร้อยแล้วคลิกที่ บันทึก เพื่อเพิ่มฟิลด์ ใหม่ลงยังตาราง |
รูปที่ 21 การเลือกเพื่อลบฐานข้อมูล
|
