Flutter และ Dart 3: Records, Patterns และ Sealed Classes สำหรับคำถามสัมภาษณ์ขั้นสูง ปี 2026

Dart 3 ได้นำเสนอชุดฟีเจอร์ใหม่ที่เปลี่ยนแปลงวิธีการเขียนโค้ด Flutter อย่างมีนัยสำคัญ โดยเฉพาะ Records, Pattern Matching และ Sealed Classes ซึ่งเป็นเครื่องมือที่ช่วยให้นักพัฒนาสามารถเขียนโค้ดที่ปลอดภัยต่อ type มากขึ้น อ่านง่ายขึ้น และลดข้อผิดพลาดที่เกิดขึ้นในระหว่าง runtime ได้อย่างมีประสิทธิภาพ ฟีเจอร์เหล่านี้ไม่เพียงแต่เป็นหัวข้อที่พบบ่อยในการสัมภาษณ์งานตำแหน่ง Flutter Developer เท่านั้น แต่ยังเป็นทักษะที่จำเป็นสำหรับการพัฒนาแอปพลิเคชัน Flutter ในระดับ production อีกด้วย

บทความนี้จะอธิบายแนวคิดหลักของแต่ละฟีเจอร์พร้อมตัวอย่างโค้ดที่สามารถนำไปใช้งานได้จริง ตั้งแต่พื้นฐานของ Records ไปจนถึงการออกแบบ State Management ด้วย Sealed Classes และ Exhaustive Pattern Matching

Records: การคืนค่าหลายค่าอย่างปลอดภัยและกระชับ

ก่อนที่จะมี Records นักพัฒนา Dart มักต้องสร้าง class หรือใช้ Map เพื่อคืนค่าหลายค่าจากฟังก์ชัน ซึ่งทำให้โค้ดยาวเกินความจำเป็นและอาจเกิดข้อผิดพลาดจากการพิมพ์ key ผิด Records แก้ปัญหานี้โดยให้ syntax ที่กระชับสำหรับการจัดกลุ่มค่าหลายค่าเข้าด้วยกัน พร้อมทั้ง type safety เต็มรูปแบบ

Records มีสองรูปแบบหลัก คือ positional records ที่ระบุค่าตามลำดับตำแหน่ง และ named records ที่ระบุค่าตามชื่อ field ซึ่งช่วยเพิ่มความชัดเจนเมื่อมี field จำนวนมาก

// Returning multiple values with a positional record
(String, int) parseUserInput(String raw) {
  final parts = raw.split(':');
  return (parts[0].trim(), int.parse(parts[1]));
}

// Named fields improve readability for complex returns
({String name, String email, bool isVerified}) fetchUserProfile(String id) {
  // Simulated database lookup
  return (
    name: 'Alice Chen',
    email: 'alice@example.com',
    isVerified: true,
  );
}

จากตัวอย่างข้างต้น ฟังก์ชัน parseUserInput ใช้ positional record (String, int) เพื่อคืนค่าชื่อและตัวเลขจาก string ที่ส่งเข้ามา ในขณะที่ fetchUserProfile ใช้ named record ซึ่งทำให้ผู้อ่านโค้ดเข้าใจความหมายของแต่ละ field ได้ทันทีโดยไม่ต้องดูเอกสารเพิ่มเติม

ในการสัมภาษณ์งาน ผู้สมัครมักถูกถามเกี่ยวกับข้อแตกต่างระหว่าง positional records และ named records รวมถึงสถานการณ์ที่เหมาะสมสำหรับแต่ละรูปแบบ หลักการทั่วไปคือ ควรใช้ positional records สำหรับการคืนค่าสองถึงสาม field ที่มีความหมายชัดเจนในตัว (เช่น พิกัด x, y) และเปลี่ยนไปใช้ named records เมื่อจำนวน field เพิ่มขึ้นหรือเมื่อ field มี type เหมือนกันจนอาจสับสนได้

Structural Equality ของ Records

คุณสมบัติสำคัญอีกประการหนึ่งของ Records คือ structural equality ซึ่งหมายความว่า Records สองตัวที่มีค่าเท่ากันจะถือว่าเท่ากันโดยอัตโนมัติ โดยไม่ต้องเขียน operator == หรือ hashCode เอง พฤติกรรมนี้แตกต่างจาก class ทั่วไปที่ใช้ referential equality เป็นค่าเริ่มต้น

