การเขียนโปรแกรมคอมพิวเตอร์ - คู่มือฉบับย่อ

ความรู้เบื้องต้นเกี่ยวกับโปรแกรมคอมพิวเตอร์

ก่อนที่จะเข้าสู่การเขียนโปรแกรมคอมพิวเตอร์ให้เราทำความเข้าใจโปรแกรมคอมพิวเตอร์ก่อนและสิ่งที่พวกเขาทำ

โปรแกรมคอมพิวเตอร์คือลำดับของคำสั่งที่เขียนโดยใช้ภาษาเขียนโปรแกรมคอมพิวเตอร์เพื่อทำงานที่ระบุโดยคอมพิวเตอร์

คำศัพท์สำคัญสองคำที่เราใช้ในคำจำกัดความข้างต้นคือ -

ลำดับคำแนะนำ
ภาษาโปรแกรมคอมพิวเตอร์

เพื่อทำความเข้าใจเงื่อนไขเหล่านี้ให้พิจารณาสถานการณ์เมื่อมีคนถามคุณเกี่ยวกับวิธีไปที่ KFC ใกล้ ๆ คุณจะทำอย่างไรเพื่อบอกวิธีไป KFC?

คุณจะใช้ภาษามนุษย์ในการบอกทางไป KFC ได้ดังนี้ -

ตรงไปอีกครึ่งกิโลเมตรเลี้ยวซ้ายจากไฟแดงขับไปประมาณ 1 กิโลเมตรจะพบร้าน KFC อยู่ทางขวามือ

ที่นี่คุณได้ใช้ภาษาอังกฤษเพื่อทำหลายขั้นตอนเพื่อไปถึง KFC หากทำตามลำดับต่อไปนี้คุณจะไปถึง KFC -

1.	Go straight
2.	Drive half kilometer
3.	Take left
4.	Drive around one kilometer
5.	Search for KFC at your right side

ตอนนี้ให้ลองแมปสถานการณ์ด้วยโปรแกรมคอมพิวเตอร์ ลำดับคำแนะนำข้างต้นเป็นไฟล์Human Program เขียนใน English Languageซึ่งจะแนะนำวิธีเข้าถึง KFC จากจุดเริ่มต้นที่กำหนด ลำดับเดียวกันนี้อาจได้รับในภาษาสเปนฮินดีอารบิกหรือภาษามนุษย์อื่น ๆ หากผู้ที่กำลังมองหาทิศทางรู้ภาษาเหล่านี้

ตอนนี้เรามาลองทำความเข้าใจกับโปรแกรมคอมพิวเตอร์ซึ่งเป็นลำดับของคำสั่งที่เขียนด้วยภาษาคอมพิวเตอร์เพื่อทำงานที่ระบุโดยคอมพิวเตอร์ ต่อไปนี้เป็นโปรแกรมง่ายๆที่เขียนขึ้นPython ภาษาโปรแกรม -

print "Hello, World!"

โปรแกรมคอมพิวเตอร์ข้างต้นสั่งให้คอมพิวเตอร์พิมพ์ "Hello, World!" บนหน้าจอคอมพิวเตอร์

โปรแกรมคอมพิวเตอร์เรียกอีกอย่างว่าไฟล์ computer softwareซึ่งมีตั้งแต่สองบรรทัดไปจนถึงคำแนะนำหลายล้านบรรทัด
คำสั่งโปรแกรมคอมพิวเตอร์เรียกอีกอย่างว่าซอร์สโค้ดของโปรแกรมและ computer programming เรียกอีกอย่างว่า program coding.
คอมพิวเตอร์ที่ไม่มีโปรแกรมคอมพิวเตอร์เป็นเพียงกล่องถ่ายโอนข้อมูล เป็นโปรแกรมที่ทำให้คอมพิวเตอร์ใช้งานได้

ในขณะที่เราได้พัฒนาภาษามากมายเพื่อสื่อสารกันเองนักวิทยาศาสตร์คอมพิวเตอร์จึงได้พัฒนาภาษาโปรแกรมคอมพิวเตอร์หลายภาษาเพื่อให้คำสั่งกับคอมพิวเตอร์ (เช่นการเขียนโปรแกรมคอมพิวเตอร์) เราจะเห็นภาษาโปรแกรมคอมพิวเตอร์หลายภาษาในบทต่อ ๆ ไป

ความรู้เบื้องต้นเกี่ยวกับการเขียนโปรแกรมคอมพิวเตอร์

หากคุณเข้าใจว่าก computer programคือแล้วเราจะพูดว่า: การเขียนโปรแกรมคอมพิวเตอร์เรียกว่าการเขียนโปรแกรมคอมพิวเตอร์

ดังที่เราได้กล่าวไว้ก่อนหน้านี้มีภาษาโปรแกรมหลายร้อยภาษาซึ่งสามารถใช้ในการเขียนโปรแกรมคอมพิวเตอร์และต่อไปนี้เป็นภาษาบางส่วน -

Java
C
C++
Python
PHP
Perl
Ruby

การใช้โปรแกรมคอมพิวเตอร์

ปัจจุบันมีการใช้โปรแกรมคอมพิวเตอร์ในเกือบทุกสาขาครัวเรือนเกษตรกรรมการแพทย์การบันเทิงการป้องกันการสื่อสาร ฯลฯ รายการด้านล่างนี้เป็นโปรแกรมคอมพิวเตอร์บางส่วน -

MS Word, MS Excel, Adobe Photoshop, Internet Explorer, Chrome ฯลฯ เป็นตัวอย่างของโปรแกรมคอมพิวเตอร์
มีการใช้โปรแกรมคอมพิวเตอร์เพื่อพัฒนากราฟิกและเทคนิคพิเศษในการสร้างภาพยนตร์
มีการใช้โปรแกรมคอมพิวเตอร์เพื่อทำการอัลตราซาวด์เอ็กซ์เรย์และการตรวจทางการแพทย์อื่น ๆ
มีการใช้โปรแกรมคอมพิวเตอร์ในโทรศัพท์มือถือของเราสำหรับการสื่อสารทาง SMS แชทและเสียง

นักเขียนโปรแกรมคอมพิวเตอร์

คนที่เขียนโปรแกรมคอมพิวเตอร์ได้หรืออีกนัยหนึ่งคนที่สามารถเขียนโปรแกรมคอมพิวเตอร์ได้เรียกว่า Computer Programmer

จากความเชี่ยวชาญด้านภาษาโปรแกรมคอมพิวเตอร์เราสามารถตั้งชื่อโปรแกรมเมอร์คอมพิวเตอร์ได้ดังนี้ -

โปรแกรมเมอร์ C
โปรแกรมเมอร์ C ++
โปรแกรมเมอร์ Java
โปรแกรมเมอร์ Python
โปรแกรมเมอร์ PHP
โปรแกรมเมอร์ Perl
โปรแกรมเมอร์ Ruby

อัลกอริทึม

จากมุมมองการเขียนโปรแกรม an algorithmเป็นขั้นตอนทีละขั้นตอนในการแก้ไขปัญหา อัลกอริทึมเป็นวิธีการที่มีประสิทธิภาพซึ่งแสดงเป็นชุดคำสั่งที่กำหนดไว้อย่าง จำกัด

ดังนั้นโปรแกรมเมอร์คอมพิวเตอร์จะแสดงขั้นตอนทั้งหมดที่จำเป็นในการแก้ไขปัญหาก่อนที่จะเขียนโค้ดจริง ต่อไปนี้เป็นตัวอย่างง่ายๆของอัลกอริทึมเพื่อค้นหาตัวเลขที่มากที่สุดจากรายการตัวเลขที่กำหนด -

1. Get a list of numbers L₁, L₂, L₃....L_N
2. Assume L₁ is the largest, Largest = L₁
3. Take next number L_i from the list and do the following
4. If Largest is less than L_i
5. Largest = L_i
6. If L_i is last number from the list then
7. Print value stored in Largest and come out
8. Else repeat same process starting from step 3

อัลกอริทึมข้างต้นได้รับการเขียนขึ้นเพื่อช่วยให้ผู้เริ่มต้นเข้าใจแนวคิดนี้ คุณจะได้พบกับวิธีการเขียนอัลกอริทึมคอมพิวเตอร์ที่เป็นมาตรฐานมากขึ้นเมื่อคุณก้าวไปสู่ขั้นสูงของการเขียนโปรแกรมคอมพิวเตอร์

เราถือว่าคุณมีความรู้ภาษาอังกฤษซึ่งเป็นที่รู้จักกันดี Human Interface Language. ภาษาอังกฤษมีไวยากรณ์ที่กำหนดไว้ล่วงหน้าซึ่งจำเป็นต้องปฏิบัติตามเพื่อเขียนข้อความภาษาอังกฤษอย่างถูกต้อง ในทำนองเดียวกันภาษาส่วนต่อประสานของมนุษย์ส่วนใหญ่ (ฮินดีอังกฤษสเปนฝรั่งเศส ฯลฯ ) ประกอบด้วยองค์ประกอบหลายอย่างเช่นคำกริยาคำนามคำคุณศัพท์กริยาวิเศษณ์และคำสันธาน ฯลฯ

เช่นเดียวกับภาษาอินเทอร์เฟซของมนุษย์ภาษาโปรแกรมคอมพิวเตอร์ยังประกอบด้วยองค์ประกอบหลายอย่าง เราจะนำคุณไปสู่พื้นฐานขององค์ประกอบเหล่านั้นและทำให้คุณสะดวกสบายในการใช้งานในภาษาโปรแกรมต่างๆ องค์ประกอบพื้นฐานเหล่านี้ ได้แก่ -

สภาพแวดล้อมการเขียนโปรแกรม
ไวยากรณ์พื้นฐาน
ประเภทข้อมูล
Variables
Keywords
ตัวดำเนินการพื้นฐาน
การตัดสินใจ
Loops
Numbers
Characters
Arrays
Strings
Functions
ไฟล์ I / O

เราจะอธิบายองค์ประกอบเหล่านี้ทั้งหมดในบทต่อ ๆ ไปพร้อมตัวอย่างโดยใช้ภาษาโปรแกรมต่างๆ ขั้นแรกเราจะพยายามทำความเข้าใจความหมายของคำศัพท์เหล่านี้โดยทั่วไปจากนั้นเราจะดูว่าคำศัพท์เหล่านี้สามารถใช้ในภาษาโปรแกรมต่างๆได้อย่างไร

บทช่วยสอนนี้ออกแบบมาเพื่อให้คุณมีความคิดเกี่ยวกับภาษาโปรแกรมยอดนิยมดังต่อไปนี้ -

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

ส่วนสำคัญของบทช่วยสอนได้รับการอธิบายโดยการใช้ภาษา C เป็นภาษาโปรแกรมจากนั้นเราได้แสดงให้เห็นว่าแนวคิดที่คล้ายกันทำงานอย่างไรใน Java และ Python ดังนั้นหลังจากจบบทช่วยสอนนี้คุณจะคุ้นเคยกับภาษาโปรแกรมยอดนิยมเหล่านี้

แม้ว่าการตั้งค่าสภาพแวดล้อมจะไม่ใช่องค์ประกอบของภาษาโปรแกรมใด ๆ แต่เป็นขั้นตอนแรกที่ต้องปฏิบัติตามก่อนที่จะตั้งค่าเพื่อเขียนโปรแกรม

เมื่อเราพูดว่า Environment Setup มันก็หมายถึงฐานที่เราสามารถเขียนโปรแกรมได้ ดังนั้นเราต้องมีการตั้งค่าซอฟต์แวร์ที่จำเป็นเช่นการติดตั้งบนพีซีของเราซึ่งจะใช้ในการเขียนโปรแกรมคอมพิวเตอร์รวบรวมและดำเนินการ ตัวอย่างเช่นหากคุณต้องการท่องอินเทอร์เน็ตคุณต้องมีการตั้งค่าต่อไปนี้ในเครื่องของคุณ -

การเชื่อมต่ออินเทอร์เน็ตที่ใช้งานได้เพื่อเชื่อมต่อกับอินเทอร์เน็ต
เว็บเบราว์เซอร์เช่น Internet Explorer, Chrome, Safari เป็นต้น

หากคุณเป็นผู้ใช้พีซีคุณจะจำภาพหน้าจอต่อไปนี้ซึ่งเรานำมาจาก Internet Explorer ในขณะที่เรียกดู tutorialspoint.com

ในทำนองเดียวกันคุณจะต้องมีการตั้งค่าต่อไปนี้เพื่อเริ่มการเขียนโปรแกรมโดยใช้ภาษาโปรแกรมใด ๆ

โปรแกรมแก้ไขข้อความสำหรับสร้างโปรแกรมคอมพิวเตอร์
คอมไพเลอร์เพื่อรวบรวมโปรแกรมในรูปแบบไบนารี
ล่ามเพื่อดำเนินการโปรแกรมโดยตรง

ในกรณีที่คุณไม่สามารถใช้คอมพิวเตอร์ได้เพียงพอคุณจะไม่สามารถตั้งค่าซอฟต์แวร์เหล่านี้ได้ ดังนั้นเราขอแนะนำให้คุณใช้ความช่วยเหลือจากเจ้าหน้าที่ด้านเทคนิคที่อยู่รอบตัวคุณเพื่อตั้งค่าสภาพแวดล้อมการเขียนโปรแกรมบนเครื่องของคุณจากจุดที่คุณสามารถเริ่มต้นได้ แต่สำหรับคุณสิ่งสำคัญคือต้องเข้าใจว่าสิ่งของเหล่านี้คืออะไร

แก้ไขข้อความ

โปรแกรมแก้ไขข้อความเป็นซอฟต์แวร์ที่ใช้ในการเขียนโปรแกรมคอมพิวเตอร์ เครื่อง Windows ของคุณต้องมี Notepad ซึ่งสามารถใช้พิมพ์โปรแกรมได้ คุณสามารถเปิดใช้งานได้โดยทำตามขั้นตอนเหล่านี้ -

Start Icon → All Programs → Accessories → Notepad → Mouse Click on Notepad

มันจะเปิด Notepad พร้อมหน้าต่างต่อไปนี้ -

คุณสามารถใช้ซอฟต์แวร์นี้เพื่อพิมพ์โปรแกรมคอมพิวเตอร์ของคุณและบันทึกลงในไฟล์ได้ทุกที่ คุณสามารถดาวน์โหลดและติดตั้งโปรแกรมแก้ไขที่ดีอื่น ๆ เช่นNotepad++ซึ่งสามารถใช้ได้อย่างอิสระ

หากคุณเป็นผู้ใช้ Mac คุณจะมี TextEdit หรือคุณสามารถติดตั้งโปรแกรมแก้ไขเชิงพาณิชย์อื่น ๆ เช่น BBEdit จะเริ่มต้นด้วย.

คอมไพเลอร์?

คุณเขียนโปรแกรมคอมพิวเตอร์ของคุณโดยใช้ภาษาโปรแกรมที่คุณชื่นชอบและบันทึกลงในไฟล์ข้อความที่เรียกว่าไฟล์โปรแกรม

ตอนนี้ให้เราลองดูรายละเอียดเพิ่มเติมเล็กน้อยว่าคอมพิวเตอร์เข้าใจโปรแกรมที่คุณเขียนโดยใช้ภาษาโปรแกรมได้อย่างไร จริงๆแล้วคอมพิวเตอร์ไม่สามารถเข้าใจโปรแกรมของคุณได้โดยตรงในรูปแบบข้อความดังนั้นเราจึงต้องแปลงโปรแกรมนี้ในรูปแบบไบนารีซึ่งคอมพิวเตอร์สามารถเข้าใจได้

การแปลงจากโปรแกรมข้อความเป็นไฟล์ไบนารีทำได้โดยซอฟต์แวร์อื่นที่เรียกว่าคอมไพเลอร์และกระบวนการแปลงจากโปรแกรมที่จัดรูปแบบข้อความเป็นไฟล์รูปแบบไบนารีนี้เรียกว่าการคอมไพล์โปรแกรม สุดท้ายคุณสามารถเรียกใช้ไฟล์ไบนารีเพื่อทำงานที่ตั้งโปรแกรมไว้

เราจะไม่ลงรายละเอียดของคอมไพเลอร์และขั้นตอนต่างๆของการคอมไพล์

แผนภาพการไหลต่อไปนี้ให้ภาพประกอบของกระบวนการ -

ดังนั้นหากคุณกำลังจะเขียนโปรแกรมของคุณในภาษาดังกล่าวซึ่งจำเป็นต้องมีการคอมไพล์เช่น C, C ++, Java และ Pascal เป็นต้นคุณจะต้องติดตั้งคอมไพเลอร์ก่อนที่จะเริ่มเขียนโปรแกรม

ล่าม

เราเพิ่งพูดคุยเกี่ยวกับคอมไพเลอร์และกระบวนการคอมไพล์ จำเป็นต้องมีคอมไพเลอร์ในกรณีที่คุณกำลังจะเขียนโปรแกรมด้วยภาษาโปรแกรมที่ต้องคอมไพล์เป็นรูปแบบไบนารีก่อนที่จะดำเนินการ

มีภาษาโปรแกรมอื่น ๆ เช่น Python, PHP และ Perl ซึ่งไม่จำเป็นต้องมีการรวบรวมเป็นรูปแบบไบนารี แต่สามารถใช้ล่ามเพื่ออ่านโปรแกรมดังกล่าวทีละบรรทัดและดำเนินการได้โดยตรงโดยไม่ต้องแปลงเพิ่มเติม

ดังนั้นหากคุณจะเขียนโปรแกรมด้วย PHP, Python, Perl, Ruby และอื่น ๆ คุณจะต้องติดตั้งล่ามก่อนที่จะเริ่มเขียนโปรแกรม

การรวบรวมออนไลน์

หากคุณไม่สามารถตั้งค่าตัวแก้ไขคอมไพเลอร์หรือล่ามบนเครื่องของคุณได้ดังนั้นtutorialspoint.comก็มีสิ่งอำนวยความสะดวกในการคอมไพล์และรันโปรแกรมเกือบทั้งหมดทางออนไลน์ด้วยการคลิกเพียงครั้งเดียว

ดังนั้นอย่ากังวลและดำเนินการต่อไปเพื่อรับประสบการณ์ที่น่าตื่นเต้นในการเป็นโปรแกรมเมอร์คอมพิวเตอร์ในขั้นตอนที่ง่ายและสะดวก

