Inline Variable

จุดประสงค์

บางครั้งตัวแปร local ก็เป็นแค่ชื่อที่สองของ expression ที่คุณเข้าใจอยู่แล้ว ไม่ได้ทำให้อะไรชัดขึ้น ไม่ได้เอากลับมาใช้ซ้ำ มีแต่มาขวางระหว่างคุณกับ code ที่สำคัญ Inline Variable ตัดตัวกลางนั้นทิ้ง โดยแทนที่ตัวแปรด้วย expression แล้วลบบรรทัดประกาศออก เหลือชื่อให้ต้องตามน้อยลงหนึ่งชื่อ

Code Smell

คุณเจอตัวแปรที่ชื่อไม่ได้บอกอะไรมากไปกว่า expression ที่เก็บไว้ เช่น let basePrice = order.basePrice; แล้วใช้ basePrice แค่ครั้งเดียว นั่นคือเสียงรบกวนล้วน ๆ ผู้อ่านต้องเลื่อนขึ้นไปยืนยันว่า basePrice คือ order.basePrice จริง ๆ และไม่มีอะไรมากกว่านั้น ตัวแปรตัวนี้สัญญาว่าจะอธิบาย แต่ให้มาแค่คำพ้องความหมาย

นี่คือด้านตรงข้ามของ Extract Variable ตรงนั้นคุณเพิ่มชื่อเพราะ sub-expression อ่านไม่ออก ตรงนี้คุณตัดชื่อทิ้งเพราะไม่เคยคุ้มกับที่ที่กินไป เกณฑ์ตัดสินเหมือนกันทั้งสองทาง คือชื่อนั้นทำให้ code ชัดกว่า expression ดิบหรือเปล่า ถ้าไม่ ก็ inline ทิ้งไปเลย

ก่อน → หลัง

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

// Before
function canShipFree(order: Order): boolean {
  const basePrice = order.basePrice;
  const overThreshold = basePrice > 100;
  return overThreshold;
}

// After
function canShipFree(order: Order): boolean {
  return order.basePrice > 100;
}

# Before
def can_ship_free(order):
    base_price = order.base_price
    over_threshold = base_price > 100
    return over_threshold

# After
def can_ship_free(order):
    return order.base_price > 100

// Before
func CanShipFree(order Order) bool {
    basePrice := order.BasePrice
    overThreshold := basePrice > 100
    return overThreshold
}

// After
func CanShipFree(order Order) bool {
    return order.BasePrice > 100
}

// Before
fn can_ship_free(order: &Order) -> bool {
    let base_price = order.base_price;
    let over_threshold = base_price > 100.0;
    over_threshold
}

// After
fn can_ship_free(order: &Order) -> bool {
    order.base_price > 100.0
}

กลไกการทำงาน

เช็คว่า expression ที่กำหนดให้ตัวแปรไม่มี side effect — การ inline ต้องไม่เปลี่ยนว่า expression นั้นรัน เมื่อไร หรือ กี่ครั้ง
ถ้าตัวแปรยังไม่ใช่ read-only ให้เปลี่ยนเป็น read-only ก่อน (const, final หรือ binding ที่กำหนดค่าได้ครั้งเดียว) ถ้า compiler บ่น แปลว่ามีการกำหนดค่าใหม่ ให้หยุดตรงนั้น เพราะตัวแปรทำมากกว่าสะท้อนค่าแล้ว
หาจุดแรกที่อ่านตัวแปร แล้วแทนที่ด้วย expression
รัน test
ทำซ้ำกับจุดที่เหลือทีละจุด รัน test คั่นไปเรื่อย ๆ
เมื่อไม่เหลือจุดที่อ่านแล้ว ให้ลบบรรทัดประกาศตัวแปรทิ้ง
รัน test อีกรอบ

ใช้เมื่อไหร่ / ข้อแลกเปลี่ยน

inline ตัวแปรเมื่อชื่อไม่ได้ให้ข้อมูลอะไรเกินกว่าที่ expression บอกอยู่แล้ว และใช้แค่หนึ่งหรือสองจุดที่อยู่ใกล้กัน ถอดออกแล้ว function สั้นลง และผู้อ่านไม่ต้องกระโดดไปมาอีกหนึ่งครั้ง

อย่า inline ถ้าชื่อตัวแปรอธิบายความหมายที่ไม่ชัดในตัว ถ้า expression ใช้ซ้ำหลายครั้ง (ชื่อช่วยเลี่ยงทั้งความซ้ำและการคำนวณซ้ำ) หรือถ้า expression แพงและตัวแปรทำหน้าที่ cache ผลไว้ กรณีแบบนั้นสิ่งที่คุณต้องการคือด้านตรงข้าม — Extract Variable

เนื้อหาที่เกี่ยวข้อง

ใช้ Inline Variable เมื่อ	หลีกเลี่ยงเมื่อ
variable name ไม่ได้อธิบายดีกว่า expression	expression ซับซ้อน — variable ช่วยให้อ่านง่าย
variable ใช้แค่ครั้งเดียว ทันทีหลัง assign	ต้องการ debug — variable ทำให้เห็นค่ากลาง
กำลัง refactor และ variable กลายเป็น noise	expression มี side effect

⚠️ ไม่ควร Inline Variable เมื่อ:

expression นั้นใช้หลายจุด — inline แล้วจะ evaluate ซ้ำ

ชื่อ variable บอก business intent ที่ expression ไม่บอก

expression มี side effect ที่ต้องรันแค่ครั้งเดียว