// Structural equality — no need for custom == operator
void main() {
  final a = (1, 'hello');
  final b = (1, 'hello');
  print(a == b); // true — records compare by value

  // Named fields also support equality
  final profile1 = (name: 'Alice', role: 'admin');
  final profile2 = (name: 'Alice', role: 'admin');
  print(profile1 == profile2); // true
}

Structural equality ทำให้ Records เหมาะสำหรับการใช้เป็น key ใน Map หรือใน Set เนื่องจาก hashCode ถูกคำนวณจากค่าของ field ทั้งหมดโดยอัตโนมัติ นอกจากนี้ยังช่วยลดโค้ด boilerplate ที่มักต้องเขียนใน data class ทั่วไป ซึ่งเป็นข้อดีที่สำคัญในการสัมภาษณ์เมื่อต้องอธิบายว่า Records ช่วยลดความซับซ้อนของโค้ดได้อย่างไร

Pattern Matching: การ Destructure ข้อมูลอย่างทรงพลัง

Pattern Matching ใน Dart 3 ช่วยให้นักพัฒนาสามารถ destructure ค่าจาก Records, Lists และ Objects ได้อย่างกระชับ แทนที่จะต้องเข้าถึง field ทีละตัว สามารถดึงค่าทั้งหมดออกมาเป็นตัวแปร local ได้ในบรรทัดเดียว

// Destructuring a record with pattern matching
void main() {
  final (name, email, isVerified) = fetchUserProfile('u-123');
  // name, email, isVerified are now local variables

  // List patterns with rest operator
  final scores = [98, 87, 92, 76, 84];
  final [first, second, ...remaining] = scores;
  print('Top two: $first, $second'); // 98, 87
  print('Others: $remaining');        // [92, 76, 84]
}

ตัวอย่างนี้แสดงให้เห็นสองรูปแบบหลักของ Pattern Matching ประการแรก คือ record destructuring ที่ดึงค่าจาก named record ออกมาเป็นตัวแปร name, email และ isVerified โดยตรง ประการที่สอง คือ list pattern ที่ใช้ rest operator (...) เพื่อจับส่วนที่เหลือของ list ไว้ในตัวแปรเดียว

List patterns มีประโยชน์มากสำหรับการประมวลผลข้อมูลที่มีโครงสร้างคงที่ เช่น ผลลัพธ์จาก API ที่คืน array ที่มี element แรกเป็น header และ elements ที่เหลือเป็นข้อมูล หรือการแยกส่วนของ URL path ออกเป็น segments ต่างๆ

Switch Expressions และ Guard Clauses

Dart 3 ยกระดับ switch statement ให้เป็น switch expression ที่สามารถคืนค่าได้โดยตรง พร้อมทั้งรองรับ guard clauses ด้วยคำสั่ง when ซึ่งช่วยให้เขียนเงื่อนไขที่ซับซ้อนได้อย่างกระชับ

// Switch expression with guard clauses
String classifyScore(int score) => switch (score) {
  >= 90 => 'Excellent',
  >= 80 => 'Good',
  >= 70 => 'Average',
  >= 60 => 'Below Average',
  _ => 'Needs Improvement',
};

// Object pattern matching with type checking
String describeValue(Object value) => switch (value) {
  int n when n < 0   => 'Negative integer: $n',
  int n              => 'Positive integer: $n',
  String s when s.isEmpty => 'Empty string',
  String s           => 'String of length ${s.length}',
  List l when l.isEmpty  => 'Empty list',
  List l             => 'List with ${l.length} elements',
  _                  => 'Unknown type',
};

ฟังก์ชัน classifyScore แสดงให้เห็นการใช้ relational patterns (>= 90) เพื่อจำแนกคะแนนเป็นระดับต่างๆ ส่วนฟังก์ชัน describeValue แสดงการใช้ object patterns ร่วมกับ type checking และ guard clauses เพื่อจัดการ input ที่มีหลาย type ได้อย่างปลอดภัย

สิ่งสำคัญที่ควรทราบคือ switch expression ใน Dart 3 บังคับให้ครอบคลุมทุกกรณีที่เป็นไปได้ (exhaustiveness) หากไม่มี wildcard pattern (_) เป็น case สุดท้าย compiler จะแจ้งข้อผิดพลาดหากมีกรณีที่ไม่ได้ครอบคลุม ซึ่งช่วยป้องกัน bug ที่เกิดจากการลืมจัดการบาง case ได้