เริ่มต้นด้วยการเข้ารหัสเล็กน้อยซึ่งจะทำให้คุณเป็นโปรแกรมเมอร์คอมพิวเตอร์ได้จริงๆ เราจะเขียนโปรแกรมคอมพิวเตอร์บรรทัดเดียวเพื่อเขียนHello, World!บนหน้าจอของคุณ มาดูกันว่าสามารถเขียนโดยใช้ภาษาโปรแกรมต่างๆได้อย่างไร

โปรแกรม Hello World ใน C

ลองตัวอย่างต่อไปนี้โดยใช้ตัวเลือกคอมไพเลอร์ออนไลน์ของเราที่มีอยู่ในwww.compileonline.com

สำหรับตัวอย่างส่วนใหญ่ที่ให้ไว้ในบทช่วยสอนนี้คุณจะพบไฟล์ Try it ในส่วนรหัสเว็บไซต์ของเราที่มุมขวาบนซึ่งจะนำคุณไปยังคอมไพเลอร์ออนไลน์

พยายามเปลี่ยนเนื้อหาภายใน printf () เช่นพิมพ์อะไรก็ได้แทน Hello World!จากนั้นตรวจสอบผลลัพธ์ เพียงแค่พิมพ์สิ่งที่คุณเก็บไว้ในเครื่องหมายคำพูดคู่สองคำ

#include <stdio.h>

int main() {
   /* printf() function to write Hello, World! */
   printf( "Hello, World!" );
}

ซึ่งให้ผลลัพธ์ดังต่อไปนี้ -

Hello, World!

โปรแกรม Hello World นี้จะช่วยให้เราเข้าใจแนวคิดพื้นฐานต่างๆที่เกี่ยวข้องกับการเขียนโปรแกรม C

จุดเข้าโปรแกรม

สำหรับตอนนี้อย่าลืมเกี่ยวกับไฟล์ #include <stdio.h> แต่โปรดทราบว่าคุณต้องใส่คำสั่งนี้ไว้ที่ด้านบนของโปรแกรม C

ทุกโปรแกรม C เริ่มต้นด้วย main () ซึ่งเรียกว่าฟังก์ชันหลักจากนั้นตามด้วยวงเล็บปีกกาด้านซ้าย ส่วนที่เหลือของคำสั่งโปรแกรมจะถูกเขียนขึ้นระหว่างและในที่สุดปีกกาขวาจะสิ้นสุดโปรแกรม

ส่วนการเข้ารหัสภายในวงเล็บปีกกาทั้งสองนี้เรียกว่าตัวโปรแกรม วงเล็บปีกกาด้านซ้ายสามารถอยู่ในบรรทัดเดียวกับ main () {หรือในบรรทัดถัดไปตามที่กล่าวไว้ในโปรแกรมข้างต้น

ฟังก์ชั่น

ฟังก์ชั่นเป็นหน่วยเล็ก ๆ ของโปรแกรมและใช้เพื่อทำงานเฉพาะอย่าง ตัวอย่างเช่นโปรแกรมข้างต้นใช้ประโยชน์จากสองฟังก์ชัน:main() และ printf(). ที่นี่ฟังก์ชัน main () ให้จุดเริ่มต้นสำหรับการทำงานของโปรแกรมและฟังก์ชันอื่น ๆ printf () จะถูกใช้เพื่อพิมพ์ข้อมูลบนหน้าจอคอมพิวเตอร์

คุณสามารถเขียนฟังก์ชันของคุณเองซึ่งเราจะเห็นในบทที่แยกต่างหาก แต่การเขียนโปรแกรม C นั้นมีฟังก์ชันในตัวมากมายเช่น main (), printf () เป็นต้นซึ่งเราสามารถใช้ในโปรแกรมของเราได้ตามความต้องการของเรา

ภาษาโปรแกรมบางภาษาใช้คำว่า sub-routine แทนฟังก์ชัน แต่ฟังก์ชันการทำงานจะเหมือนกันมากหรือน้อย

ความคิดเห็น

โปรแกรม AC สามารถมีคำสั่งอยู่ภายใน /*.....*/. ข้อความดังกล่าวเรียกว่าความคิดเห็นและความคิดเห็นเหล่านี้ใช้เพื่อทำให้ผู้ใช้โปรแกรมเป็นมิตรและเข้าใจง่าย สิ่งที่ดีเกี่ยวกับความคิดเห็นคือคอมไพเลอร์และล่ามจะละเลยอย่างสิ้นเชิง ดังนั้นคุณสามารถใช้ภาษาใดก็ได้ที่คุณต้องการเขียนความคิดเห็นของคุณ

ช่องว่าง

เมื่อเราเขียนโปรแกรมโดยใช้ภาษาโปรแกรมใด ๆ เราจะใช้อักขระที่พิมพ์ได้ต่างๆเพื่อเตรียมคำสั่งในการเขียนโปรแกรม อักขระที่พิมพ์ได้เหล่านี้คือa, b, c,......z, A, B, C,.....Z, 1, 2, 3,...... 0, !, @, #, $, %, ^, &, *, (, ), -, _, +, =, \, |, {, }, [, ], :, ;, <, >, ?, /, \, ~. `. ", '. หวังว่าฉันจะไม่พลาดอักขระที่พิมพ์ได้จากแป้นพิมพ์ของคุณ

นอกเหนือจากอักขระเหล่านี้แล้วยังมีอักขระบางตัวที่เราใช้บ่อยมาก แต่จะมองไม่เห็นในโปรแกรมของคุณและอักขระเหล่านี้คือช่องว่างแท็บ (\ t) บรรทัดใหม่ (\ n) อักขระเหล่านี้เรียกว่าwhitespaces.

อักขระช่องว่างที่สำคัญทั้งสามนี้มีอยู่ทั่วไปในภาษาโปรแกรมทั้งหมดและยังคงมองไม่เห็นในเอกสารข้อความของคุณ -

ช่องว่าง	คำอธิบาย	การเป็นตัวแทน
บรรทัดใหม่	เพื่อสร้างบรรทัดใหม่	\ n
แท็บ	เพื่อสร้างแท็บ	\ t
พื้นที่	เพื่อสร้างช่องว่าง	พื้นที่ว่าง

บรรทัดที่มีเฉพาะช่องว่างอาจมีความคิดเห็นเรียกว่าบรรทัดว่างและคอมไพเลอร์ C จะละเว้นมันโดยสิ้นเชิง Whitespace เป็นคำที่ใช้ใน C เพื่ออธิบายช่องว่างแท็บอักขระขึ้นบรรทัดใหม่และข้อคิดเห็น ดังนั้นคุณสามารถเขียนprintf("Hello, World!" );ดังแสดงด้านล่าง นี่คือช่องว่างที่สร้างขึ้นทั้งหมดรอบ ๆ "Hello, World!" ไม่มีประโยชน์และคอมไพเลอร์จะเพิกเฉยต่อสิ่งเหล่านี้ในช่วงเวลาของการคอมไพล์

#include <stdio.h>

int main() {

   /* printf() function to write Hello, World! */
   
   printf(    "Hello, World!"      );
   
}

ซึ่งให้ผลลัพธ์ดังต่อไปนี้ -

Hello, World!

หากเราทำให้อักขระช่องว่างเหล่านี้มองเห็นได้โปรแกรมด้านบนจะมีลักษณะเช่นนี้และคุณจะไม่สามารถคอมไพล์ได้ -

#include <stdio.h>\n
\n
int main()\n
{
   \n
   \t/* printf() function to write Hello, World! */
   \n 
   \tprintf(\t"Hello, World!"\t);\n
   \n
}\n

อัฒภาค

ทุกคำสั่งในโปรแกรม C ต้องลงท้ายด้วยอัฒภาค (;) ตัวอย่างเช่นหากคุณต้องการเขียนว่า "Hello, World!" สองครั้งจากนั้นจะเขียนดังนี้ -

#include <stdio.h>

int main() {
   /* printf() function to write Hello, World! */
   printf( "Hello, World!\n" );
   printf( "Hello, World!" );
}

โปรแกรมนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

Hello, World! 
Hello, World!

ที่นี่เรากำลังใช้อักขระบรรทัดใหม่ \nในฟังก์ชัน printf () แรกเพื่อสร้างบรรทัดใหม่ ให้เราดูว่าจะเกิดอะไรขึ้นถ้าเราไม่ใช้อักขระบรรทัดใหม่นี้ -

#include <stdio.h>

int main() {
   /* printf() function to write Hello, World! */
   printf( "Hello, World!" );
   printf( "Hello, World!" );
}

โปรแกรมนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

Hello, World! Hello, World!

เราจะเรียนรู้ตัวระบุและคำหลักในสองสามบทถัดไป

คำอธิบายโปรแกรม

ให้เราเข้าใจว่าโปรแกรม C ข้างต้นทำงานอย่างไร ก่อนอื่นโปรแกรมข้างต้นจะถูกแปลงเป็นรูปแบบไบนารีโดยใช้คอมไพเลอร์ C ลองใส่รหัสนี้ในไฟล์ test.c แล้วรวบรวมดังนี้ -

$gcc test.c -o demo

หากมีข้อผิดพลาดทางไวยากรณ์ (ข้อผิดพลาดทางไวยากรณ์ในศัพท์คอมพิวเตอร์) เราจะแก้ไขก่อนที่จะแปลงเป็นรูปแบบไบนารี หากทุกอย่างเรียบร้อยดีมันจะสร้างไฟล์ไบนารีที่เรียกว่าdemo. สุดท้ายเราดำเนินการสาธิตไบนารีที่สร้างขึ้นดังต่อไปนี้ -

$./demo

ซึ่งให้ผลลัพธ์ดังต่อไปนี้ -

Hello, World!

ที่นี่เมื่อเรารันไบนารี a.outคอมพิวเตอร์จะเข้าสู่ภายในโปรแกรมโดยเริ่มจาก main () และพบคำสั่ง printf () โปรดทราบว่าบรรทัดข้างใน /*....*/ เป็นความคิดเห็นและจะถูกกรองในเวลาที่รวบรวม ดังนั้นฟังก์ชัน printf () จะสั่งให้คอมพิวเตอร์พิมพ์บรรทัดที่กำหนดที่หน้าจอคอมพิวเตอร์ สุดท้ายจะพบวงเล็บปีกกาขวาซึ่งระบุการสิ้นสุดของฟังก์ชัน main () และออกจากโปรแกรม

ข้อผิดพลาดทางไวยากรณ์

หากคุณไม่ปฏิบัติตามกฎที่กำหนดโดยภาษาโปรแกรมเมื่อทำการคอมไพล์คุณจะได้รับข้อผิดพลาดทางไวยากรณ์และโปรแกรมจะไม่ถูกคอมไพล์ จากมุมมองทางไวยากรณ์แม้แต่จุดเดียวหรือลูกน้ำหรืออัฒภาคเดียวก็มีความสำคัญและคุณควรดูแลไวยากรณ์ขนาดเล็กเช่นกัน ในตัวอย่างต่อไปนี้เราได้ข้ามอัฒภาคมาลองคอมไพล์โปรแกรม -

#include <stdio.h>

main() {
   printf("Hello, World!")
}

โปรแกรมนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

main.c: In function 'main':
main.c:7:1: error: expected ';' before '}' token
 }
 ^

ดังนั้นสิ่งที่สำคัญที่สุดก็คือหากคุณไม่ปฏิบัติตามไวยากรณ์ที่เหมาะสมที่กำหนดโดยภาษาโปรแกรมในโปรแกรมของคุณคุณจะได้รับข้อผิดพลาดทางไวยากรณ์ ก่อนที่จะพยายามรวบรวมอีกครั้งคุณจะต้องแก้ไขและดำเนินการต่อ

โปรแกรม Hello World ใน Java

ต่อไปนี้เป็นโปรแกรมเทียบเท่าที่เขียนด้วย Java โปรแกรมนี้ก็จะให้ผลลัพธ์เช่นเดียวกันHello, World!.

public class HelloWorld { 
   public static void main(String []args) {
      /* println() function to write Hello, World! */
      System.out.println("Hello, World!");     
   }
}

ซึ่งให้ผลลัพธ์ดังต่อไปนี้ -

Hello, World!

โปรแกรม Hello World ใน Python

ต่อไปนี้เป็นโปรแกรมเทียบเท่าที่เขียนด้วย Python โปรแกรมนี้ก็จะให้ผลลัพธ์เช่นเดียวกันHello, World!.

#  print function to write Hello, World! */
print "Hello, World!"

ซึ่งให้ผลลัพธ์ดังต่อไปนี้ -

Hello, World!

หวังว่าคุณจะสังเกตเห็นว่าสำหรับตัวอย่าง C และ Java อันดับแรกเราจะรวบรวมโปรแกรมแล้วเรียกใช้งานไบนารีที่สร้างขึ้น แต่ในโปรแกรม Python เรากำลังดำเนินการโดยตรง ดังที่เราได้อธิบายไว้ในบทที่แล้ว Python เป็นภาษาที่ตีความและไม่จำเป็นต้องมีขั้นตอนกลางที่เรียกว่าการคอมไพล์

Python ไม่จำเป็นต้องใช้อัฒภาค (;) ในการยุติคำสั่ง แต่บรรทัดใหม่หมายถึงการสิ้นสุดของคำสั่งเสมอ

เรามาพูดถึงแนวคิดที่เรียบง่าย แต่สำคัญมากที่มีอยู่ในภาษาโปรแกรมเกือบทั้งหมดที่เรียกว่า data types. ตามชื่อที่ระบุประเภทข้อมูลแสดงถึงประเภทของข้อมูลที่คุณสามารถประมวลผลโดยใช้โปรแกรมคอมพิวเตอร์ของคุณ สามารถเป็นตัวเลขตัวอักษรและตัวเลขทศนิยม ฯลฯ

มาลองเขียนโปรแกรมคอมพิวเตอร์กันสักพักแล้วยกตัวอย่างง่ายๆในการเพิ่มจำนวนเต็ม 10 & 20 สองจำนวนซึ่งสามารถทำได้ง่ายๆดังนี้ -

10 + 20

ลองมาอีกปัญหาหนึ่งที่เราต้องการเพิ่มทศนิยมสองตัว 10.50 & 20.50 ซึ่งจะเขียนดังนี้ -

10.50 + 20.50

สองตัวอย่างตรงไปตรงมา ตอนนี้เรามาดูอีกตัวอย่างหนึ่งที่เราต้องการบันทึกข้อมูลนักเรียนในสมุดบันทึก ที่นี่เราต้องการบันทึกข้อมูลต่อไปนี้ -

Name:
Class:
Section:
Age:
Sex:

ตอนนี้ให้ใส่บันทึกนักเรียนหนึ่งคนตามข้อกำหนดที่กำหนด -

Name: Zara Ali
Class: 6th
Section: J
Age: 13
Sex: F

ตัวอย่างแรกจัดการกับจำนวนเต็มตัวอย่างที่สองเพิ่มตัวเลขทศนิยมสองตัวในขณะที่ตัวอย่างที่สามจัดการกับข้อมูลที่แตกต่างกัน มาใส่ดังนี้ -

ชื่อนักเรียน "Zara Ali" เป็นลำดับของอักขระซึ่งเรียกอีกอย่างว่าสตริง
นักเรียนชั้น "6" แสดงด้วยจำนวนเต็มและสตริงของอักขระสองตัว การผสมดังกล่าวเรียกว่าตัวอักษรและตัวเลข
ส่วนของนักเรียนแสดงด้วยอักขระตัวเดียวซึ่งก็คือ 'J'
อายุของนักเรียนแสดงด้วยจำนวนเต็มซึ่งก็คือ 13
เพศของนักเรียนแสดงด้วยอักขระตัวเดียวซึ่งก็คือ 'F'

ด้วยวิธีนี้เราจึงตระหนักว่าในชีวิตประจำวันของเราเราจัดการกับข้อมูลประเภทต่างๆเช่นสตริงอักขระตัวเลขจำนวนเต็ม (จำนวนเต็ม) และตัวเลขทศนิยม (ตัวเลขทศนิยม)

ในทำนองเดียวกันเมื่อเราเขียนโปรแกรมคอมพิวเตอร์เพื่อประมวลผลข้อมูลประเภทต่างๆเราจำเป็นต้องระบุประเภทให้ชัดเจน มิฉะนั้นคอมพิวเตอร์จะไม่เข้าใจว่าสามารถดำเนินการต่าง ๆ กับข้อมูลนั้นได้อย่างไร ภาษาโปรแกรมต่างๆใช้คำสำคัญที่แตกต่างกันเพื่อระบุประเภทข้อมูลที่แตกต่างกัน ตัวอย่างเช่นภาษาโปรแกรม C และ Java ใช้int เพื่อระบุข้อมูลจำนวนเต็มในขณะที่ char ระบุชนิดข้อมูลอักขระ

บทต่อ ๆ ไปจะแสดงวิธีใช้ข้อมูลประเภทต่างๆในสถานการณ์ต่างๆ สำหรับตอนนี้เรามาตรวจสอบประเภทข้อมูลสำคัญที่มีใน C, Java และ Python และคำหลักที่เราจะใช้เพื่อระบุประเภทข้อมูลเหล่านั้น

ประเภทข้อมูล C และ Java

C และ Java สนับสนุนชนิดข้อมูลเกือบชุดเดียวกันแม้ว่า Java จะสนับสนุนชนิดข้อมูลเพิ่มเติม สำหรับตอนนี้เรากำลังใช้ข้อมูลทั่วไปสองสามประเภทที่รองรับทั้งภาษาโปรแกรม -

ประเภท	คำสำคัญ	ช่วงค่าซึ่งสามารถแสดงโดยประเภทข้อมูลนี้
ตัวละคร	ถ่าน	-128 ถึง 127 หรือ 0 ถึง 255
จำนวน	int	-32,768 ถึง 32,767 หรือ -2,147,483,648 ถึง 2,147,483,647
จำนวนน้อย	สั้น	-32,768 ถึง 32,767
หมายเลขยาว	ยาว	-2,147,483,648 ถึง 2,147,483,647
เลขฐานสิบ	ลอย	1.2E-38 ถึง 3.4E + 38 จนถึงทศนิยม 6 ตำแหน่ง

