Imperative Programming

แนวคิดหลัก

Imperative Programming เป็นกระบวนทัศน์การเขียนโปรแกรมที่เน้นการบอกคอมพิวเตอร์ว่า "ทำอย่างไร" (How) มากกว่า "ต้องการอะไร" (What) โดยใช้ชุดคำสั่งที่เปลี่ยนแปลงสถานะของโปรแกรมตามลำดับ

องค์ประกอบหลัก

• การเปลี่ยนแปลงสถานะ: ใช้ตัวแปรที่สามารถเปลี่ยนค่าได้ (mutable variables) เพื่อเก็บและอัปเดตข้อมูลระหว่างการทำงาน

JavaScript

let counter = 0; // สร้างตัวแปรเริ่มต้น
counter = counter + 1; // เปลี่ยนแปลงค่าของตัวแปร
console.log(counter); // แสดงผลลัพธ์: 1

Rust

fn main() {
    let mut counter = 0;  // สร้างตัวแปรเริ่มต้นที่เปลี่ยนแปลงได้ (mut)
    counter = counter + 1; // เปลี่ยนแปลงค่าของตัวแปร
    println!("{}", counter); // แสดงผลลัพธ์: 1
}

Python

counter = 0          # สร้างตัวแปรเริ่มต้น
counter = counter + 1    # เปลี่ยนแปลงค่าของตัวแปร
print(counter)     # แสดงผลลัพธ์: 1

Go

package main

import "fmt"

func main() {
    counter := 0          // สร้างตัวแปรเริ่มต้น
    counter = counter + 1 // เปลี่ยนแปลงค่าของตัวแปร
    fmt.Println(counter)  // แสดงผลลัพธ์: 1
}

ลำดับคำสั่ง

• ลำดับคำสั่ง: โค้ดทำงานตามลำดับจากบนลงล่าง การเปลี่ยนลำดับคำสั่งจะส่งผลต่อผลลัพธ์

JavaScript

let x = 5;
let y = 10;
let z = x + y; // z = 15
x = 20; // เปลี่ยนค่า x แต่ไม่มีผลกับค่า z ที่คำนวณไปแล้ว
console.log(z); // ยังคงแสดง 15

Rust

fn main() {
    let mut x = 5;
    let y = 10;
    let z = x + y;    // z = 15
    x = 20;           // เปลี่ยนค่า x แต่ไม่มีผลกับค่า z ที่คำนวณไปแล้ว
    println!("{}", z); // ยังคงแสดง 15
}

Python

x = 5
y = 10
z = x + y    # z = 15
x = 20       # เปลี่ยนค่า x แต่ไม่มีผลกับค่า z ที่คำนวณไปแล้ว
print(z)     # ยังคงแสดง 15

Go

package main

import "fmt"

func main() {
    x := 5
    y := 10
    z := x + y    // z = 15
    x = 20        // เปลี่ยนค่า x แต่ไม่มีผลกับค่า z ที่คำนวณไปแล้ว
    fmt.Println(z) // ยังคงแสดง 15
}

การวนซ้ำ

• การวนซ้ำ: ใช้โครงสร้างแบบ loops เพื่อทำงานซ้ำๆ โดยไม่ต้องเขียนโค้ดซ้ำ

JavaScript

let sum = 0;
for (let i = 1; i <= 5; i++) {
  sum += i;
  console.log(`รอบที่ ${i}: sum = ${sum}`);
}
// แสดงผล:
// รอบที่ 1: sum = 1
// รอบที่ 2: sum = 3
// รอบที่ 3: sum = 6
// รอบที่ 4: sum = 10
// รอบที่ 5: sum = 15

Rust

fn main() {
    let mut sum = 0;
    for i in 1..=5 {
        sum += i;
        println!("รอบที่ {}: sum = {}", i, sum);
    }
    // แสดงผล:
    // รอบที่ 1: sum = 1
    // รอบที่ 2: sum = 3
    // รอบที่ 3: sum = 6
    // รอบที่ 4: sum = 10
    // รอบที่ 5: sum = 15
}