Sealed Classes: การกำหนด State ที่ครบถ้วนและปลอดภัย

Sealed Classes เป็นหนึ่งในฟีเจอร์ที่ทรงพลังที่สุดของ Dart 3 สำหรับการออกแบบ State Management ในแอปพลิเคชัน Flutter โดย sealed class กำหนดชุดของ subclass ที่เป็นไปได้ทั้งหมด และ compiler จะตรวจสอบว่าโค้ดที่ใช้ sealed class นั้นครอบคลุมทุก subclass หรือไม่

// Sealed class defining all possible authentication states
sealed class AuthState {}

class AuthInitial extends AuthState {}

class AuthLoading extends AuthState {}

class AuthAuthenticated extends AuthState {
  final String userId;
  final String displayName;
  AuthAuthenticated({required this.userId, required this.displayName});
}

class AuthError extends AuthState {
  final String message;
  final int? statusCode;
  AuthError({required this.message, this.statusCode});
}

ตัวอย่างข้างต้นกำหนด AuthState เป็น sealed class ที่มี subclass สี่ตัว ได้แก่ AuthInitial สำหรับสถานะเริ่มต้น, AuthLoading สำหรับสถานะกำลังโหลด, AuthAuthenticated สำหรับสถานะที่ผู้ใช้ยืนยันตัวตนสำเร็จ และ AuthError สำหรับสถานะที่เกิดข้อผิดพลาด

ข้อดีของ sealed class คือ Dart compiler สามารถรับประกันได้ว่าไม่มี subclass อื่นนอกเหนือจากที่กำหนดไว้ในไฟล์เดียวกัน ซึ่งทำให้ switch expression สามารถตรวจสอบความครบถ้วนได้อย่างสมบูรณ์

Exhaustive Switch กับ Sealed Classes

เมื่อใช้ sealed class ร่วมกับ switch expression จะได้ exhaustive pattern matching ที่ compiler ตรวจสอบให้แน่ใจว่าทุก subclass ถูกจัดการอย่างถูกต้อง หากมีการเพิ่ม subclass ใหม่ในอนาคต compiler จะแจ้งข้อผิดพลาดทุกจุดที่ยังไม่ได้จัดการ case ใหม่นั้น

// Exhaustive switch — compiler error if a case is missing
Widget buildAuthUI(AuthState state) => switch (state) {
  AuthInitial()       => const LoginPrompt(),
  AuthLoading()       => const CircularProgressIndicator(),
  AuthAuthenticated(
    displayName: final name
  )                   => Text('Welcome, $name'),
  AuthError(
    message: final msg,
    statusCode: final code,
  )                   => ErrorBanner(
    message: msg,
    code: code,
  ),
};

ในตัวอย่างนี้ ฟังก์ชัน buildAuthUI ใช้ switch expression เพื่อสร้าง Widget ที่เหมาะสมสำหรับแต่ละสถานะ สังเกตว่าไม่มี wildcard pattern (_) เป็น case สุดท้าย เนื่องจาก compiler รู้ว่า AuthState มี subclass ทั้งหมดสี่ตัวและทุกตัวถูกจัดการแล้ว

นอกจากนี้ ตัวอย่างยังแสดงการ destructure ค่าจาก subclass โดยตรงภายใน switch case เช่น AuthAuthenticated(displayName: final name) ซึ่งดึงค่า displayName ออกมาเป็นตัวแปร name โดยไม่ต้องใช้ as หรือ is อย่างที่ทำในโค้ดแบบเดิม

การออกแบบ Generic Sealed Type สำหรับ API Layer

หนึ่งในรูปแบบที่นิยมมากที่สุดในการใช้ sealed classes คือการสร้าง generic result type สำหรับ API layer ซึ่งช่วยจัดการทั้ง success case และ error case ได้อย่างเป็นระบบและปลอดภัยต่อ type

// Generic sealed result type for API operations
sealed class ApiResult<T> {}

class ApiSuccess<T> extends ApiResult<T> {
  final T data;
  final ({int statusCode, Map<String, String> headers}) metadata;
  ApiSuccess(this.data, {required this.metadata});
}

class ApiFailure<T> extends ApiResult<T> {
  final String error;
  final int? statusCode;
  ApiFailure(this.error, {this.statusCode});
}