ชนิดข้อมูลเหล่านี้เรียกว่าชนิดข้อมูลดั้งเดิมและคุณสามารถใช้ชนิดข้อมูลเหล่านี้เพื่อสร้างชนิดข้อมูลที่ซับซ้อนมากขึ้นซึ่งเรียกว่าชนิดข้อมูลที่ผู้ใช้กำหนดเองเช่นสตริงจะเป็นลำดับของอักขระ

ประเภทข้อมูล Python

Python มีข้อมูลมาตรฐานห้าประเภท แต่ภาษาโปรแกรมนี้ไม่ได้ใช้ประโยชน์จากคำสำคัญใด ๆ ในการระบุประเภทข้อมูลเฉพาะ แต่ Python ฉลาดพอที่จะเข้าใจประเภทข้อมูลที่กำหนดโดยอัตโนมัติ

Numbers
String
List
Tuple
Dictionary

ในที่นี้ Number จะระบุตัวเลขทุกประเภทรวมทั้งเลขฐานสิบและสตริงแสดงถึงลำดับของอักขระที่มีความยาวตั้งแต่ 1 อักขระขึ้นไป ในตอนนี้เรามาดำเนินการกับประเภทข้อมูลทั้งสองนี้และข้าม List, Tuple และ Dictionary ซึ่งเป็นประเภทข้อมูลขั้นสูงใน Python

ตัวแปรคือชื่อที่คุณตั้งให้กับตำแหน่งหน่วยความจำคอมพิวเตอร์ซึ่งใช้ในการจัดเก็บค่าในโปรแกรมคอมพิวเตอร์

ตัวอย่างเช่นสมมติว่าคุณต้องการจัดเก็บสองค่า 10 และ 20 ในโปรแกรมของคุณและในระยะต่อมาคุณต้องการใช้สองค่านี้ มาดูกันว่าคุณจะทำอย่างไร นี่คือสามขั้นตอนง่ายๆต่อไปนี้ -

สร้างตัวแปรด้วยชื่อที่เหมาะสม
เก็บค่าของคุณในสองตัวแปรนั้น
ดึงและใช้ค่าที่เก็บไว้จากตัวแปร

การสร้างตัวแปร

เรียกอีกอย่างว่าการสร้างตัวแปร declaring variablesในการเขียนโปรแกรมภาษาซี ภาษาโปรแกรมต่างๆมีวิธีการสร้างตัวแปรภายในโปรแกรมที่แตกต่างกัน ตัวอย่างเช่นการเขียนโปรแกรม C มีวิธีการสร้างตัวแปรง่ายๆดังต่อไปนี้ -

#include <stdio.h>

int main() {
   int a;
   int b;
}

โปรแกรมข้างต้นสร้างตัวแปรสองตัวเพื่อจองตำแหน่งหน่วยความจำสองตำแหน่งพร้อมชื่อ a และ b. เราสร้างตัวแปรเหล่านี้โดยใช้int คีย์เวิร์ดเพื่อระบุตัวแปร data typeซึ่งหมายความว่าเราต้องการเก็บค่าจำนวนเต็มในตัวแปรทั้งสองนี้ ในทำนองเดียวกันคุณสามารถสร้างตัวแปรเพื่อจัดเก็บได้long, float, charหรือประเภทข้อมูลอื่น ๆ ตัวอย่างเช่น -

/* variable to store long value */
long a;

/* variable to store float value */
float b;

คุณสามารถสร้างตัวแปรประเภทที่คล้ายกันได้โดยใส่ไว้ในบรรทัดเดียว แต่คั่นด้วยลูกน้ำดังนี้ -

#include <stdio.h>

int main() {
   int a, b;
}

ด้านล่างนี้เป็นประเด็นสำคัญเกี่ยวกับตัวแปรที่คุณต้องจำไว้ -

ชื่อตัวแปรสามารถเก็บค่าประเภทเดียวได้ ตัวอย่างเช่นถ้าตัวแปรa ได้ถูกกำหนดไว้ int จากนั้นสามารถจัดเก็บได้เฉพาะจำนวนเต็ม
การเขียนโปรแกรมภาษาซีต้องการการสร้างตัวแปรกล่าวคือการประกาศก่อนการใช้งานในโปรแกรมของคุณ คุณไม่สามารถใช้ชื่อตัวแปรในโปรแกรมของคุณได้โดยไม่ต้องสร้างแม้ว่าภาษาโปรแกรมเช่น Python จะอนุญาตให้คุณใช้ชื่อตัวแปรได้โดยไม่ต้องสร้าง
คุณสามารถใช้ชื่อตัวแปรภายในโปรแกรมของคุณได้เพียงครั้งเดียว ตัวอย่างเช่นถ้าตัวแปรa ถูกกำหนดให้เก็บค่าจำนวนเต็มแล้วคุณไม่สามารถกำหนดได้ a อีกครั้งเพื่อจัดเก็บค่าประเภทอื่น ๆ
มีภาษาโปรแกรมเช่น Python, PHP, Perl และอื่น ๆ ซึ่งไม่ต้องการให้คุณระบุประเภทข้อมูลในขณะสร้างตัวแปร ดังนั้นคุณสามารถจัดเก็บจำนวนเต็มจำนวนทศนิยมหรือแบบยาวได้โดยไม่ต้องระบุประเภทข้อมูล
คุณสามารถตั้งชื่อให้กับตัวแปรเช่น age, sex, salary, year1990หรือสิ่งอื่นที่คุณต้องการให้ แต่ภาษาโปรแกรมส่วนใหญ่อนุญาตให้ใช้อักขระที่ จำกัด ในชื่อตัวแปรเท่านั้น สำหรับตอนนี้เราจะแนะนำให้ใช้เท่านั้นa....z, A....Z, 0....9 ในชื่อตัวแปรของคุณและเริ่มต้นชื่อโดยใช้ตัวอักษรเท่านั้นแทนที่จะเป็นตัวเลข
แทบไม่มีภาษาโปรแกรมใดที่อนุญาตให้ขึ้นต้นชื่อตัวแปรด้วยตัวเลข 1990year จะไม่ใช่ชื่อตัวแปรที่ถูกต้องในขณะที่ year1990 หรือ ye1990ar เป็นชื่อตัวแปรที่ถูกต้อง

ภาษาโปรแกรมทุกภาษามีกฎเพิ่มเติมที่เกี่ยวข้องกับตัวแปรและคุณจะได้เรียนรู้เมื่อคุณจะลงรายละเอียดเพิ่มเติมเกี่ยวกับภาษาโปรแกรมนั้น

เก็บค่าในตัวแปร

คุณได้เห็นวิธีที่เราสร้างตัวแปรในส่วนก่อนหน้านี้ ตอนนี้เรามาเก็บค่าบางอย่างในตัวแปรเหล่านั้น -

#include <stdio.h>

int main() {
   int a;
   int b;
   
   a = 10;
   b = 20;
}

โปรแกรมข้างต้นมีคำสั่งเพิ่มเติมสองรายการที่เราจัดเก็บ 10 ในตัวแปร a และ 20 จะถูกเก็บไว้ในตัวแปร b. ภาษาโปรแกรมเกือบทั้งหมดมีวิธีการจัดเก็บค่าในตัวแปรที่คล้ายคลึงกันโดยที่เราเก็บชื่อตัวแปรไว้ทางซ้ายมือของเครื่องหมายเท่ากับ = และค่าใดก็ตามที่เราต้องการเก็บไว้ในตัวแปรเราจะเก็บค่านั้นไว้ทางด้านขวามือ

ตอนนี้เราได้ทำสองขั้นตอนเสร็จสิ้นก่อนอื่นเราสร้างตัวแปรสองตัวจากนั้นเราเก็บค่าที่ต้องการในตัวแปรเหล่านั้น ตอนนี้ตัวแปรa มีค่า 10 และตัวแปร b มีค่า 20 กล่าวอีกนัยหนึ่งเราสามารถพูดได้เมื่อโปรแกรมด้านบนถูกเรียกใช้ตำแหน่งหน่วยความจำที่ชื่อ a จะถือ 10 และตำแหน่งหน่วยความจำ b จะถือ 20.

เข้าถึงค่าที่เก็บไว้ในตัวแปร

หากเราไม่ใช้ค่าที่เก็บไว้ในตัวแปรก็จะไม่มีจุดใดในการสร้างตัวแปรและเก็บค่าไว้ในนั้น เรารู้ว่าโปรแกรมข้างต้นมีสองตัวแปรa และ bและเก็บค่า 10 และ 20 ตามลำดับ ลองพิมพ์ค่าที่เก็บไว้ในสองตัวแปรนี้ ต่อไปนี้เป็นโปรแกรม C ซึ่งพิมพ์ค่าที่เก็บไว้ในตัวแปร -

#include <stdio.h>

int main() {
   int a;
   int b;
   
   a = 10;
   b = 20;
   
   printf( "Value of a = %d\n", a );
   printf( "Value of b = %d\n", b );
}

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Value of a = 10
Value of b = 20

คุณต้องได้เห็น printf()ในบทที่แล้วที่เราเคยใช้มันเพื่อพิมพ์ "Hello, World!" คราวนี้เราใช้มันเพื่อพิมพ์ค่าของตัวแปร เรากำลังใช้ประโยชน์จากไฟล์%dซึ่งจะถูกแทนที่ด้วยค่าของตัวแปรที่กำหนดในคำสั่ง printf () เราสามารถพิมพ์ทั้งสองค่าโดยใช้คำสั่ง printf () เดียวดังนี้ -

#include <stdio.h>

int main() {
   int a;
   int b;
   
   a = 10;
   b = 20;
   
   printf( "Value of a = %d and value of b = %d\n", a, b );
}

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Value of a = 10 and value of b = 20

หากต้องการใช้ float ตัวแปรในการเขียนโปรแกรม C จากนั้นคุณจะต้องใช้ %f แทน %dและหากคุณต้องการพิมพ์ค่าอักขระคุณจะต้องใช้ %c. ในทำนองเดียวกันชนิดข้อมูลที่แตกต่างกันสามารถพิมพ์ได้โดยใช้% และอักขระที่แตกต่างกัน

ตัวแปรใน Java

ต่อไปนี้เป็นโปรแกรมเทียบเท่าที่เขียนด้วยภาษาโปรแกรม Java โปรแกรมนี้จะสร้างตัวแปรสองตัวa และ b และคล้ายกับการเขียนโปรแกรม C มากโดยจะกำหนด 10 และ 20 ให้กับตัวแปรเหล่านี้และในที่สุดก็พิมพ์ค่าของตัวแปรทั้งสองในสองวิธี -

public class DemoJava {
   public static void main(String []args) {
      int a;
      int b;
   
      a = 10;
      b = 20;
   
      System.out.println("Value of a = " + a);
      System.out.println("Value of b = " + b);
      System.out.println("Value of a = " + a + " and value of b = " + b);     
   }
}

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Value of a = 10
Value of b = 20
Value of a = 10 and value of b = 20

ตัวแปรใน Python

ต่อไปนี้เป็นโปรแกรมเทียบเท่าที่เขียนด้วย Python โปรแกรมนี้จะสร้างตัวแปรสองตัวa และ b และในเวลาเดียวกันให้กำหนด 10 และ 20 ในตัวแปรเหล่านั้น

Python ไม่ต้องการให้คุณระบุชนิดข้อมูลในขณะสร้างตัวแปรและไม่จำเป็นต้องสร้างตัวแปรล่วงหน้า

a = 10
b = 20
   
print "Value of a = ", a
print "Value of b = ", b
print "Value of a = ", a, " and value of b = ", b

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Value of a =  10
Value of b =  20
Value of a =  10  and value of b =  20

คุณสามารถใช้ไวยากรณ์ต่อไปนี้ในการเขียนโปรแกรม C และ Java เพื่อประกาศตัวแปรและกำหนดค่าในเวลาเดียวกัน -

#include <stdio.h>

int main() {
   int a = 10;
   int b = 20;
   
   printf( "Value of a = %d and value of b = %d\n", a, b );
}

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Value of a = 10 and value of b = 20

จนถึงตอนนี้เราได้กล่าวถึงแนวคิดสำคัญสองประการที่เรียกว่าตัวแปรและประเภทข้อมูล เราได้กล่าวถึงวิธีการใช้งานint, longและ floatเพื่อระบุประเภทข้อมูลต่างๆ เรายังได้เรียนรู้วิธีตั้งชื่อตัวแปรเพื่อเก็บค่าต่างๆ

แม้ว่าบทนี้จะไม่จำเป็นต้องแยกกันเนื่องจากคำหลักที่สงวนไว้เป็นส่วนหนึ่งของไวยากรณ์การเขียนโปรแกรมขั้นพื้นฐาน แต่เราแยกไว้เพื่ออธิบายตามประเภทข้อมูลและตัวแปรเพื่อให้เข้าใจง่าย

เช่นเดียวกับ int, long และ float มีคำหลักอื่น ๆ อีกมากมายที่รองรับโดยภาษาโปรแกรม C ซึ่งเราจะใช้เพื่อวัตถุประสงค์ที่แตกต่างกัน ภาษาการเขียนโปรแกรมที่แตกต่างกันมีชุดคำหลักที่สงวนไว้แตกต่างกัน แต่มีกฎที่สำคัญและมีอยู่ข้อหนึ่งในภาษาโปรแกรมทั้งหมดที่เราไม่สามารถใช้คำหลักที่สงวนไว้เพื่อตั้งชื่อตัวแปรของเราซึ่งหมายความว่าเราไม่สามารถตั้งชื่อตัวแปรของเราได้int หรือ float แต่คำหลักเหล่านี้สามารถใช้เพื่อระบุประเภทข้อมูลตัวแปรเท่านั้น

ตัวอย่างเช่นหากคุณจะพยายามใช้คีย์เวิร์ดที่สงวนไว้เพื่อวัตถุประสงค์ในการตั้งชื่อตัวแปรคุณจะได้รับข้อผิดพลาดทางไวยากรณ์

#include <stdio.h>

int main() {
   int float;
   float = 10;
   
   printf( "Value of float = %d\n", float);
}

เมื่อคุณคอมไพล์โปรแกรมข้างต้นจะเกิดข้อผิดพลาดดังต่อไปนี้ -

main.c: In function 'main':
main.c:5:8: error: two or more data types in declaration specifiers
   int float;
......

ตอนนี้เรามาตั้งชื่อที่เหมาะสมให้กับตัวแปรจำนวนเต็มของเราจากนั้นโปรแกรมข้างต้นควรรวบรวมและดำเนินการสำเร็จ -

#include <stdio.h>

int main() {
   int count;
   count = 10;

   printf( "Value of count = %d\n", count);
}

การเขียนโปรแกรม C คำสำคัญที่สงวนไว้

นี่คือตารางที่มีคำหลักเกือบทั้งหมดที่รองรับโดยภาษาโปรแกรม C -

อัตโนมัติ	อื่น	ยาว	สวิตซ์
หยุดพัก	enum	ลงทะเบียน	typedef
กรณี	ภายนอก	กลับ	สหภาพแรงงาน
ถ่าน	ลอย	สั้น	ไม่ได้ลงนาม
const	สำหรับ	ลงนาม	เป็นโมฆะ
ดำเนินการต่อ	ไปที่	ขนาดของ	ระเหย
ค่าเริ่มต้น	ถ้า	คงที่	ในขณะที่
ทำ	int	โครงสร้าง	_ บรรจุ
สองเท่า

คีย์เวิร์ดที่สงวนไว้สำหรับการเขียนโปรแกรม Java

นี่คือตารางที่มีคีย์เวิร์ดเกือบทั้งหมดที่รองรับภาษา Java Programming -

บทคัดย่อ	ยืนยัน	บูลีน	หยุดพัก
ไบต์	กรณี	จับ	ถ่าน
ชั้นเรียน	const	ดำเนินการต่อ	ค่าเริ่มต้น
ทำ	สองเท่า	อื่น	enum
ขยาย	สุดท้าย	ในที่สุด	ลอย
สำหรับ	ไปที่	ถ้า	ดำเนินการ
นำเข้า	อินสแตนซ์ของ	int	อินเตอร์เฟซ
ยาว	พื้นเมือง	ใหม่	แพ็คเกจ
เอกชน	มีการป้องกัน	สาธารณะ	กลับ
สั้น	คงที่	เข้มงวด fp	สุดยอด
สวิตซ์	ซิงโครไนซ์	นี้	โยน
พ่น	ชั่วคราว	ลอง	เป็นโมฆะ
ระเหย	ในขณะที่

คำหลักที่สงวนไว้สำหรับการเขียนโปรแกรม Python

นี่คือตารางที่มีคีย์เวิร์ดเกือบทั้งหมดที่รองรับภาษา Python Programming -

และ	ผู้บริหาร	ไม่
ยืนยัน	ในที่สุด	หรือ
หยุดพัก	สำหรับ	ผ่าน
ชั้นเรียน	จาก	พิมพ์
ดำเนินการต่อ	ทั่วโลก	ยก
def	ถ้า	กลับ
เดล	นำเข้า	ลอง
elif	ใน	ในขณะที่
อื่น	คือ	ด้วย
ยกเว้น	แลมด้า	ผลผลิต

เราทราบดีว่าคุณไม่สามารถจดจำคำหลักเหล่านี้ได้ทั้งหมด แต่เราได้ระบุไว้เพื่อวัตถุประสงค์ในการอ้างอิงของคุณและเพื่ออธิบายแนวคิดของ reserved keywords. ดังนั้นโปรดใช้ความระมัดระวังขณะตั้งชื่อตัวแปรของคุณคุณไม่ควรใช้คำหลักที่สงวนไว้สำหรับภาษาโปรแกรมนั้น

ตัวดำเนินการในภาษาโปรแกรมคือสัญลักษณ์ที่บอกให้คอมไพเลอร์หรือล่ามดำเนินการทางคณิตศาสตร์เชิงสัมพันธ์หรือเชิงตรรกะที่เฉพาะเจาะจงและสร้างผลลัพธ์สุดท้าย บทนี้จะอธิบายแนวคิดของoperators และจะนำคุณผ่านตัวดำเนินการทางคณิตศาสตร์และเชิงสัมพันธ์ที่สำคัญที่มีอยู่ใน C, Java และ Python

ตัวดำเนินการเลขคณิต