Python

sum = 0
for i in range(1, 6):
    sum += i
    print(f"รอบที่ {i}: sum = {sum}")
# แสดงผล:
# รอบที่ 1: sum = 1
# รอบที่ 2: sum = 3
# รอบที่ 3: sum = 6
# รอบที่ 4: sum = 10
# รอบที่ 5: sum = 15

Go

package main

import "fmt"

func main() {
    sum := 0
    for i := 1; i <= 5; i++ {
        sum += i
        fmt.Printf("รอบที่ %d: sum = %d\n", i, sum)
    }
    // แสดงผล:
    // รอบที่ 1: sum = 1
    // รอบที่ 2: sum = 3
    // รอบที่ 3: sum = 6
    // รอบที่ 4: sum = 10
    // รอบที่ 5: sum = 15
}

เงื่อนไข

• เงื่อนไข: ใช้คำสั่งแบบมีเงื่อนไขเพื่อควบคุมการทำงานของโปรแกรม

JavaScript

let score = 75;
let grade;

if (score >= 80) {
  grade = "A";
} else if (score >= 70) {
  grade = "B";
} else if (score >= 60) {
  grade = "C";
} else {
  grade = "F";
}

console.log(`คะแนน ${score} ได้เกรด ${grade}`); // คะแนน 75 ได้เกรด B

Rust

fn main() {
    let score = 75;
    let grade;

    if score >= 80 {
        grade = "A";
    } else if score >= 70 {
        grade = "B";
    } else if score >= 60 {
        grade = "C";
    } else {
        grade = "F";
    }

    println!("คะแนน {} ได้เกรด {}", score, grade); // คะแนน 75 ได้เกรด B
}

Python

score = 75
grade = ""

if score >= 80:
    grade = "A"
elif score >= 70:
    grade = "B"
elif score >= 60:
    grade = "C"
else:
    grade = "F"

print(f"คะแนน {score} ได้เกรด {grade}")  # คะแนน 75 ได้เกรด B

Go

package main

import "fmt"

func main() {
    score := 75
    var grade string

    if score >= 80 {
        grade = "A"
    } else if score >= 70 {
        grade = "B"
    } else if score >= 60 {
        grade = "C"
    } else {
        grade = "F"
    }

    fmt.Printf("คะแนน %d ได้เกรด %s\n", score, grade) // คะแนน 75 ได้เกรด B
}

โปรแกรมย่อย

• โปรแกรมย่อย: แบ่งโค้ดเป็นฟังก์ชันหรือโปรซีเจอร์ที่สามารถเรียกใช้ซ้ำได้

JavaScript

function calculateArea(width, height) {
  return width * height;
}

let roomWidth = 4;
let roomHeight = 5;
let area = calculateArea(roomWidth, roomHeight);
console.log(`พื้นที่ห้อง: ${area} ตารางเมตร`); // พื้นที่ห้อง: 20 ตารางเมตร

Rust

fn calculate_area(width: i32, height: i32) -> i32 {
    width * height
}

fn main() {
    let room_width = 4;
    let room_height = 5;
    let area = calculate_area(room_width, room_height);
    println!("พื้นที่ห้อง: {} ตารางเมตร", area); // พื้นที่ห้อง: 20 ตารางเมตร
}

Python

def calculate_area(width, height):
    return width * height

room_width = 4
room_height = 5
area = calculate_area(room_width, room_height)
print(f"พื้นที่ห้อง: {area} ตารางเมตร")  # พื้นที่ห้อง: 20 ตารางเมตร

Go

package main

import "fmt"

func calculateArea(width, height int) int {
    return width * height
}

func main() {
    roomWidth := 4
    roomHeight := 5
    area := calculateArea(roomWidth, roomHeight)
    fmt.Printf("พื้นที่ห้อง: %d ตารางเมตร\n", area) // พื้นที่ห้อง: 20 ตารางเมตร
}

เหมาะสำหรับ

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