ApiResult<T> เป็น sealed class ที่ใช้ generics ทำให้สามารถนำไปใช้กับ data type ใดก็ได้ ApiSuccess เก็บทั้งข้อมูลผลลัพธ์และ metadata (เช่น status code และ headers) ในรูปแบบ record ในขณะที่ ApiFailure เก็บข้อความ error และ status code ที่อาจเป็น null

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

การใช้ Nested Pattern Matching กับ API Result

เมื่อนำ ApiResult ไปใช้จริงในการสร้าง UI สามารถใช้ nested pattern matching เพื่อจัดการเงื่อนไขย่อยภายในแต่ละ case ได้อย่างละเอียด

// Consuming the sealed result with pattern matching
Widget buildProductList(ApiResult<List<Product>> result) => switch (result) {
  ApiSuccess(
    data: final products,
    metadata: (statusCode: 200, headers: _),
  ) when products.isNotEmpty => ListView.builder(
    itemCount: products.length,
    itemBuilder: (_, i) => ProductCard(products[i]),
  ),
  ApiSuccess(data: final products) when products.isEmpty =>
    const EmptyState(message: 'No products found'),
  ApiFailure(statusCode: 401) =>
    const AuthExpiredBanner(),
  ApiFailure(error: final msg) =>
    ErrorDisplay(message: msg),
};

ตัวอย่างนี้แสดงให้เห็นพลังของ nested pattern matching อย่างชัดเจน case แรกตรวจสอบว่าเป็น ApiSuccess ที่มี status code 200 และมีข้อมูล product อย่างน้อยหนึ่งรายการ case ที่สองจัดการกรณีที่ API สำเร็จแต่ไม่มีข้อมูล case ที่สามจัดการกรณี authentication expired โดยเฉพาะ (status code 401) และ case สุดท้ายจับ error ทั่วไปทั้งหมด

รูปแบบนี้เป็นหัวข้อที่นิยมถามในการสัมภาษณ์งานระดับ Senior เนื่องจากแสดงให้เห็นความเข้าใจในหลักการ type safety, exhaustiveness checking และการออกแบบ API layer ที่ดี

If-Case Pattern สำหรับ Null-Safe Data Extraction

นอกจาก switch expression แล้ว Dart 3 ยังเพิ่ม if-case syntax สำหรับการ destructure ข้อมูลแบบมีเงื่อนไข ซึ่งมีประโยชน์อย่างมากเมื่อต้องทำงานกับข้อมูลที่มาจากแหล่งภายนอก เช่น JSON ที่อาจมี field ขาดหายหรือมี type ไม่ตรงตามที่คาดหวัง

// If-case for null-safe extraction
void processUser(Map<String, dynamic> json) {
  if (json case {'name': String name, 'age': int age}) {
    // name and age are non-nullable here
    print('$name is $age years old');
  } else {
    print('Invalid user data');
  }
}

If-case pattern ทำหน้าที่สามอย่างพร้อมกัน ได้แก่ ตรวจสอบว่า key ที่ต้องการมีอยู่ใน Map หรือไม่, ตรวจสอบว่า value มี type ที่ถูกต้อง และ destructure ค่าออกมาเป็นตัวแปร non-nullable ทั้งหมดนี้ทำได้ในบรรทัดเดียวโดยไม่ต้องใช้ null checks หลายชั้น

รูปแบบนี้มีประโยชน์อย่างยิ่งเมื่อทำงานกับ API response ที่ไม่มี code generation อย่าง freezed หรือ json_serializable เนื่องจากช่วยให้การ parse JSON ด้วยมือปลอดภัยและกระชับมากขึ้น

แนวทางปฏิบัติที่ดีสำหรับการใช้ Records, Patterns และ Sealed Classes

จากประสบการณ์ในการพัฒนาแอปพลิเคชัน Flutter ระดับ production มีแนวทางปฏิบัติที่ดีหลายประการที่ควรนำไปใช้

ประการแรก ควรเลือกใช้ named records แทน positional records เมื่อมี field มากกว่าสาม field หรือเมื่อ field มี type เหมือนกัน เช่น (String, String) อาจสร้างความสับสนว่า String ตัวไหนคือ name และตัวไหนคือ email แต่ ({String name, String email}) นั้นชัดเจนในตัวเอง

ประการที่สอง ควรใช้ sealed classes แทน enum เมื่อ subtype ต้องการเก็บข้อมูลเพิ่มเติม เนื่องจาก sealed classes รองรับ field และ constructor ที่แตกต่างกันในแต่ละ subclass ในขณะที่ enum สามารถมี field ร่วมกันเท่านั้น