โปรแกรมคอมพิวเตอร์ใช้กันอย่างแพร่หลายสำหรับการคำนวณทางคณิตศาสตร์ เราสามารถเขียนโปรแกรมคอมพิวเตอร์ซึ่งสามารถคำนวณง่ายๆเช่นการบวกตัวเลขสองตัว (2 + 3) และเรายังสามารถเขียนโปรแกรมซึ่งสามารถแก้สมการที่ซับซ้อนได้เช่น P (x) = x ⁴ + 7x ³ - 5x + 9 หากคุณเคยเป็นนักเรียนที่ยากจนมาก่อนคุณต้องระวังว่าในนิพจน์แรก 2 และ 3 เป็นตัวถูกดำเนินการและ + เป็นตัวดำเนินการ มีแนวคิดที่คล้ายกันในการเขียนโปรแกรมคอมพิวเตอร์

ดูสองตัวอย่างต่อไปนี้ -

2 + 3

P(x) = x⁴ + 7x³ - 5x + 9.

คำสั่งทั้งสองนี้เรียกว่านิพจน์เลขคณิตในภาษาโปรแกรมและ plus, minusที่ใช้ในนิพจน์เหล่านี้เรียกว่าตัวดำเนินการทางคณิตศาสตร์และค่าที่ใช้ในนิพจน์เหล่านี้เช่น 2, 3 และ x เป็นต้นเรียกว่าตัวถูกดำเนินการ ในรูปแบบที่ง่ายที่สุดนิพจน์ดังกล่าวจะให้ผลลัพธ์ที่เป็นตัวเลข

ในทำนองเดียวกันภาษาโปรแกรมจะให้ตัวดำเนินการทางคณิตศาสตร์ต่างๆ ตารางต่อไปนี้แสดงรายการตัวดำเนินการทางคณิตศาสตร์ที่สำคัญบางตัวที่มีอยู่ในโปรแกรมภาษาซี สมมติว่าตัวแปร A ถือ 10 และตัวแปร B ถือ 20 จากนั้น -

ตัวดำเนินการ	คำอธิบาย	ตัวอย่าง
+	เพิ่มสองตัวถูกดำเนินการ	A + B จะให้ 30
-	ลบตัวถูกดำเนินการที่สองจากตัวแรก	A - B จะให้ -10
*	คูณตัวถูกดำเนินการทั้งสอง	A * B จะให้ 200
/	หารเศษด้วยตัวเศษ	B / A จะให้ 2
%	สิ่งนี้ให้ส่วนที่เหลือของการหารจำนวนเต็ม	B% A จะให้ 0

ต่อไปนี้เป็นตัวอย่างง่ายๆของการเขียนโปรแกรม C เพื่อทำความเข้าใจตัวดำเนินการทางคณิตศาสตร์ข้างต้น -

#include <stdio.h>

int main() {
   int a, b, c;
   
   a = 10;
   b = 20;
   
   c = a + b;   
   printf( "Value of c = %d\n", c);
   
   c = a - b;   
   printf( "Value of c = %d\n", c);
   
   c = a * b;   
   printf( "Value of c = %d\n", c);
   
   c = b / a;   
   printf( "Value of c = %d\n", c);
   
   c = b % a;   
   printf( "Value of c = %d\n", c);
}

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Value of c = 30
Value of c = -10
Value of c = 200
Value of c = 2
Value of c = 0

ตัวดำเนินการเชิงสัมพันธ์

พิจารณาสถานการณ์ที่เราสร้างตัวแปรสองตัวและกำหนดค่าบางอย่างดังนี้ -

A = 20
B = 10

ที่นี่เห็นได้ชัดว่าตัวแปร A มีค่ามากกว่า B ดังนั้นเราต้องการความช่วยเหลือจากสัญลักษณ์บางอย่างเพื่อเขียนนิพจน์ดังกล่าวซึ่งเรียกว่านิพจน์เชิงสัมพันธ์ ถ้าเราใช้โปรแกรมภาษาซีจะเขียนดังนี้ -

(A > B)

ที่นี่เราใช้สัญลักษณ์> และเรียกว่าตัวดำเนินการเชิงสัมพันธ์และในรูปแบบที่ง่ายที่สุดพวกมันสร้างผลลัพธ์บูลีนซึ่งหมายความว่าผลลัพธ์จะเป็นจริงหรือเท็จ ในทำนองเดียวกันภาษาโปรแกรมจะให้ตัวดำเนินการเชิงสัมพันธ์ต่างๆ ตารางต่อไปนี้แสดงรายการตัวดำเนินการเชิงสัมพันธ์ที่สำคัญบางตัวที่มีอยู่ในโปรแกรมภาษาซี สมมติตัวแปรA ถือ 10 และตัวแปร B ถือ 20 แล้ว -

ตัวดำเนินการ	คำอธิบาย	ตัวอย่าง
==	ตรวจสอบว่าค่าของตัวถูกดำเนินการสองค่าเท่ากันหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง	(A == B) ไม่เป็นความจริง
! =	ตรวจสอบว่าค่าของตัวถูกดำเนินการสองค่าเท่ากันหรือไม่หากค่าไม่เท่ากันเงื่อนไขจะกลายเป็นจริง	(A! = B) เป็นจริง
>	ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายมากกว่าค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง	(A> B) ไม่เป็นความจริง
<	ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายน้อยกว่าค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง	(A <B) เป็นจริง
> =	ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายมากกว่าหรือเท่ากับค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง	(A> = B) ไม่เป็นความจริง
<=	ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายน้อยกว่าหรือเท่ากับค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง	(A <= B) เป็นจริง

ที่นี่เราจะแสดงตัวอย่างหนึ่งของการเขียนโปรแกรม C ซึ่งใช้ประโยชน์จาก if conditional statement. แม้ว่าข้อความนี้จะถูกกล่าวถึงในอีกบทในภายหลัง แต่ในระยะสั้นเราใช้if statement เพื่อตรวจสอบเงื่อนไขและถ้าเงื่อนไขนั้นเป็นจริงร่างกายของ if statement จะถูกประหารชีวิตมิฉะนั้นร่างของ if statement ถูกข้ามไป

#include <stdio.h>

int main() {
   int a, b;
   
   a = 10;
   b = 20;
   
   /* Here we check whether a is equal to 10 or not */
   if( a == 10 ) {
	   
      /* if a is equal to 10 then this body will be executed */
      printf( "a is equal to 10\n");
   }
   
   /* Here we check whether b is equal to 10 or not */
   if( b == 10 ) {
	
      /* if b is equal to 10 then this body will be executed */
      printf( "b is equal to 10\n");
   }
   
   /* Here we check if a is less b than or not */
   if( a < b ) {
	
      /* if a is less than b then this body will be executed */
      printf( "a is less than b\n");
   }
   
   /* Here we check whether a and b are not equal */
   if( a != b ) {
	
      /* if a is not equal to b then this body will be executed */
      printf( "a is not equal to b\n");
   }
}

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

a is equal to 10
a is less than b
a is not equal to b

ตัวดำเนินการทางตรรกะ

ตัวดำเนินการทางตรรกะมีความสำคัญมากในภาษาโปรแกรมใด ๆ และช่วยให้เราตัดสินใจตามเงื่อนไขบางประการ สมมติว่าเราต้องการรวมผลลัพธ์ของสองเงื่อนไขจากนั้นตัวดำเนินการตรรกะ AND และ OR จะช่วยเราในการสร้างผลลัพธ์สุดท้าย

ตารางต่อไปนี้แสดงตัวดำเนินการทางตรรกะทั้งหมดที่ภาษา C สนับสนุน สมมติตัวแปรA ถือ 1 และตัวแปร B ถือ 0 แล้ว -

ตัวดำเนินการ	คำอธิบาย	ตัวอย่าง
&&	เรียกว่าตัวดำเนินการ Logical AND หากตัวถูกดำเนินการทั้งสองไม่ใช่ศูนย์เงื่อนไขจะกลายเป็นจริง	(A && B) เป็นเท็จ
\|\|	เรียกว่า Logical OR Operator หากตัวถูกดำเนินการสองตัวใดตัวหนึ่งไม่เป็นศูนย์เงื่อนไขจะกลายเป็นจริง	(A \|\| B) เป็นจริง
!	เรียกว่า Logical NOT Operator ใช้เพื่อย้อนกลับสถานะตรรกะของตัวถูกดำเนินการ หากเงื่อนไขเป็นจริงตัวดำเนินการ Logical NOT จะสร้างเท็จ	! (A && B) เป็นเรื่องจริง

ลองใช้ตัวอย่างต่อไปนี้เพื่อทำความเข้าใจตัวดำเนินการทางตรรกะทั้งหมดที่มีในโปรแกรมภาษาซี -

#include <stdio.h>

int main() {
   int a = 1;
   int b = 0;

   if ( a && b ) {
	
      printf("This will never print because condition is false\n" );
   }
   if ( a || b ) {
	
      printf("This will be printed print because condition is true\n" );
   }
   if ( !(a && b) ) {
	
      printf("This will be printed print because condition is true\n" );
   }
}

เมื่อคุณคอมไพล์และรันโปรแกรมข้างต้นโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้ -

This will be printed print because condition is true
This will be printed print because condition is true

ตัวดำเนินการใน Java

ต่อไปนี้เป็นโปรแกรมเทียบเท่าที่เขียนด้วย Java การเขียนโปรแกรม C และ Java จัดเตรียมชุดตัวดำเนินการและคำสั่งเงื่อนไขที่เหมือนกันเกือบทั้งหมด โปรแกรมนี้จะสร้างตัวแปรสองตัวa และ bคล้ายกับการเขียนโปรแกรม C มากจากนั้นเรากำหนด 10 และ 20 ในตัวแปรเหล่านี้และสุดท้ายเราจะใช้ตัวดำเนินการทางคณิตศาสตร์และเชิงสัมพันธ์ที่แตกต่างกัน -

คุณสามารถลองรันโปรแกรมต่อไปนี้เพื่อดูผลลัพธ์ซึ่งจะต้องเหมือนกับผลลัพธ์ที่สร้างขึ้นจากตัวอย่างข้างต้น

public class DemoJava {
   public static void main(String []args) {
      int a, b, c;
   
      a = 10;
      b = 20;
   
      c = a + b;   
      System.out.println("Value of c = " + c );
   
      c = a - b;
      System.out.println("Value of c = " + c );
   
      c = a * b;   
      System.out.println("Value of c = " + c );
   
      c = b / a;   
      System.out.println("Value of c = " + c );
   
      c = b % a;   
      System.out.println("Value of c = " + c );
      
      if( a == 10 ) {
		
         System.out.println("a is equal to 10" );
      }
   }
}

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Value of c = 30
Value of c = -10
Value of c = 200
Value of c = 2
Value of c = 0
a is equal to 10

ตัวดำเนินการใน Python

ต่อไปนี้เป็นโปรแกรมเทียบเท่าที่เขียนด้วย Python โปรแกรมนี้จะสร้างตัวแปรสองตัวa และ bและในเวลาเดียวกันให้กำหนด 10 และ 20 ในตัวแปรเหล่านั้น โชคดีที่การเขียนโปรแกรม C และภาษาโปรแกรม Python มีชุดตัวดำเนินการที่เหมือนกันเกือบทั้งหมด โปรแกรมนี้จะสร้างตัวแปรสองตัวa และ bคล้ายกับการเขียนโปรแกรม C มากจากนั้นเรากำหนด 10 และ 20 ในตัวแปรเหล่านี้และสุดท้ายเราจะใช้ตัวดำเนินการทางคณิตศาสตร์และเชิงสัมพันธ์ที่แตกต่างกัน

a = 10
b = 20
   
c = a + b   
print "Value of c = ", c

c = a - b   
print "Value of c = ", c

c = a * b   
print "Value of c = ", c

c = a / b   
print "Value of c = ", c

c = a % b   
print "Value of c = ", c

if( a == 10 ):
   print "a is equal to 10"

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Value of c =  30
Value of c =  -10
Value of c =  200
Value of c =  0
Value of c =  10
a is equal to 10

การตัดสินใจมีความสำคัญต่อการเขียนโปรแกรมคอมพิวเตอร์ จะมีหลายสถานการณ์ที่คุณจะได้รับสองตัวเลือกขึ้นไปและคุณจะต้องเลือกตัวเลือกตามเงื่อนไขที่กำหนด ตัวอย่างเช่นเราต้องการพิมพ์คำพูดเกี่ยวกับนักเรียนโดยพิจารณาจากเครื่องหมายที่ปลอดภัยของเขา ต่อไปนี้เป็นสถานการณ์ -

Assume given marks are x for a student:

If given marks are more than 95, then
Student is brilliant

If given marks are less than 30, then
Student is poor

If given marks are less than 95 and more than 30, then
Student is average

ตอนนี้คำถามคือจะเขียนโค้ดโปรแกรมเพื่อจัดการกับสถานการณ์ดังกล่าวได้อย่างไร ภาษาโปรแกรมเกือบทั้งหมดให้คำสั่งเงื่อนไขที่ทำงานตามแผนภาพการไหลต่อไปนี้ -

มาเขียนโปรแกรม C ด้วยความช่วยเหลือของ if conditional statements เพื่อแปลงสถานการณ์ที่กำหนดข้างต้นเป็นรหัสการเขียนโปรแกรม -

#include <stdio.h>

int main() {
   int x = 45;
   
   if( x > 95) {
	
      printf( "Student is brilliant\n");
   }
   if( x < 30) {
	
      printf( "Student is poor\n");
   }
   if( x < 95 && x > 30 ) {
	
      printf( "Student is average\n");
   }
}

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Student is average

โปรแกรมข้างต้นใช้ if conditional statements. ที่นี่ที่แรกif statementตรวจสอบว่าเงื่อนไขที่กำหนดเช่นตัวแปร x มีค่ามากกว่า 95 หรือไม่และหากพบว่าเงื่อนไขเป็นจริงระบบจะป้อนเนื้อความเงื่อนไขเพื่อดำเนินการคำสั่งที่กำหนด ที่นี่เรามีคำสั่งprintf () เพียงคำสั่งเดียวเพื่อพิมพ์คำพูดเกี่ยวกับนักเรียน

ในทำนองเดียวกันที่สอง if statementได้ผล ประการที่สามif statement ถูกดำเนินการที่นี่เรามีสองเงื่อนไขต่อไปนี้ -

เงื่อนไขแรกคือ x > 95
เงื่อนไขที่สองคือ x < 30

คอมพิวเตอร์จะประเมินทั้งสองเงื่อนไขที่กำหนดจากนั้นผลลัพธ์โดยรวมจะถูกรวมเข้ากับความช่วยเหลือของตัวดำเนินการไบนารี &&. หากผลลัพธ์สุดท้ายเป็นจริงคำสั่งเงื่อนไขจะถูกดำเนินการมิฉะนั้นจะไม่มีการดำเนินการคำสั่งใด ๆ

บทช่วยสอนนี้จะให้แนวคิดพื้นฐานเกี่ยวกับรูปแบบต่างๆ if statements และข้อมูลเบื้องต้นเกี่ยวกับ switchคำสั่งที่มีอยู่ในภาษาโปรแกรม C ภาษาการเขียนโปรแกรมที่แตกต่างกันมีข้อความประกอบการตัดสินใจประเภทต่างๆ แต่แนวคิดพื้นฐานยังคงเหมือนเดิมตามที่อธิบายไว้ในบทช่วยสอนนี้

if ... else คำสั่ง

อัน if ตามด้วยคำสั่งก็ได้ elseคำสั่งซึ่งดำเนินการเมื่อนิพจน์บูลีนเป็นเท็จ ไวยากรณ์ของไฟล์if...else คำสั่งในการเขียนโปรแกรมภาษาซีคือ -

if(boolean_expression) {
   
   /* Statement(s) will execute if the boolean expression is true */
} else {
  
  /* Statement(s) will execute if the boolean expression is false */
}

ไวยากรณ์ข้างต้นสามารถแสดงในรูปแบบของโฟลว์ไดอะแกรมดังที่แสดงด้านล่าง -

อัน if...elseคำสั่งมีประโยชน์เมื่อเราต้องตัดสินใจจากสองทางเลือก ตัวอย่างเช่นหากนักเรียนได้คะแนนมากกว่า 95 แสดงว่านักเรียนนั้นเก่งไม่เช่นนั้นจะไม่สามารถเข้ารหัสสถานการณ์ดังกล่าวได้ดังนี้ -

#include <stdio.h>

int main() {
   int x = 45;
   
   if( x > 95) {
	
      printf( "Student is brilliant\n");
   } else {
      printf( "Student is not brilliant\n");
   }
}

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Student is not brilliant

if ... elseif ... else คำสั่ง

อัน if ตามด้วยคำสั่งก็ได้ else if...else คำสั่งซึ่งมีประโยชน์มากในการทดสอบเงื่อนไขต่างๆ

ขณะใช้งาน if, else if, else มีบางประเด็นที่ควรทราบ -

อัน if สามารถมีศูนย์หรือหนึ่ง else's และมันจะต้องมาหลังจาก else if.
อัน if สามารถมีศูนย์ถึงมาก else…if's และพวกเขาต้องมาก่อน else.
ครั้งเดียว else…if ประสบความสำเร็จไม่มีที่เหลือ else…if's หรือ else's จะถูกทดสอบ

ไวยากรณ์ของไฟล์ if...else if...else คำสั่งในการเขียนโปรแกรมภาษาซีคือ -

if(boolean_expression 1) {

   /* Executes when the boolean expression 1 is true */
}
else if( boolean_expression 2) {

   /* Executes when the boolean expression 2 is true */
}
else if( boolean_expression 3) {

   /* Executes when the boolean expression 3 is true */
} else {
   
   /* Executes when the none of the above condition is true */
}

ตอนนี้ด้วยความช่วยเหลือของ if...elseif...else คำสั่งโปรแกรมแรกสามารถเข้ารหัสได้ดังนี้ -

#include <stdio.h>

int main() {
   int x = 45;
   
   if( x > 95) {
      printf( "Student is brilliant\n");
   } 
   else if( x < 30) {
      printf( "Student is poor\n");
   } 
   else if( x < 95 && x > 30 ) {
      printf( "Student is average\n");
   }
}

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Student is average

คำสั่ง Switch

