Variables & Types

Variables: แนวคิดที่คุ้นเคย แต่กฎต่างกัน

ใน TypeScript คุณประกาศตัวแปรด้วย let หรือ const จะใส่ annotation บอก type ด้วยหรือไม่ก็ได้ แล้วคอมไพเลอร์จะคุม type นั้นไปตลอดอายุของตัวแปร ส่วนใน Python แค่เขียนชื่อแล้ว assign ค่าลงไป ไม่มีคีย์เวิร์ด ไม่มีคอมไพเลอร์ ตัวแปรเกิดขึ้นตั้งแต่บรรทัดนั้น และ type ก็คือสิ่งที่คุณ assign ลงไปนั่นเอง

จุดต่างสำคัญคือ type system ของ TypeScript ทำงานตอน compile-time แล้วหายไปตอน runtime ส่วน type hints ของ Python เป็นแค่ annotation ที่ใส่หรือไม่ใส่ก็ได้ interpreter ไม่บังคับตามให้ ต้องพึ่ง tool ภายนอกอย่าง mypy มาตรวจแยกอีกที

การประกาศตัวแปร

// TypeScript
let age: number = 30;
let name: string = "Alice";
const PI: number = 3.14159;
let isActive: boolean = true;

// Inferred type — TS figures it out
let score = 100;  // inferred as number

# Python
age: int = 30
name: str = "Alice"
PI: float = 3.14159
is_active: bool = True

# No annotation needed — works the same
score = 100  # Python infers nothing; it is just an int

สังเกตความต่างของสไตล์:

ไม่มีคีย์เวิร์ด let หรือ const — ตัว assignment นั่นแหละคือการประกาศ
ใช้ snake_case สำหรับชื่อตัวแปร (ไม่ใช่ camelCase)
True / False ขึ้นต้นด้วยตัวพิมพ์ใหญ่ (ไม่ใช่ตัวพิมพ์เล็กแบบ JS/TS)

ค่าคงที่ตามธรรมเนียม: UPPER_CASE

Python ไม่มีคีย์เวิร์ด const ธรรมเนียมของชุมชนคือตั้งชื่อค่าคงที่เป็น UPPER_SNAKE_CASE ซึ่งไม่ได้ห้าม assign ทับจริง ๆ แต่เป็นสัญญาณบอกเพื่อนร่วมทีมว่าอย่าไปแตะ

// TypeScript — enforced at compile time
const MAX_RETRIES: number = 3;
const API_BASE = "https://api.example.com";

// MAX_RETRIES = 5;  // TS error: cannot assign to const

# Python — convention only, NOT enforced
MAX_RETRIES: int = 3
API_BASE: str = "https://api.example.com"

# Technically legal (but don't do this):
# MAX_RETRIES = 5  # no error, just bad style

Dynamic typing ในการใช้งานจริง

ตัวแปรใน Python ไม่ได้ล็อกอยู่กับ type แรกที่ assign ลงไป เพราะเป็นแค่ชื่อที่ชี้ไปยัง object คุณ rebind ไปเป็น type ไหนตอนไหนก็ได้ ฝั่ง TypeScript จะตีตกตั้งแต่ compile-time ส่วน Python ปล่อยผ่าน

// TypeScript
let value: string | number = "hello";
value = 42;   // OK — union type
// value = true; // Error — not in the union

# Python
value = "hello"
print(type(value))   # <class 'str'>

value = 42
print(type(value))   # <class 'int'>

value = [1, 2, 3]
print(type(value))   # <class 'list'>

การ assign หลายค่าพร้อมกัน

Python unpack หลายค่าในบรรทัดเดียวได้ ที่เป็นท่าที่ TypeScript developer คุ้นอยู่แล้วจาก array destructuring

// TypeScript destructuring
const [x, y, z] = [1, 2, 3];
const { name, age } = { name: "Alice", age: 30 };

# Python tuple unpacking
x, y, z = 1, 2, 3
print(x, y, z)  # 1 2 3

# Works with any iterable
first, *rest = [10, 20, 30, 40]
print(first, rest)  # 10 [20, 30, 40]

ลองเล่นดู

Open in an online REPL

# Experiment with Python variables
age: int = 30
name: str = "Alice"
PI: float = 3.14159
is_active: bool = True

print(f"name={name}, age={age}, PI={PI}, is_active={is_active}")

# Dynamic reassignment — Python allows this
age = "thirty"
print(f"age is now: {age} (type: {type(age).__name__})")

# Multiple assignment
x, y, z = 1, 2, 3
print(f"x={x}, y={y}, z={z}")

# Star unpacking
first, *rest = [10, 20, 30, 40]
print(f"first={first}, rest={rest}")

🟦 Type hints เป็น optional และ runtime ไม่บังคับตาม

ใน TypeScript type คือคำรับประกันตอน compile-time คอมไพเลอร์ตีตก type ที่ไม่ตรงกันตั้งแต่ก่อนโค้ดได้รัน

ส่วนใน Python type hints อย่าง name: str = "Alice" เป็น เอกสารสำหรับคนอ่านและสำหรับ tool เท่านั้น ตอน runtime interpreter มองข้ามไปเลย คุณส่ง int เข้าฟังก์ชันที่ annotate ไว้ว่า str ก็ได้ Python ไม่บ่นสักคำ

ถ้าอยากได้ static analysis แบบเดียวกับคอมไพเลอร์ TypeScript ต้องรัน mypy หรือ pyright แยกเอง:

pip install mypy
mypy your_script.py

editor สมัยใหม่อย่าง VS Code ที่ใช้ Pylance หรือ PyCharm รันการตรวจนี้ให้อัตโนมัติตั้งแต่ตอนคุณพิมพ์