ประการที่สาม ควรหลีกเลี่ยงการใช้ wildcard pattern (_) เป็น case สุดท้ายใน switch expression ที่ใช้กับ sealed classes เนื่องจากจะทำให้สูญเสียประโยชน์ของ exhaustiveness checking หากมีการเพิ่ม subclass ใหม่ในอนาคต compiler จะไม่แจ้งเตือนเพราะ wildcard จะจับทุก case ที่เหลือ

ประการที่สี่ ควรใช้ guard clauses (when) เพื่อแยกเงื่อนไขย่อยภายใน case เดียวกัน แทนที่จะใช้ if-else ซ้อนกันภายใน body ของ case ซึ่งช่วยให้โค้ดอ่านง่ายและบำรุงรักษาง่ายขึ้น

คำถามสัมภาษณ์ที่พบบ่อยเกี่ยวกับ Dart 3

ในการสัมภาษณ์งานตำแหน่ง Flutter Developer ระดับ Senior และ Lead มักพบคำถามเกี่ยวกับฟีเจอร์ใหม่ของ Dart 3 หลายหัวข้อ

Records กับ Classes ต่างกันอย่างไร -- Records เป็น value type ที่มี structural equality ในตัว ไม่สามารถมี methods หรือ inheritance ได้ และเหมาะสำหรับการจัดกลุ่มค่าชั่วคราว ส่วน classes เป็น reference type ที่มี referential equality เป็นค่าเริ่มต้น สามารถมี methods, constructors และ inheritance ได้ เหมาะสำหรับการสร้าง abstraction ที่ซับซ้อน

Sealed Classes ต่างจาก Abstract Classes อย่างไร -- Sealed classes จำกัดให้ subclass ทั้งหมดอยู่ในไฟล์เดียวกัน ซึ่งทำให้ compiler สามารถตรวจสอบ exhaustiveness ใน switch expression ได้ ส่วน abstract classes สามารถมี subclass ในไฟล์ใดก็ได้ จึงไม่สามารถรับประกัน exhaustiveness ได้

เมื่อใดควรใช้ Pattern Matching แทน if-else แบบเดิม -- Pattern matching เหมาะสมเมื่อต้องจัดการหลายเงื่อนไขที่เกี่ยวข้องกับ type checking, null checking หรือ destructuring พร้อมกัน เนื่องจากช่วยลดโค้ดซ้ำซ้อนและเพิ่มความปลอดภัยต่อ type

สรุป

ฟีเจอร์ Records, Pattern Matching และ Sealed Classes ใน Dart 3 เป็นการยกระดับภาษา Dart ให้ทัดเทียมกับภาษาสมัยใหม่อย่าง Kotlin, Swift และ Rust ในด้านความสามารถในการจัดการ type อย่างปลอดภัยและการเขียนโค้ดที่กระชับ

ประเด็นสำคัญที่ควรจดจำ:

• Records ช่วยให้คืนค่าหลายค่าจากฟังก์ชันได้อย่างปลอดภัยโดยมี structural equality ในตัว
• Pattern Matching ช่วยให้ destructure ข้อมูลและเขียน control flow ที่ซับซ้อนได้อย่างกระชับและปลอดภัย
• Sealed Classes ร่วมกับ exhaustive switch ช่วยรับประกันว่าทุกสถานะถูกจัดการอย่างครบถ้วน
• Generic sealed types อย่าง ApiResult<T> เป็นรูปแบบที่มีประสิทธิภาพสำหรับ API layer
• If-case patterns ช่วยให้การ parse ข้อมูลจากแหล่งภายนอกปลอดภัยและกระชับยิ่งขึ้น
• Guard clauses ด้วยคำสั่ง when ช่วยให้จัดการเงื่อนไขย่อยได้โดยไม่ต้อง nest if-else

สำหรับนักพัฒนาที่กำลังเตรียมตัวสัมภาษณ์งาน การทำความเข้าใจฟีเจอร์เหล่านี้อย่างลึกซึ้งพร้อมทั้งสามารถอธิบายข้อดี ข้อเสีย และสถานการณ์ที่เหมาะสมในการใช้งานแต่ละฟีเจอร์ จะเป็นจุดแข็งที่สำคัญในการแสดงความเชี่ยวชาญด้าน Flutter และ Dart 3