ก switch คำสั่งเป็นอีกทางเลือกหนึ่งของ if statementsซึ่งช่วยให้สามารถทดสอบตัวแปรเพื่อความเท่าเทียมกับรายการค่าได้ แต่ละค่าเรียกว่า acaseและตัวแปรที่เปิดอยู่จะถูกตรวจสอบสำหรับสวิตช์แต่ละกรณี มีไวยากรณ์ต่อไปนี้ -

switch(expression){
   case ONE :
      statement(s);
      break;
   case TWO:
      statement(s);
      break;
   ......
   
   default :
      statement(s);
}

expression ใช้ใน switchคำสั่งต้องให้ค่าจำนวนเต็มซึ่งจะถูกเปรียบเทียบเพื่อความเท่าเทียมกับกรณีต่างๆที่กำหนด เมื่อใดก็ตามที่ค่านิพจน์ตรงกับค่าเคสเนื้อหาของเคสนั้นจะถูกดำเนินการและสุดท้ายสวิตช์จะถูกยกเลิกโดยใช้ abreakคำให้การ. หากไม่มีการระบุคำสั่งหยุดพักคอมพิวเตอร์จะยังคงดำเนินการคำสั่งอื่น ๆ ที่มีอยู่ด้านล่างต่อไปในกรณีที่ตรงกัน หากไม่มีกรณีใดที่ตรงกันระบบจะดำเนินการตัวเคสเริ่มต้น

ตอนนี้ลองพิจารณาอีกตัวอย่างหนึ่งที่เราต้องการเขียนคำภาษาอังกฤษที่เทียบเท่ากับตัวเลขที่กำหนด จากนั้นสามารถเข้ารหัสได้ดังนี้ -

#include <stdio.h>

int main() {
   int x = 2;
   
   switch( x ){
      case 1 :
         printf( "One\n");
         break;
      case 2 :
         printf( "Two\n");
         break;
      case 3 :
         printf( "Three\n");
         break;
      case 4 :
         printf( "Four\n");
         break;
      default :
         printf( "None of the above...\n");
   }
}

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Two

การตัดสินใจใน Java

ต่อไปนี้เป็นโปรแกรมเทียบเท่าที่เขียนด้วย Java ซึ่งรองรับเช่นกัน if, if...else, if...elseif...elseและ switch งบ

คุณสามารถลองรันโปรแกรมต่อไปนี้เพื่อดูผลลัพธ์ซึ่งต้องเหมือนกับผลลัพธ์ที่สร้างโดยตัวอย่าง C ด้านบน

public class DemoJava {
   public static void main(String []args) {
      int x = 45;
   
      if( x > 95) {
         System.out.println( "Student is brilliant");
      } 
      else if( x < 30) {
         System.out.println( "Student is poor");
      } 
      else if( x < 95 && x > 30 ) {
         System.out.println( "Student is average");
      }
   }
}

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Student is average

การตัดสินใจใน Python

ต่อไปนี้เป็นโปรแกรมเทียบเท่าที่เขียนด้วย Python Python ให้if, if...else, if...elif...elseและ switchงบ ที่นี่คุณต้องทราบว่า Python ไม่ได้ใช้วงเล็บปีกกาสำหรับเนื้อหาแบบมีเงื่อนไข แต่เพียงแค่ระบุเนื้อหาของบล็อกโดยใช้การเยื้องของข้อความ

คุณสามารถลองรันโปรแกรมต่อไปนี้เพื่อดูผลลัพธ์ -

x = 45

if x > 95:
   print "Student is brilliant"
elif x < 30:
   print "Student is poor"
elif x < 95 and x > 30:
   print "Student is average"

print "The end"

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Student is average
The end

ลองพิจารณาสถานการณ์เมื่อคุณต้องการพิมพ์ Hello, World!ห้าครั้ง. นี่คือโปรแกรม C ง่ายๆที่จะทำเช่นเดียวกัน -

#include <stdio.h>

int main() {
   printf( "Hello, World!\n");
   printf( "Hello, World!\n");
   printf( "Hello, World!\n");
   printf( "Hello, World!\n");
   printf( "Hello, World!\n");
}

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!

มันง่ายมาก แต่ลองพิจารณาสถานการณ์อื่นเมื่อคุณต้องการเขียนอีกครั้ง Hello, World!พันครั้ง เราไม่สามารถเขียนคำสั่ง printf () เป็นพัน ๆ ครั้งได้อย่างแน่นอน ภาษาโปรแกรมเกือบทั้งหมดมีแนวคิดที่เรียกว่าloopซึ่งช่วยในการดำเนินการคำสั่งอย่างน้อยหนึ่งรายการได้ตามจำนวนครั้งที่ต้องการ ภาษาโปรแกรมระดับสูงทั้งหมดมีรูปแบบต่างๆของการวนซ้ำซึ่งสามารถใช้เพื่อดำเนินการคำสั่งหนึ่งหรือหลายคำสั่งซ้ำ ๆ

มาเขียนโปรแกรม C ด้านบนด้วยความช่วยเหลือของไฟล์ while loop และต่อไปเราจะพูดถึงวิธีการทำงานของลูปนี้

#include <stdio.h>

int main() {
   int i = 0;
   
   while ( i < 5 ) {
      printf( "Hello, World!\n");
      i = i + 1;
   }
}

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!

โปรแกรมข้างต้นใช้ประโยชน์จากไฟล์ while loopซึ่งใช้เพื่อดำเนินการชุดคำสั่งการเขียนโปรแกรมที่อยู่ภายใน {.... } ขั้นแรกให้คอมพิวเตอร์ตรวจสอบว่าเงื่อนไขที่กำหนดเช่นตัวแปร "a" น้อยกว่า 5 หรือไม่และหากพบว่าเงื่อนไขเป็นจริงระบบจะป้อน loop body เพื่อดำเนินการตามคำสั่งที่กำหนด ที่นี่เรามีสองคำสั่งต่อไปนี้ในเนื้อวน -

คำสั่งแรกคือฟังก์ชัน printf ()ซึ่งพิมพ์ Hello World!
คำสั่งที่สองคือi = i + 1ซึ่งใช้เพื่อเพิ่มค่าของตัวแปรi

หลังจากดำเนินการคำสั่งทั้งหมดที่ระบุใน loop body แล้วคอมพิวเตอร์จะกลับไปที่ while (i <5) และเงื่อนไขที่กำหนด (i <5) จะถูกตรวจสอบอีกครั้งและลูปจะถูกดำเนินการอีกครั้งหากเงื่อนไขนั้นเป็นจริง กระบวนการนี้ซ้ำจนกว่าเงื่อนไขที่กำหนดจะยังคงเป็นจริงซึ่งหมายความว่าตัวแปร "a" มีค่าน้อยกว่า 5

สรุปได้ว่าคำสั่งวนซ้ำช่วยให้เราดำเนินการคำสั่งหรือกลุ่มของคำสั่งได้หลายครั้ง ด้านล่างเป็นรูปแบบทั่วไปของคำสั่งวนซ้ำในภาษาโปรแกรมส่วนใหญ่ -

บทช่วยสอนนี้ออกแบบมาเพื่อนำเสนอแนวคิดพื้นฐานของการเขียนโปรแกรมให้กับผู้ที่ไม่ใช่โปรแกรมเมอร์ดังนั้นเรามาพูดถึงลูปที่สำคัญที่สุดสองประการที่มีอยู่ในภาษาโปรแกรมซี เมื่อคุณชัดเจนเกี่ยวกับลูปทั้งสองนี้แล้วคุณสามารถเลือกแบบฝึกหัดการเขียนโปรแกรม C หรือหนังสืออ้างอิงและตรวจสอบลูปอื่น ๆ ที่มีอยู่ใน C และวิธีการทำงาน

ในขณะที่วนซ้ำ

ก while loop ที่มีอยู่ในภาษา C Programming มีไวยากรณ์ต่อไปนี้ -

while ( condition ) {
   /*....while loop body ....*/
}

โค้ดด้านบนสามารถแสดงในรูปแบบของโฟลว์ไดอะแกรมดังที่แสดงด้านล่าง -

ประเด็นสำคัญต่อไปนี้ควรสังเกตเกี่ยวกับ while loop -

ห่วงขณะเริ่มต้นด้วยคำสำคัญ while ตามด้วย condition อยู่ใน ()

นอกเหนือจากคำสั่ง while () คุณจะมีเนื้อหาของลูปที่อยู่ในวงเล็บปีกกา {...}.
ร่างกายของลูปในขณะที่สามารถมีซอร์สโค้ดบรรทัดหนึ่งหรือหลายบรรทัดเพื่อดำเนินการซ้ำ ๆ
หากส่วนของห่วงขณะมีเส้นเดียวแสดงว่าเป็นทางเลือกที่จะใช้วงเล็บปีกกา {...}.
ลูปในขณะที่ยังคงดำเนินการกับร่างกายจนกว่าจะได้รับ conditionถือเป็นความจริง ทันทีที่เงื่อนไขกลายเป็นเท็จ while ลูปจะออกมาและดำเนินการต่อจากคำสั่งถัดไปทันทีหลังจากเนื้อหาลูป while
เงื่อนไขมักเป็นคำสั่งเชิงสัมพันธ์ซึ่งประเมินว่าเป็นจริงหรือเท็จ ค่าที่เท่ากับศูนย์จะถือว่าเป็นเท็จและค่าที่ไม่ใช่ศูนย์จะทำงานเหมือนจริง

ทำ ... ในขณะที่ห่วง

ลูปในขณะที่ตรวจสอบเงื่อนไขที่กำหนดก่อนที่จะรันคำสั่งใด ๆ ที่ให้ไว้ในส่วนของร่างกาย การเขียนโปรแกรม C จัดให้มีการวนซ้ำอีกรูปแบบหนึ่งเรียกว่าdo...whileที่อนุญาตให้ดำเนินการวนรอบก่อนที่จะตรวจสอบเงื่อนไขที่กำหนด มีไวยากรณ์ต่อไปนี้ -

do {
   /*....do...while loop body ....*/
} 
while ( condition );

โค้ดด้านบนสามารถแสดงในรูปแบบของโฟลว์ไดอะแกรมดังที่แสดงด้านล่าง -

หากคุณจะเขียนตัวอย่างข้างต้นโดยใช้ do...while วนแล้ว Hello, World จะให้ผลลัพธ์เดียวกัน -

#include <stdio.h>

int main() {
   int i = 0;
   
   do {
      printf( "Hello, World!\n");
      i = i + 1;
   }
   while ( i < 5 );
}

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!

คำสั่งแบ่ง

เมื่อ breakพบคำสั่งภายในลูปการวนซ้ำจะถูกยกเลิกทันทีและการควบคุมโปรแกรมจะดำเนินการต่อที่คำสั่งถัดไปตามลูป ไวยากรณ์สำหรับbreak คำสั่งใน C มีดังนี้ -

break;

ก break คำสั่งสามารถแสดงในรูปแบบของแผนภาพการไหลดังที่แสดงด้านล่าง -

โปรแกรมต่อไปนี้เป็นโปรแกรมข้างต้น แต่จะออกมาหลังจากพิมพ์ Hello World! สามครั้งเท่านั้น -

#include <stdio.h>

int main() {
   int i = 0;
   do {
      printf( "Hello, World!\n");
      i = i + 1;
      
      if( i == 3 ) {
         break;
      }
   }
   while ( i < 5 );
}

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Hello, World!
Hello, World!
Hello, World!

คำสั่งต่อ

continue คำสั่งในการเขียนโปรแกรมภาษาซีทำงานคล้ายกับ breakคำให้การ. แทนที่จะบังคับให้เลิกจ้างcontinueบังคับให้การวนซ้ำครั้งต่อไปเกิดขึ้นโดยข้ามรหัสใด ๆ ที่อยู่ระหว่าง ไวยากรณ์สำหรับcontinue คำสั่งใน C มีดังนี้ -

continue;

ก continue คำสั่งสามารถแสดงในรูปแบบของแผนภาพการไหลดังที่แสดงด้านล่าง -

ต่อไปนี้เป็นตัวแปรของโปรแกรมข้างต้น แต่จะข้ามการพิมพ์เมื่อตัวแปรมีค่าเท่ากับ 3 -

#include <stdio.h>

int main() {
   int i = 0;
   do {
      if( i == 3 ) {
         i = i + 1;
         continue;
      }
      printf( "Hello, World!\n");
      i = i + 1;
   }
   while ( i < 5 );
}

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Hello, World!
Hello, World!
Hello, World!
Hello, World!

ลูปใน Java

ต่อไปนี้เป็นโปรแกรมเทียบเท่าที่เขียนด้วย Java ที่รองรับเช่นกัน while และ do...whileลูป โปรแกรมต่อไปนี้จะพิมพ์ออกมาHello, World! ห้าเท่าในกรณีของการเขียนโปรแกรม C -

public class DemoJava {
   public static void main(String []args) {
      int i = 0;
   
      while ( i < 5 ) {
         System.out.println("Hello, World!");
         i = i + 1;
      }
   }
}

break และ continue คำสั่งในการเขียนโปรแกรม Java ทำงานในลักษณะเดียวกับที่ทำงานในการเขียนโปรแกรม C

ลูปใน Python

ต่อไปนี้เป็นโปรแกรมเทียบเท่าที่เขียนด้วย Python Python ก็รองรับเช่นกันwhile และ do...whileลูป โปรแกรมต่อไปนี้จะพิมพ์ออกมาHello, World!ห้าเท่าของเราในกรณีของการเขียนโปรแกรม C ที่นี่คุณต้องสังเกตว่า Python ไม่ได้ใช้วงเล็บปีกกาสำหรับตัวห่วง แต่เพียงแค่ระบุเนื้อหาของลูปโดยใช้การเยื้องของประโยคคำสั่ง

คุณสามารถลองรันโปรแกรมต่อไปนี้เพื่อดูผลลัพธ์ เพื่อแสดงความแตกต่างเราได้ใช้คำสั่งพิมพ์อีกหนึ่งคำสั่งซึ่งจะดำเนินการเมื่อการวนซ้ำสิ้นสุดลง

i = 0

while (i < 5):
   print "Hello, World!"
   i = i + 1
print "Loop ends"

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Loop ends

break และ continue คำสั่งใน Python ทำงานในลักษณะเดียวกับที่ทำในการเขียนโปรแกรม C

ภาษาโปรแกรมทุกภาษาให้การสนับสนุนสำหรับการจัดการตัวเลขประเภทต่างๆเช่นจำนวนเต็มจำนวนเต็มและตัวเลขทศนิยม C, Java และ Python จัดหมวดหมู่ตัวเลขเหล่านี้ในหลายประเภทตามลักษณะ

ลองกลับไปตรวจสอบบทประเภทข้อมูลซึ่งเราได้ระบุประเภทข้อมูลหลักที่เกี่ยวข้องกับตัวเลข -

ประเภท	คำสำคัญ	ช่วงค่าซึ่งสามารถแสดงโดยประเภทข้อมูลนี้
จำนวน	int	-32,768 ถึง 32,767 หรือ -2,147,483,648 ถึง 2,147,483,647
จำนวนน้อย	สั้น	-32,768 ถึง 32,767
หมายเลขยาว	ยาว	-2,147,483,648 ถึง 2,147,483,647
เลขฐานสิบ	ลอย	1.2E-38 ถึง 3.4E + 38 จนถึงทศนิยม 6 ตำแหน่ง

ชนิดข้อมูลเหล่านี้เรียกว่าชนิดข้อมูลดั้งเดิมและคุณสามารถใช้ชนิดข้อมูลเหล่านี้เพื่อสร้างชนิดข้อมูลเพิ่มเติมซึ่งเรียกว่าชนิดข้อมูลที่ผู้ใช้กำหนดเอง

เราได้เห็นการดำเนินการทางคณิตศาสตร์และตรรกะต่างๆเกี่ยวกับตัวเลขในระหว่างการอภิปรายเกี่ยวกับตัวดำเนินการ เราจึงรู้วิธีบวกเลขลบเลขหารเลข ฯลฯ

ก่อนอื่นมาดูวิธีการพิมพ์ตัวเลขประเภทต่างๆที่มีอยู่ในภาษาโปรแกรม C -

#include <stdio.h>

int main() {
   short  s;
   int    i;
   long   l;
   float  f;
   double d;

   s = 10;
   i = 1000;
   l = 1000000;
   f = 230.47;
   d = 30949.374;

   printf( "s: %d\n", s);
   printf( "i: %d\n", i);
   printf( "l: %ld\n", l);
   printf( "f: %.3f\n", f);
   printf( "d: %.3f\n", d);
}

ส่วนที่เหลือของการเข้ารหัสนั้นชัดเจนมาก แต่เราใช้ %.3fพิมพ์ float และ double ซึ่งระบุจำนวนหลักหลังทศนิยมที่จะพิมพ์ เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

s: 10
i: 1000
l: 1000000
f: 230.470
d: 30949.374

การดำเนินการทางคณิตศาสตร์เกี่ยวกับตัวเลข

ตารางต่อไปนี้แสดงรายการทางคณิตศาสตร์ในตัวที่มีประโยชน์ต่างๆ functions มีอยู่ในโปรแกรมภาษาซีซึ่งสามารถใช้สำหรับการคำนวณทางคณิตศาสตร์ที่สำคัญต่างๆ

ตัวอย่างเช่นหากคุณต้องการคำนวณรากที่สองของตัวเลขตัวอย่างเช่น 2304 คุณจะมีฟังก์ชันในตัวสำหรับคำนวณรากที่สอง

ซีเนียร์	ฟังก์ชั่นและวัตถุประสงค์
1	double cos(double); ฟังก์ชันนี้ใช้มุม (เป็นคู่) และส่งกลับโคไซน์
2	double sin(double); ฟังก์ชันนี้ใช้มุม (เป็นคู่) และส่งกลับไซน์
3	ตาลคู่ (สองเท่า); ฟังก์ชันนี้รับมุม (เป็นคู่) และส่งกลับแทนเจนต์
4	double log(double); ฟังก์ชันนี้รับจำนวนและส่งกลับบันทึกธรรมชาติของตัวเลขนั้น
5	double pow(double, double); หมายเลขแรกคือตัวเลขที่คุณต้องการเพิ่มและตัวที่สองคือพลังที่คุณต้องการจะเพิ่ม
6	double hypot(double, double); ถ้าคุณส่งฟังก์ชันนี้ไปด้วยความยาวของด้านสองด้านของสามเหลี่ยมมุมฉากฟังก์ชันนี้จะส่งกลับความยาวของด้านตรงข้ามมุมฉาก
7	double sqrt(double); คุณส่งผ่านฟังก์ชันนี้เป็นตัวเลขและส่งกลับค่ารากที่สอง
8	int abs(int); ฟังก์ชันนี้จะส่งคืนค่าสัมบูรณ์ของจำนวนเต็มที่ส่งผ่านไป
9	double fabs(double); ฟังก์ชันนี้จะส่งคืนค่าสัมบูรณ์ของเลขฐานสิบใด ๆ ที่ส่งผ่านไป
10	double floor(double); ค้นหาจำนวนเต็มซึ่งน้อยกว่าหรือเท่ากับอาร์กิวเมนต์ที่ส่งผ่านไป

ต่อไปนี้เป็นตัวอย่างง่ายๆเพื่อแสดงการดำเนินการทางคณิตศาสตร์บางส่วน ในการใช้ฟังก์ชันเหล่านี้คุณต้องรวมไฟล์ส่วนหัวทางคณิตศาสตร์<math.h> ในโปรแกรมของคุณในลักษณะเดียวกับที่คุณรวมไว้ stdio.h -

#include <stdio.h>
#include <math.h>

int main() {
   short  s;
   int    i;
   long   l;
   float  f;
   double d;

   printf( "sin(s): %f\n", sin(10));
   printf( "abs(i): %f\n", abs(1000));
   printf( "floor(f): %f\n", floor(230.47));
   printf( "sqrt(l): %f\n", sqrt(1000000));
   printf( "pow(d, 2): %f\n", pow(2.374, 2));
}

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

sin(s): -0.544021
abs(i): -0.544021
floor(f): 230.000000
sqrt(l): 1000.000000
pow(d, 2): 5.635876

นอกจากการใช้งานข้างต้นแล้วคุณจะใช้ตัวเลขในการนับลูปการแทนค่าสถานะค่าจริงหรือเท็จในการเขียนโปรแกรม C

ตัวเลขใน Java

ต่อไปนี้เป็นโปรแกรมเทียบเท่าที่เขียนด้วย Java Java จัดเตรียมประเภทข้อมูลตัวเลขเกือบทั้งหมดที่มีอยู่ในการเขียนโปรแกรม C

คุณสามารถลองรันโปรแกรมต่อไปนี้เพื่อดูผลลัพธ์ซึ่งเหมือนกับผลลัพธ์ที่สร้างโดยตัวอย่าง C ด้านบน

public class DemoJava {
   public static void main(String []args) {
      short  s;
      int    i;
      long   l;
      float  f;
      double d;

      s = 10;
      i = 1000;
      l = 1000000L;
      f = 230.47f;
      d = 30949.374;

      System.out.format( "s: %d\n", s);
      System.out.format( "i: %d\n", i);
      System.out.format( "l: %d\n", l);
      System.out.format( "f: %f\n", f);
      System.out.format( "d: %f\n", d);
   }
}

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

s: 10
i: 1000
l: 1000000
f: 230.470001
d: 30949.374000

Java ยังมีฟังก์ชันในตัวที่ครบครันสำหรับการคำนวณทางคณิตศาสตร์และคุณสามารถใช้งานได้ในลักษณะเดียวกับที่คุณทำในการเขียนโปรแกรม C

ตัวเลขใน Python

Python แตกต่างจาก C และ Java เล็กน้อย มันจัดหมวดหมู่ตัวเลขในint, long, float และ complex. นี่คือตัวอย่างของตัวเลขใน Python -

int	ยาว	ลอย	ซับซ้อน
10	51924361 ล	0.0	3.14j
100	-0x19323 ล	15.20 น	45.j
-786	0122 ล	-21.9	9.322e-36j
080	0xDEFABCECBDAECBFBAEl	32.3 + จ 18	.876j
-0490	535633629843 ล	-90.	-.6545 + 0J
-0x260	-052318172735 ล	-32.54e100	3e + 26J
0x69	-4721885298529 ล	70.2-E12	4.53e-7j

ต่อไปนี้เป็นโปรแกรมเทียบเท่าที่เขียนด้วย Python -

s = 10
i = 1000
l = 1000000
f = 230.47
d = 30949.374

print "s: ", s
print "i: ", i
print "l: ", l
print "f: ", f
print "d: ", d

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

s:  10
i:  1000
l:  1000000
f:  230.47
d:  30949.374

Python ยังมีฟังก์ชันในตัวที่ครบครันสำหรับการคำนวณทางคณิตศาสตร์และคุณสามารถใช้งานได้ในลักษณะเดียวกับที่คุณใช้ในการเขียนโปรแกรม C

ถ้ามันเป็นเรื่องง่ายที่จะทำงานกับตัวเลขในการเขียนโปรแกรมคอมพิวเตอร์การทำงานกับตัวอักษรก็จะง่ายยิ่งขึ้น อักขระเป็นตัวอักษรธรรมดาเช่น a, b, c, d .... , A, B, C, D, ..... แต่มีข้อยกเว้น ในการเขียนโปรแกรมคอมพิวเตอร์ตัวเลขหลักเดียวเช่น 0, 1, 2, .... และอักขระพิเศษเช่น $,%, +, -.... ฯลฯ จะถือว่าเป็นอักขระและกำหนดให้เป็นประเภทอักขระ ตัวแปรคุณก็ต้องใส่ไว้ข้างในsingle quotes. ตัวอย่างเช่นคำสั่งต่อไปนี้กำหนดตัวแปรชนิดอักขระch และเรากำหนดค่า 'a' ให้กับมัน -

char ch = 'a';

ที่นี่ ch เป็นตัวแปรของประเภทอักขระซึ่งสามารถเก็บอักขระของชุดอักขระของการนำไปใช้งานและ 'a' เรียกว่า character literalหรือค่าคงที่ของอักขระ ไม่ใช่แค่ a, b, c, .... แต่เมื่อมีตัวเลขเช่น 1, 2, 3 .... หรืออักขระพิเศษใด ๆ เช่น!, @, #, #, $, .... จะถูกเก็บไว้ในเครื่องหมายคำพูดเดียว จากนั้นจะถือว่าเป็นอักขระตามตัวอักษรและสามารถกำหนดให้กับตัวแปรประเภทอักขระได้ดังนั้นสิ่งต่อไปนี้จึงเป็นคำสั่งที่ถูกต้อง -

char ch = '1';

ชนิดข้อมูลอักขระใช้หน่วยความจำ 8 บิตซึ่งหมายความว่าคุณสามารถจัดเก็บอะไรก็ได้ในอักขระที่มีค่า ASCII อยู่ระหว่าง -127 ถึง 127 ดังนั้นจึงสามารถเก็บค่าที่แตกต่างกันได้ 256 ค่า ประเภทข้อมูลอักขระสามารถจัดเก็บอักขระใด ๆ ที่มีอยู่บนแป้นพิมพ์ของคุณรวมถึงอักขระพิเศษเช่น!, @, #, #, $,%, ^, &, *, (,), _, +, {,} ฯลฯ

โปรดทราบว่าคุณสามารถเก็บได้เพียงตัวอักษรเดียวหรือตัวเลขหลักเดียวในเครื่องหมายคำพูดเดียวและไม่อนุญาตให้ใช้ตัวอักษรหรือตัวเลขมากกว่าหนึ่งตัวในเครื่องหมายคำพูดเดี่ยว ดังนั้นข้อความต่อไปนี้ไม่ถูกต้องในการเขียนโปรแกรม C -

char ch1 = 'ab';
char ch2 = '10';

ด้านล่างนี้เป็นตัวอย่างง่ายๆซึ่งแสดงวิธีกำหนดกำหนดและพิมพ์อักขระในภาษาโปรแกรม C -

#include <stdio.h>

int main() {
   char  ch1;
   char  ch2;
   char  ch3;
   char  ch4;
   
   ch1 = 'a';      
   ch2 = '1';
   ch3 = '$';
   ch4 = '+';  

   printf( "ch1: %c\n", ch1);
   printf( "ch2: %c\n", ch2);
   printf( "ch3: %c\n", ch3);
   printf( "ch4: %c\n", ch4);
}

ที่นี่เราใช้% c ในการพิมพ์ประเภทข้อมูลอักขระ เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

ch1: a
ch2: 1
ch3: $
ch4: +

ลำดับการหลบหนี

ภาษาโปรแกรมจำนวนมากสนับสนุนแนวคิดที่เรียกว่า Escape Sequence. เมื่ออักขระนำหน้าด้วยแบ็กสแลช (\) จะเรียกว่าลำดับการหลีกเลี่ยงและมีความหมายพิเศษสำหรับคอมไพเลอร์ ตัวอย่างเช่น \ n ในคำสั่งต่อไปนี้เป็นอักขระที่ถูกต้องและเรียกว่าอักขระบรรทัดใหม่ -

char ch = '\n';

ที่นี่ตัวละคร nนำหน้าด้วยแบ็กสแลช (\) ซึ่งมีความหมายพิเศษซึ่งเป็นบรรทัดใหม่ แต่โปรดทราบว่าแบ็กสแลช (\) มีความหมายพิเศษโดยมีอักขระเพียงไม่กี่ตัวเท่านั้น ข้อความต่อไปนี้จะไม่สื่อความหมายใด ๆ ในการเขียนโปรแกรม C และจะถือว่าเป็นคำสั่งที่ไม่ถูกต้อง -

char ch = '\1';

ตารางต่อไปนี้แสดงรายการลำดับการหลีกเลี่ยงที่มีอยู่ในโปรแกรมภาษาซี -

ลำดับการหลบหนี	คำอธิบาย
\ t	แทรกแท็บในข้อความที่จุดนี้
\ b	แทรก backspace ในข้อความ ณ จุดนี้
\ n	แทรกขึ้นบรรทัดใหม่ในข้อความ ณ จุดนี้
\ r	แทรกการกลับแคร่ในข้อความ ณ จุดนี้
\ ฉ	แทรกฟีดแบบฟอร์มในข้อความ ณ จุดนี้
\ '	แทรกอักขระเครื่องหมายคำพูดเดี่ยวในข้อความ ณ จุดนี้
\ "	แทรกอักขระอัญประกาศคู่ในข้อความ ณ จุดนี้
\\	แทรกอักขระแบ็กสแลชในข้อความ ณ จุดนี้

ตัวอย่างต่อไปนี้แสดงวิธีที่คอมไพลเลอร์ตีความลำดับการหลีกเลี่ยงในคำสั่งพิมพ์ -

#include <stdio.h>

int main() {
   char  ch1;
   char  ch2;
   char  ch3;
   char  ch4;
   
   ch1 = '\t';      
   ch2 = '\n';

   printf( "Test for tabspace %c and a newline %c will start here", ch1, ch2);
}

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Test for tabspace     and a newline 
will start here

อักขระใน Java

ต่อไปนี้เป็นโปรแกรมเทียบเท่าที่เขียนด้วย Java Java จัดการประเภทข้อมูลอักขระในลักษณะเดียวกับที่เราเห็นในการเขียนโปรแกรม C อย่างไรก็ตาม Java ให้การสนับสนุนเพิ่มเติมสำหรับการจัดการอักขระ

public class DemoJava {
   public static void main(String []args) {
      char  ch1;
      char  ch2;
      char  ch3;
      char  ch4;
   
      ch1 = 'a';      
      ch2 = '1';
      ch3 = '$';
      ch4 = '+';  

      System.out.format( "ch1: %c\n", ch1);
      System.out.format( "ch2: %c\n", ch2);
      System.out.format( "ch3: %c\n", ch3);
      System.out.format( "ch4: %c\n", ch4);
   }
}

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

ch1:  a
ch2:  1
ch3:  $
ch4:  +

Java ยังสนับสนุนลำดับการหลีกเลี่ยงในลักษณะเดียวกับที่คุณใช้ในการเขียนโปรแกรม C

อักขระใน Python

Python ไม่สนับสนุนประเภทข้อมูลอักขระใด ๆ แต่อักขระทั้งหมดจะถือว่าเป็นสตริงซึ่งเป็นลำดับของอักขระ เราจะศึกษาสตริงในบทที่แยกต่างหาก คุณไม่จำเป็นต้องมีการจัดเรียงพิเศษใด ๆ ในขณะที่ใช้อักขระเดี่ยวใน Python

ต่อไปนี้เป็นโปรแกรมเทียบเท่าที่เขียนด้วย Python -

ch1 = 'a';      
ch2 = '1';
ch3 = '$';
ch4 = '+'; 

print "ch1: ", ch1
print "ch2: ", ch2
print "ch3: ", ch3
print "ch4: ", ch4

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

ch1:  a
ch2:  1
ch3:  $
ch4:  +

Python สนับสนุนลำดับการหลบหนีในลักษณะเดียวกับที่คุณใช้ในการเขียนโปรแกรม C

พิจารณาสถานการณ์ที่เราต้องจัดเก็บตัวเลขจำนวนเต็มห้าตัว หากเราใช้แนวคิดเรื่องตัวแปรและประเภทข้อมูลอย่างง่ายของการเขียนโปรแกรมเราจำเป็นต้องมีตัวแปรห้าตัวของint ประเภทข้อมูลและโปรแกรมจะเป็นดังนี้ -

#include <stdio.h>

int main() {
   int number1;
   int number2;
   int number3;
   int number4;
   int number5;
   
   number1 = 10;      
   number2 = 20;   
   number3 = 30;   
   number4 = 40; 
   number5 = 50;     

   printf( "number1: %d\n", number1);
   printf( "number2: %d\n", number2);
   printf( "number3: %d\n", number3);
   printf( "number4: %d\n", number4);
   printf( "number5: %d\n", number5);
}

มันง่ายมากเพราะเราต้องเก็บตัวเลขจำนวนเต็มห้าตัว ตอนนี้สมมติว่าเราต้องจัดเก็บตัวเลขจำนวนเต็ม 5,000 ตัว เราจะใช้ 5000 ตัวแปรหรือไม่?

ในการจัดการกับสถานการณ์ดังกล่าวภาษาโปรแกรมเกือบทั้งหมดให้แนวคิดที่เรียกว่า array. อาร์เรย์คือโครงสร้างข้อมูลซึ่งสามารถจัดเก็บคอลเลกชันขนาดคงที่ขององค์ประกอบประเภทข้อมูลเดียวกัน อาร์เรย์ใช้ในการจัดเก็บชุดข้อมูล แต่มักจะมีประโยชน์มากกว่าที่จะคิดว่าอาร์เรย์เป็นชุดของตัวแปรประเภทเดียวกัน

แทนที่จะประกาศตัวแปรเดี่ยวเช่น number1, number2, ... , number99 คุณเพียงแค่ประกาศตัวแปรอาร์เรย์หนึ่งตัว numberของประเภทจำนวนเต็มและใช้ number1 [0], number1 [1] และ ... , number1 [99] เพื่อแทนตัวแปรแต่ละตัว นี่คือ 0, 1, 2, ..... 99 คือindex ที่เกี่ยวข้องกับ var ตัวแปรและถูกใช้เพื่อแสดงองค์ประกอบแต่ละรายการที่มีอยู่ในอาร์เรย์

อาร์เรย์ทั้งหมดประกอบด้วยตำแหน่งหน่วยความจำที่อยู่ติดกัน ที่อยู่ต่ำสุดสอดคล้องกับองค์ประกอบแรกและที่อยู่สูงสุดขององค์ประกอบสุดท้าย

สร้างอาร์เรย์

ในการสร้างตัวแปรอาร์เรย์ใน C โปรแกรมเมอร์จะระบุประเภทขององค์ประกอบและจำนวนองค์ประกอบที่จะจัดเก็บในอาร์เรย์นั้น ด้านล่างเป็นไวยากรณ์ง่ายๆในการสร้างอาร์เรย์ในการเขียนโปรแกรม C -

type arrayName [ arraySize ];

สิ่งนี้เรียกว่าอาร์เรย์มิติเดียว arraySize ต้องเป็นค่าคงที่จำนวนเต็มมากกว่าศูนย์และ typeสามารถเป็นประเภทข้อมูล C ที่ถูกต้องได้ ตัวอย่างเช่นตอนนี้เพื่อประกาศอาร์เรย์ 10 องค์ประกอบที่เรียกว่าnumber ประเภท intใช้คำสั่งนี้ -

int number[10];

ในที่นี้numberคืออาร์เรย์ตัวแปรซึ่งเพียงพอที่จะเก็บตัวเลขจำนวนเต็มได้ถึง 10 ตัว

การเริ่มต้นอาร์เรย์

คุณสามารถเริ่มต้นอาร์เรย์ใน C ทีละรายการหรือใช้คำสั่งเดียวดังต่อไปนี้ -

int number[5] = {10, 20, 30, 40, 50};

จำนวนค่าระหว่างวงเล็บปีกกา {} ต้องไม่เกินจำนวนองค์ประกอบที่เราประกาศสำหรับอาร์เรย์ระหว่างวงเล็บเหลี่ยม []

หากคุณละเว้นขนาดของอาร์เรย์อาร์เรย์ที่ใหญ่พอที่จะรองรับการเริ่มต้นจะถูกสร้างขึ้น ดังนั้นถ้าคุณเขียน -

int number[] = {10, 20, 30, 40, 50};

คุณจะสร้างอาร์เรย์เหมือนกับที่คุณทำในตัวอย่างก่อนหน้านี้ ต่อไปนี้เป็นตัวอย่างในการกำหนดองค์ประกอบเดียวของอาร์เรย์ -

number[4] = 50;

คำสั่งข้างต้นกำหนดองค์ประกอบหมายเลข 5 ในอาร์เรย์ด้วยค่า 50 อาร์เรย์ทั้งหมดมี 0 เป็นดัชนีขององค์ประกอบแรกซึ่งเรียกอีกอย่างว่าดัชนีฐานและดัชนีสุดท้ายของอาร์เรย์จะเป็นขนาดรวมของอาร์เรย์ลบ 1. ภาพต่อไปนี้แสดงการแสดงภาพของอาร์เรย์ที่เรากล่าวถึงข้างต้น -

การเข้าถึงองค์ประกอบอาร์เรย์

องค์ประกอบถูกเข้าถึงโดยการสร้างดัชนีชื่ออาร์เรย์ ทำได้โดยการวางดัชนีขององค์ประกอบไว้ในวงเล็บเหลี่ยมหลังชื่อของอาร์เรย์ ตัวอย่างเช่น -

int var = number[9];

คำสั่งข้างต้นจะนำองค์ประกอบที่ 10 จากอาร์เรย์และกำหนดค่าให้ varตัวแปร. ตัวอย่างต่อไปนี้ใช้แนวคิดทั้งสามที่กล่าวถึงข้างต้น ได้แก่ การสร้างการกำหนดและการเข้าถึงอาร์เรย์ -

#include <stdio.h>
 
int main () {
   int number[10]; /* number is an array of 10 integers */
   int i = 0;
 
   /* Initialize elements of array n to 0 */         
   while( i < 10 ) {
	
      /* Set element at location i to i + 100 */
      number[ i ] = i + 100;
      i = i + 1;
   }
   
   /* Output each array element's value */
   i = 0;
   while( i < 10 ) {
	
      printf("number[%d] = %d\n", i, number[i] );
      i = i + 1;
   }
   
   return 0;
}

เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

number[0] = 100
number[1] = 101
number[2] = 102
number[3] = 103
number[4] = 104
number[5] = 105
number[6] = 106
number[7] = 107
number[8] = 108
number[9] = 109

อาร์เรย์ใน Java

ต่อไปนี้เป็นโปรแกรมเทียบเท่าที่เขียนด้วย Java Java รองรับอาร์เรย์ แต่มีความแตกต่างเล็กน้อยในวิธีสร้างใน Java โดยใช้ไฟล์new ตัวดำเนินการ

public class DemoJava {
   public static void main(String []args) {
      int[] number = new int[10];
      int i = 0;
      
      while( i < 10 ) {
		
         number[ i ] = i + 100;
         i = i + 1;
      }

      i = 0;
      while( i < 10 ) {
         System.out.format( "number[%d] = %d\n", i, number[i] );
         i = i + 1;
      }
   }
}

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

number[0] = 100
number[1] = 101
number[2] = 102
number[3] = 103
number[4] = 104
number[5] = 105
number[6] = 106
number[7] = 107
number[8] = 108
number[9] = 109

อาร์เรย์ (รายการ) ใน Python

Python ไม่มีแนวคิดของ Array แต่ Python จะให้โครงสร้างข้อมูลอื่นที่เรียกว่า listซึ่งมีฟังก์ชันการทำงานที่คล้ายกับอาร์เรย์ในภาษาอื่น ๆ

ต่อไปนี้เป็นโปรแกรมเทียบเท่าที่เขียนด้วย Python -

# Following defines an empty list.
number = []
i = 0

while i < 10:
   # Appending elements in the list
   number.append(i + 100)
   i = i + 1

i = 0
while i < 10:
   # Accessing elements from the list
   print "number[", i,  "] = ", number[ i ]
   i = i + 1

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

number[ 0 ] =  100
number[ 1 ] =  101
number[ 2 ] =  102
number[ 3 ] =  103
number[ 4 ] =  104
number[ 5 ] =  105
number[ 6 ] =  106
number[ 7 ] =  107
number[ 8 ] =  108
number[ 9 ] =  109

ในระหว่างการอภิปรายของเราเกี่ยวกับ charactersเราได้เรียนรู้ว่าประเภทข้อมูลอักขระเกี่ยวข้องกับอักขระตัวเดียวและคุณสามารถกำหนดอักขระใดก็ได้จากแป้นพิมพ์ของคุณไปยังตัวแปรประเภทอักขระ

ตอนนี้เรามาดูสถานการณ์ที่เราต้องเก็บอักขระมากกว่าหนึ่งตัวไว้ในตัวแปร เราได้เห็นแล้วว่าการเขียนโปรแกรมภาษาซีไม่อนุญาตให้เก็บอักขระมากกว่าหนึ่งตัวในตัวแปรชนิดอักขระ ดังนั้นข้อความต่อไปนี้ไม่ถูกต้องในการเขียนโปรแกรม C และทำให้เกิดข้อผิดพลาดทางไวยากรณ์ -

char ch1 = 'ab';
char ch2 = '10';

เรายังได้เห็นวิธีการใช้แนวคิดของ arraysเพื่อเก็บค่าประเภทข้อมูลที่คล้ายกันมากกว่าหนึ่งค่าในตัวแปร นี่คือไวยากรณ์ในการจัดเก็บและพิมพ์ตัวเลขห้าตัวในอาร์เรย์ประเภท int -

#include <stdio.h>

main() {
   int number[5] = {10, 20, 30, 40, 50};
   int i = 0;
        
   while( i < 5 ) {
      printf("number[%d] = %d\n", i, number[i] );
      i = i + 1;
   }
}

เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

number[0] = 10
number[1] = 20
number[2] = 30
number[3] = 40
number[4] = 50

ตอนนี้เรามากำหนดอาร์เรย์ของอักขระห้าตัวในลักษณะเดียวกับที่เราทำสำหรับตัวเลขและลองพิมพ์ -

#include <stdio.h>

main() {
   char ch[5] = {'H', 'e', 'l', 'l', 'o'};
   int i = 0;
        
   while( i < 5 ) {
      printf("ch[%d] = %c\n", i, ch[i] );
      i = i + 1;
   }
}

ที่นี่เราใช้% c เพื่อพิมพ์ค่าอักขระ เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

ch[0] = H
ch[1] = e
ch[2] = l
ch[3] = l
ch[4] = o

หากคุณทำตามตัวอย่างข้างต้นแล้วฉันคิดว่าคุณเข้าใจวิธีการทำงานของสตริงในการเขียนโปรแกรม C เพราะ strings in C are represented as arrays of characters. การเขียนโปรแกรม C ทำให้การกำหนดและการพิมพ์สตริงง่ายขึ้น ลองตรวจสอบตัวอย่างเดียวกันอีกครั้งด้วยไวยากรณ์ที่เรียบง่าย -

#include <stdio.h>

main() {
   char ch[5] = "Hello";
   int i = 0;
    
   /* Print as a complete string */
   printf("String = %s\n", ch);  

   /* Print character by character */
   while( i < 5 ) {
      printf("ch[%d] = %c\n", i, ch[i] );
      i = i + 1;
   }
}

ที่นี่เราใช้% s เพื่อพิมพ์ค่าสตริงเต็มโดยใช้ชื่ออาร์เรย์ chซึ่งเป็นจุดเริ่มต้นของการเก็บแอดเดรสหน่วยความจำ ch ตัวแปรตามที่แสดงด้านล่าง -

แม้ว่าจะมองไม่เห็นจากตัวอย่างข้างต้น แต่โปรแกรม C จะกำหนดอักขระว่างภายใน '\0'เป็นอักขระสุดท้ายของทุกสตริง มันระบุจุดสิ้นสุดของสตริงและหมายความว่าหากคุณต้องการจัดเก็บสตริงอักขระ 5 ตัวในอาร์เรย์คุณต้องกำหนดขนาดอาร์เรย์เป็น 6 เป็นแนวทางปฏิบัติที่ดีแม้ว่า C จะไม่บ่นก็ตาม

หากมีการคอมไพล์และเรียกใช้โค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

String = Hello
ch[0] = H
ch[1] = e
ch[2] = l
ch[3] = l
ch[4] = o

แนวคิดพื้นฐานของสตริง

จากการอภิปรายข้างต้นเราสามารถสรุปประเด็นสำคัญต่อไปนี้เกี่ยวกับสตริงในภาษาโปรแกรมซี -

สตริงใน C แสดงเป็นอาร์เรย์ของอักขระ
เราสามารถสร้างสตริงในการเขียนโปรแกรม C ได้โดยกำหนดอักขระทีละอักขระลงในอาร์เรย์ของอักขระ
เราสามารถสร้างสตริงในการเขียนโปรแกรม C โดยกำหนดสตริงที่สมบูรณ์ที่อยู่ในเครื่องหมายคำพูดคู่
เราสามารถพิมพ์อักขระสายอักขระโดยใช้ตัวห้อยอาร์เรย์หรือสตริงที่สมบูรณ์โดยใช้ชื่ออาร์เรย์โดยไม่มีตัวห้อย
อักขระสุดท้ายของทุกสตริงเป็นอักขระว่างกล่าวคือ ‘\0’.
ภาษาโปรแกรมส่วนใหญ่มีฟังก์ชันในตัวเพื่อจัดการสตริงกล่าวคือคุณสามารถต่อสตริงคุณสามารถค้นหาจากสตริงคุณสามารถแยกสตริงย่อยออกจากสตริงเป็นต้นสำหรับข้อมูลเพิ่มเติมคุณสามารถตรวจสอบบทช่วยสอนโดยละเอียดของเราได้ที่ การเขียนโปรแกรมภาษาซีหรือภาษาโปรแกรมอื่น ๆ

สตริงใน Java

แม้ว่าคุณจะสามารถใช้อาร์เรย์อักขระเพื่อจัดเก็บสตริงได้ แต่ Java เป็นภาษาการเขียนโปรแกรมขั้นสูงและผู้ออกแบบพยายามจัดหาฟังก์ชันเพิ่มเติม Java จัดเตรียมสตริงเป็นชนิดข้อมูลในตัวเหมือนกับชนิดข้อมูลอื่น ๆ หมายความว่าคุณสามารถกำหนดสตริงได้โดยตรงแทนที่จะกำหนดเป็นอาร์เรย์ของอักขระ

ต่อไปนี้เป็นโปรแกรมเทียบเท่าที่เขียนด้วย Java Java ใช้ประโยชน์จากไฟล์new ตัวดำเนินการเพื่อสร้างตัวแปรสตริงดังที่แสดงในโปรแกรมต่อไปนี้

คุณสามารถลองรันโปรแกรมต่อไปนี้เพื่อดูผลลัพธ์ -

public class DemoJava {
   public static void main(String []args) {
      String str = new String("Hello");  
      System.out.println( "String = " + str );
   }
}

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

String = Hello

สตริงใน Python

การสร้างสตริงใน Python ทำได้ง่ายเพียงแค่กำหนดสตริงให้กับตัวแปร Python โดยใช้เครื่องหมายคำพูดเดี่ยวหรือคู่

ด้านล่างนี้เป็นโปรแกรมง่ายๆที่สร้างสองสตริงและพิมพ์โดยใช้ฟังก์ชัน print () -

var1 = 'Hello World!'
var2 = "Python Programming"

print "var1 = ", var1
print "var2 = ", var2

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

var1 =  Hello World!
var2 =  Python Programming

Python ไม่รองรับประเภทอักขระ สิ่งเหล่านี้ถือว่าเป็นสตริงที่มีความยาวหนึ่งดังนั้นจึงถือว่าเป็นสตริงย่อยด้วย

ในการเข้าถึงสตริงย่อยให้ใช้วงเล็บเหลี่ยมสำหรับการแบ่งส่วนพร้อมกับดัชนีหรือดัชนีเพื่อรับสตริงย่อยของคุณ ดูส่วนรหัสต่อไปนี้ -

var1 = 'Hello World!'
var2 = "Python Programming"

print "var1[0]: ", var1[0]
print "var2[1:5]: ", var2[1:5]

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

var1[0]:  H
var2[1:5]:  ytho

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

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

เริ่มต้นด้วยโปรแกรมที่เราจะกำหนดอาร์เรย์ของตัวเลขสองอาร์เรย์แล้วจากแต่ละอาร์เรย์เราจะพบจำนวนที่มากที่สุด ด้านล่างนี้เป็นขั้นตอนในการค้นหาจำนวนสูงสุดจากชุดตัวเลขที่กำหนด -

1. Get a list of numbers L₁, L₂, L₃....L_N
2. Assume L₁ is the largest, Set max = L₁
3. Take next number L_i from the list and do the following
4.    If max is less than L_i
5.       Set max = L_i
6.    If L_i is last number from the list then
7.       Print value stored in max and come out
8. Else prepeat same process starting from step 3

มาแปลโปรแกรมข้างต้นเป็นภาษาซี -

#include <stdio.h>

int main() {
   int set1[5] = {10, 20, 30, 40, 50};
   int set2[5] = {101, 201, 301, 401, 501};
   int i, max;
   
   /* Process first set of numbers available in set1[] */
   max = set1[0];
   i = 1;    
   while( i < 5 ) {
      if( max <  set1[i] ) {
         max = set1[i];
      }
      i = i + 1;
   }
   
   printf("Max in first set = %d\n", max );
    
   /* Now process second set of numbers available in set2[] */
   max = set2[0];
   i = 1;    
   while( i < 5 ) {
      if( max <  set2[i] ) {
         max = set2[i];
      }
      i = i + 1;
   }
   printf("Max in second set = %d\n", max );
}

เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Max in first set = 50
Max in second set = 501

หากคุณมีความชัดเจนเกี่ยวกับตัวอย่างข้างต้นมันจะกลายเป็นเรื่องง่ายที่จะเข้าใจว่าทำไมเราถึงต้องการฟังก์ชัน ในตัวอย่างข้างต้นมีชุดตัวเลขเพียงสองชุดคือ set1 และ set2 แต่ให้พิจารณาสถานการณ์ที่เรามีชุดตัวเลขที่คล้ายกัน 10 ชุดขึ้นไปเพื่อหาจำนวนสูงสุดจากแต่ละชุด ในสถานการณ์เช่นนี้เราจะต้องทำซ้ำประมวลผล 10 ครั้งขึ้นไปและท้ายที่สุดโปรแกรมจะมีขนาดใหญ่เกินไปเมื่อใช้รหัสซ้ำ เพื่อจัดการกับสถานการณ์ดังกล่าวเราเขียนฟังก์ชันของเราที่เราพยายามเก็บซอร์สโค้ดซึ่งจะถูกใช้ซ้ำแล้วซ้ำอีกในการเขียนโปรแกรมของเรา

ตอนนี้เรามาดูวิธีการกำหนดฟังก์ชันในการเขียนโปรแกรมภาษาซีแล้วในส่วนต่อไปเราจะอธิบายวิธีการใช้งาน

การกำหนดฟังก์ชัน

รูปแบบทั่วไปของนิยามฟังก์ชันในโปรแกรมภาษาซีมีดังนี้ -

return_type function_name( parameter list ) {
   body of the function
   
   return [expression];
}

ความหมายฟังก์ชั่นในการเขียนโปรแกรม C ประกอบด้วยส่วนหัวของฟังก์ชั่นและการทำงานของร่างกาย นี่คือส่วนทั้งหมดของฟังก์ชัน -

Return Type- ฟังก์ชันอาจส่งคืนค่า return_typeคือชนิดข้อมูลของค่าที่ฟังก์ชันส่งกลับ ฟังก์ชันบางอย่างดำเนินการตามที่ต้องการโดยไม่ส่งคืนค่า ในกรณีนี้ return_type คือคีย์เวิร์ดvoid.
Function Name- นี่คือชื่อจริงของฟังก์ชัน ชื่อฟังก์ชันและรายการพารามิเตอร์ประกอบกันเป็นลายเซ็นฟังก์ชัน
Parameter List- พารามิเตอร์เปรียบเสมือนตัวยึด เมื่อเรียกใช้ฟังก์ชันคุณจะส่งผ่านค่าเป็นพารามิเตอร์ ค่านี้เรียกว่าพารามิเตอร์หรืออาร์กิวเมนต์จริง รายการพารามิเตอร์หมายถึงประเภทลำดับและจำนวนของพารามิเตอร์ของฟังก์ชัน พารามิเตอร์เป็นทางเลือก นั่นคือฟังก์ชันอาจไม่มีพารามิเตอร์
Function Body - เนื้อความของฟังก์ชันประกอบด้วยชุดของคำสั่งที่กำหนดสิ่งที่ฟังก์ชันทำ

เรียกใช้ฟังก์ชัน

ในขณะที่สร้างฟังก์ชัน C คุณให้คำจำกัดความว่าฟังก์ชันนี้มีไว้ทำอะไร ในการใช้ฟังก์ชันคุณจะต้องเรียกใช้ฟังก์ชันนั้นเพื่อทำงานที่กำหนดไว้

ตอนนี้เรามาเขียนตัวอย่างข้างต้นด้วยความช่วยเหลือของฟังก์ชัน -

#include <stdio.h>

int getMax( int set[] ) {
   int i, max;
   
   max = set[0];
   i = 1;    
   while( i < 5 ) {
      if( max <  set[i] ) {
         max = set[i];
      }
      i = i + 1;
   }
   return max;
}
main() {
   int set1[5] = {10, 20, 30, 40, 50};
   int set2[5] = {101, 201, 301, 401, 501};
   int max;

   /* Process first set of numbers available in set1[] */
   max = getMax(set1);
   printf("Max in first set = %d\n", max );
    
   /* Now process second set of numbers available in set2[] */
   max = getMax(set2);
   printf("Max in second set = %d\n", max );
}

เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Max in first set = 50
Max in second set = 501

ฟังก์ชันใน Java

หากคุณมีความชัดเจนเกี่ยวกับฟังก์ชันในการเขียนโปรแกรม C คุณก็สามารถเข้าใจฟังก์ชันเหล่านี้ใน Java ได้โดยง่ายเช่นกัน การเขียนโปรแกรม Java ตั้งชื่อเป็นmethodsแต่แนวคิดที่เหลือยังคงเหมือนเดิมไม่มากก็น้อย

ต่อไปนี้เป็นโปรแกรมเทียบเท่าที่เขียนด้วย Java คุณสามารถลองดำเนินการเพื่อดูผลลัพธ์ -

public class DemoJava {
   public static void main(String []args) {
      int[] set1 = {10, 20, 30, 40, 50};
      int[] set2 = {101, 201, 301, 401, 501};
      int max;

      /* Process first set of numbers available in set1[] */
      max = getMax(set1);
      System.out.format("Max in first set = %d\n", max );

      /* Now process second set of numbers available in set2[] */
      max = getMax(set2);
      System.out.format("Max in second set = %d\n", max );
   }
   public static int getMax( int set[] ) {
      int i, max;
      max = set[0];
      i = 1;    
      
      while( i < 5 ) {
         if( max <  set[i] ) {
            max = set[i];
         }
         i = i + 1;
      }
      return max;
   }
}

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Max in first set = 50
Max in second set = 501

ฟังก์ชั่นใน Python

อีกครั้งถ้าคุณรู้แนวคิดของฟังก์ชันในการเขียนโปรแกรม C และ Java แล้ว Python ก็ไม่แตกต่างกันมากนัก ด้านล่างนี้เป็นไวยากรณ์พื้นฐานของการกำหนดฟังก์ชันใน Python -

def function_name( parameter list ):
   body of the function
   
   return [expression]

การใช้ไวยากรณ์ของฟังก์ชันนี้ใน Python ตัวอย่างข้างต้นสามารถเขียนได้ดังนี้ -

def getMax( set ):
   max = set[0]
   i = 1   
   
   while( i < 5 ):
      if( max <  set[i] ):
         max = set[i]
      
      i = i + 1
   return max

set1 = [10, 20, 30, 40, 50]
set2 = [101, 201, 301, 401, 501]

# Process first set of numbers available in set1[]
max = getMax(set1)
print "Max in first set = ", max
    
# Now process second set of numbers available in set2[]
max = getMax(set2)
print "Max in second set = ", max

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

Max in first set =  50
Max in second set =  501

ไฟล์คอมพิวเตอร์

ไฟล์คอมพิวเตอร์ใช้เพื่อจัดเก็บข้อมูลในรูปแบบดิจิทัลเช่นข้อความธรรมดาข้อมูลรูปภาพหรือเนื้อหาอื่น ๆ ไฟล์คอมพิวเตอร์สามารถจัดระเบียบภายในไดเร็กทอรีต่างๆ ไฟล์ถูกใช้เพื่อเก็บข้อมูลดิจิทัลในขณะที่ไดเร็กทอรีใช้เพื่อเก็บไฟล์

ไฟล์คอมพิวเตอร์ถือได้ว่าเป็นเอกสารดิจิทัลที่เป็นกระดาษ ในขณะเขียนโปรแกรมคุณจะเก็บซอร์สโค้ดไว้ในไฟล์ข้อความที่มีนามสกุลต่างกันตัวอย่างเช่นไฟล์การเขียนโปรแกรม C จะลงท้ายด้วยนามสกุล.c, ไฟล์การเขียนโปรแกรม Java ด้วย .javaและไฟล์ Python ที่มีไฟล์ .py.

อินพุต / เอาต์พุตไฟล์

โดยปกติคุณจะสร้างไฟล์โดยใช้โปรแกรมแก้ไขข้อความเช่น notepad, MS Word, MS Excel หรือ MS Powerpoint เป็นต้นอย่างไรก็ตามหลายครั้งเราจำเป็นต้องสร้างไฟล์โดยใช้โปรแกรมคอมพิวเตอร์เช่นกัน เราสามารถแก้ไขไฟล์ที่มีอยู่โดยใช้โปรแกรมคอมพิวเตอร์

อินพุตไฟล์หมายถึงข้อมูลที่เขียนลงในไฟล์และเอาต์พุตไฟล์หมายถึงข้อมูลที่อ่านจากไฟล์ จริงๆแล้วคำศัพท์อินพุตและเอาต์พุตเกี่ยวข้องกับอินพุตและเอาต์พุตของหน้าจอมากกว่า เมื่อเราแสดงผลลัพธ์บนหน้าจอเรียกว่าเอาต์พุต ในทำนองเดียวกันถ้าเราให้อินพุตบางส่วนไปยังโปรแกรมของเราจากพรอมต์คำสั่งจะเรียกว่าอินพุต

สำหรับตอนนี้ก็เพียงพอที่จะจำไว้ว่าการเขียนลงในไฟล์คือการป้อนไฟล์และการอ่านบางสิ่งจากไฟล์คือเอาต์พุตไฟล์

โหมดการทำงานของไฟล์

ก่อนที่เราจะเริ่มทำงานกับไฟล์ใด ๆ โดยใช้โปรแกรมคอมพิวเตอร์เราจำเป็นต้องสร้างไฟล์ใหม่หากไม่มีอยู่หรือเปิดไฟล์ที่มีอยู่แล้ว ไม่ว่าในกรณีใดเราสามารถเปิดไฟล์ในโหมดต่อไปนี้ -

Read-Only Mode- หากคุณกำลังจะอ่านไฟล์ที่มีอยู่และคุณไม่ต้องการเขียนเนื้อหาใด ๆ เพิ่มเติมในไฟล์คุณจะเปิดไฟล์ในโหมดอ่านอย่างเดียว ภาษาโปรแกรมเกือบทั้งหมดมีไวยากรณ์สำหรับเปิดไฟล์ในโหมดอ่านอย่างเดียว
Write-Only Mode- หากคุณกำลังจะเขียนลงในไฟล์ที่มีอยู่หรือไฟล์ที่สร้างขึ้นใหม่ แต่คุณไม่ต้องการอ่านเนื้อหาที่เขียนจากไฟล์นั้นคุณจะเปิดไฟล์ในโหมดเขียนอย่างเดียว ภาษาโปรแกรมทั้งหมดมีไวยากรณ์เพื่อเปิดไฟล์ในโหมดเขียนอย่างเดียว
Read & Write Mode - หากคุณกำลังจะอ่านและเขียนลงในไฟล์เดียวกันคุณจะเปิดไฟล์ในโหมดอ่านและเขียน
Append Mode- เมื่อคุณเปิดไฟล์เพื่อเขียนมันจะช่วยให้คุณสามารถเริ่มเขียนได้จากจุดเริ่มต้นของไฟล์ อย่างไรก็ตามมันจะเขียนทับเนื้อหาที่มีอยู่ถ้ามี สมมติว่าเราไม่ต้องการเขียนทับเนื้อหาใด ๆ ที่มีอยู่จากนั้นเราจะเปิดไฟล์ในโหมดผนวก ท้ายที่สุดแล้วโหมดต่อท้ายคือโหมดการเขียนซึ่งจะทำให้สามารถต่อท้ายเนื้อหาได้ที่ท้ายไฟล์ ภาษาโปรแกรมเกือบทั้งหมดมีไวยากรณ์สำหรับเปิดไฟล์ในโหมดผนวก

ในส่วนต่อไปนี้เราจะเรียนรู้วิธีการเปิดไฟล์ใหม่วิธีเขียนลงในไฟล์และวิธีการอ่านและผนวกเนื้อหาเพิ่มเติมลงในไฟล์เดียวกันในภายหลัง

กำลังเปิดไฟล์

คุณสามารถใช้ไฟล์ fopen()เพื่อสร้างไฟล์ใหม่หรือเปิดไฟล์ที่มีอยู่ การเรียกใช้นี้จะเริ่มต้นอ็อบเจ็กต์ประเภทFILEซึ่งมีข้อมูลทั้งหมดที่จำเป็นในการควบคุมสตรีม นี่คือต้นแบบคือลายเซ็นของการเรียกใช้ฟังก์ชันนี้ -

FILE *fopen( const char * filename, const char * mode );

ที่นี่ filename เป็นสตริงลิเทอรัลซึ่งคุณจะใช้ตั้งชื่อไฟล์และเข้าถึง mode สามารถมีค่าใดค่าหนึ่งต่อไปนี้ -

ซีเนียร์ No	โหมดและคำอธิบาย
1	r เปิดไฟล์ข้อความที่มีอยู่เพื่อจุดประสงค์ในการอ่าน
2	w เปิดไฟล์ข้อความเพื่อเขียน หากไม่มีอยู่ไฟล์ใหม่จะถูกสร้างขึ้น ที่นี่โปรแกรมของคุณจะเริ่มเขียนเนื้อหาจากจุดเริ่มต้นของไฟล์
3	a เปิดไฟล์ข้อความสำหรับเขียนในโหมดต่อท้าย หากไม่มีอยู่ไฟล์ใหม่จะถูกสร้างขึ้น ที่นี่โปรแกรมของคุณจะเริ่มต่อท้ายเนื้อหาในเนื้อหาไฟล์ที่มีอยู่
4	r+ เปิดไฟล์ข้อความสำหรับอ่านและเขียนทั้งสองอย่าง
5	w+ เปิดไฟล์ข้อความสำหรับทั้งการอ่านและการเขียน ขั้นแรกจะตัดทอนไฟล์ให้มีความยาวเป็นศูนย์หากมีอยู่ มิฉะนั้นจะสร้างไฟล์หากไม่มีอยู่
6	a+ เปิดไฟล์ข้อความสำหรับทั้งการอ่านและการเขียน จะสร้างไฟล์หากไม่มีอยู่ การอ่านจะเริ่มจากจุดเริ่มต้น แต่การเขียนสามารถต่อท้ายได้เท่านั้น

การปิดไฟล์

ในการปิดไฟล์ให้ใช้ไฟล์ fclose( )ฟังก์ชัน ต้นแบบของฟังก์ชันนี้คือ -

int fclose( FILE *fp );

fclose( ) ฟังก์ชันคืนค่าเป็นศูนย์เมื่อสำเร็จหรือ EOFอักขระพิเศษหากมีข้อผิดพลาดในการปิดไฟล์ ฟังก์ชันนี้จะล้างข้อมูลที่ค้างอยู่ในบัฟเฟอร์ไปยังไฟล์ปิดไฟล์และปล่อยหน่วยความจำที่ใช้สำหรับไฟล์ EOF คือค่าคงที่ที่กำหนดไว้ในไฟล์ส่วนหัวstdio.h.

มีฟังก์ชั่นต่างๆที่จัดเตรียมโดยไลบรารีมาตรฐาน C เพื่ออ่านและเขียนไฟล์ทีละอักขระหรือในรูปแบบของสตริงที่มีความยาวคงที่ ให้เราดูบางส่วนในส่วนถัดไป

การเขียนไฟล์

ด้านล่างนี้เป็นฟังก์ชันที่ง่ายที่สุดในการเขียนอักขระแต่ละตัวไปยังสตรีม -

int fputc( int c, FILE *fp );

ฟังก์ชั่น fputc() เขียนค่าอักขระของอาร์กิวเมนต์ c ไปยังเอาต์พุตสตรีมที่อ้างอิงโดย fp. จะส่งคืนอักขระที่เขียนด้วยความสำเร็จมิฉะนั้นEOFหากมีข้อผิดพลาด คุณสามารถใช้ฟังก์ชันต่อไปนี้เพื่อเขียนสตริงที่สิ้นสุดด้วย null ลงในสตรีม -

int fputs( const char *s, FILE *fp );

ฟังก์ชั่น fputs() เขียนสตริง sลงในไฟล์ที่อ้างอิงโดย fp จะส่งคืนค่าที่ไม่เป็นลบต่อความสำเร็จมิฉะนั้นEOFจะถูกส่งกลับในกรณีที่เกิดข้อผิดพลาดใด ๆ คุณยังสามารถใช้ฟังก์ชันint fprintf(FILE *fp,const char *format, ...)เพื่อเขียนสตริงลงในไฟล์ ลองใช้ตัวอย่างต่อไปนี้ -

#include <stdio.h>

int main() {
   FILE *fp;

   fp = fopen("/tmp/test.txt", "w+");
   fprintf(fp, "This is testing for fprintf...\n");
   fputs("This is testing for fputs...\n", fp);
   fclose(fp);
}

เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานโค้ดจะสร้างไฟล์ใหม่ test.txt ใน /tmpไดเร็กทอรีและเขียนสองบรรทัดโดยใช้สองฟังก์ชันที่แตกต่างกัน ให้เราอ่านไฟล์นี้ในหัวข้อถัดไป

การอ่านไฟล์

ให้ด้านล่างเป็นฟังก์ชั่นที่ง่ายที่สุดในการอ่านไฟล์ข้อความทีละอักขระ -

int fgetc( FILE * fp );

fgetc() ฟังก์ชันอ่านอักขระจากไฟล์อินพุตที่อ้างอิงโดย fp. ค่าที่ส่งคืนคืออักขระที่อ่านแล้ว หรือในกรณีที่มีข้อผิดพลาดจะส่งคืนEOF. ฟังก์ชันต่อไปนี้ช่วยให้คุณอ่านสตริงจากสตรีม -

char *fgets( char *buf, int n, FILE *fp );

ฟังก์ชั่น fgets() อ่านได้สูงสุด n - 1 อักขระจากอินพุตสตรีมที่อ้างอิงโดย fp. คัดลอกสตริงการอ่านลงในบัฟเฟอร์bufต่อท้ายก null อักขระเพื่อยุติสตริง

หากฟังก์ชันนี้พบอักขระขึ้นบรรทัดใหม่ '\ n' หรือ EOF ก่อนที่จะอ่านจำนวนอักขระสูงสุดฟังก์ชันนี้จะส่งคืนเฉพาะอักขระที่อ่านจนถึงจุดนั้นรวมถึงอักขระบรรทัดใหม่ คุณยังสามารถใช้int fscanf(FILE *fp, const char *format, ...) เพื่ออ่านสตริงจากไฟล์ แต่จะหยุดอ่านหลังจากพบอักขระช่องว่างตัวแรก

#include <stdio.h>

main() {

   FILE *fp;
   char buff[255];

   fp = fopen("/tmp/test.txt", "r");
   fscanf(fp, "%s", buff);
   printf("1 : %s\n", buff );

   fgets(buff, 255, (FILE*)fp);
   printf("2: %s\n", buff );
   
   fgets(buff, 255, (FILE*)fp);
   printf("3: %s\n", buff );
   fclose(fp);
}

เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะอ่านไฟล์ที่สร้างในส่วนก่อนหน้าและสร้างผลลัพธ์ต่อไปนี้ -

1 : This
2 : is testing for fprintf...

3 : This is testing for fputs...

ลองวิเคราะห์สิ่งที่เกิดขึ้นที่นี่ ก่อนอื่นfscanf() วิธีการอ่าน Thisเพราะหลังจากนั้นก็พบกับช่องว่าง สายที่สองมีไว้สำหรับfgets()ซึ่งอ่านบรรทัดที่เหลือจนพบจุดสิ้นสุดของบรรทัด สุดท้ายสายสุดท้ายfgets() อ่านบรรทัดที่สองอย่างสมบูรณ์

ไฟล์ I / O ใน Java

Java มีชุดฟังก์ชันที่สมบูรณ์ยิ่งขึ้นเพื่อจัดการ File I / O สำหรับข้อมูลเพิ่มเติมเกี่ยวกับหัวข้อนี้เราขอแนะนำให้คุณตรวจสอบบทช่วยสอน Java ของเรา

ที่นี่เราจะเห็นโปรแกรม Java อย่างง่ายซึ่งเทียบเท่ากับโปรแกรม C ที่อธิบายข้างต้น โปรแกรมนี้จะเปิดไฟล์ข้อความเขียนข้อความสองสามบรรทัดลงไปแล้วปิดไฟล์ ในที่สุดไฟล์เดียวกันจะถูกเปิดขึ้นแล้วอ่านจากไฟล์ที่สร้างไว้แล้ว คุณสามารถลองรันโปรแกรมต่อไปนี้เพื่อดูผลลัพธ์ -

import java.io.*;

public class DemoJava {
   public static void main(String []args) throws IOException {
      File file = new File("/tmp/java.txt");
      
      // Create a File
      file.createNewFile();
      
      //  Creates a FileWriter Object using file object
      FileWriter writer = new FileWriter(file); 
      
      // Writes the content to the file
      writer.write("This is testing for Java write...\n");
      writer.write("This is second line...\n");
      
      // Flush the memory and close the file
      writer.flush();
      writer.close();
      
      // Creates a FileReader Object
      FileReader reader = new FileReader(file); 
      char [] a = new char[100];
      
      // Read file content in the array
      reader.read(a);
      System.out.println( a );
      
      // Close the file
      reader.close();
   }
}

เมื่อโปรแกรมด้านบนถูกเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

This is testing for Java write...
This is second line...

ไฟล์ I / O ใน Python

โปรแกรมต่อไปนี้แสดงการทำงานเดียวกันในการเปิดไฟล์ใหม่เขียนเนื้อหาบางส่วนลงในไฟล์และสุดท้ายอ่านไฟล์เดียวกัน -

# Create a new file
fo = open("/tmp/python.txt", "w")

# Writes the content to the file
fo.write( "This is testing for Python write...\n");
fo.write( "This is second line...\n");

# Close the file
fo.close()

# Open existing file
fo = open("/tmp/python.txt", "r")

# Read file content in a variable
str = fo.read(100);
print str

# Close opened file
fo.close()

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

This is testing for Python write...
This is second line...

ขอขอบคุณที่อดทนรอในการทำตามบทแนะนำนี้ เราพยายามทำให้กระชับ แต่เนื่องจากหัวข้อนี้มีหลายหัวข้อเราจึงได้แสดงตัวอย่างบางส่วนโดยละเอียด

หากคุณไม่เข้าใจแนวคิดใด ๆ เราขอแนะนำให้อ่านบทช่วยสอนอีกครั้งและเมื่อคุณพอใจกับแนวคิดที่อธิบายไว้ในบทช่วยสอนนี้แล้วคุณสามารถดำเนินการต่อไปได้

มีวิชาอื่น ๆ อีกมากมายที่เกี่ยวข้องกับการเขียนโปรแกรมคอมพิวเตอร์ซึ่งเราไม่ได้กล่าวถึงโดยเจตนาเพื่อหลีกเลี่ยงความสับสน แต่เรามั่นใจว่าแนวคิดเหล่านั้นจะไม่ใช่เรื่องยากสำหรับคุณที่จะเข้าใจตราบเท่าที่คุณทำให้ตัวเองพอใจกับแนวคิดที่อธิบายในบทช่วยสอนนี้

ที่ Tutorialspoint เราได้ใช้ความพยายามอย่างมากในการจัดเตรียมแบบฝึกหัดที่ครอบคลุมเกี่ยวกับภาษาการเขียนโปรแกรม C, Java และ Python และเราขอแนะนำให้คุณเริ่มต้นอย่างใดอย่างหนึ่งหลังจากเสร็จสิ้นบทช่วยสอนนี้แล้ว

กรุณาแบ่งปันมุมมองของคุณเกี่ยวกับบทช่วยสอนนี้กับเราโดยระบุชื่อบทช่วยสอนในหัวเรื่องที่ [email protected]. หากคุณมีข้อเสนอแนะในการปรับปรุงบทช่วยสอนนี้เพิ่มเติมเรายินดีรับฟังความคิดเห็นของคุณอย่างแน่นอน