การกำหนดและใช้งาน Function ในภาษา Dart เบื้องต้น

03 October 2019 By Ninenik Narkdee
ฟังก์ชั่นในภาษา dart function in dart dart

คำสั่ง การ กำหนด รูปแบบ ตัวอย่าง เทคนิค ลูกเล่น การประยุกต์ การใช้งาน เกี่ยวกับ ฟังก์ชั่นในภาษา dart function in dart dart



เนื่องจาก Dart เป็นภาษาโปรแกรมเชิงวัตถุ ทุกอย่างล้วนเป็น Object
รวมถึงฟังก์ชั่นก็เป็น object หนึ่ง เป็นประเภทข้อมูลที่เรียกว่า function  ดังนั้น เราสามารถ
ที่จะกำหนดฟังก์ชั่นใก้กับตัวแปรได้ หรือเราสามารถที่จะกำหนดฟังก์ชั่นในการส่งค่า
ให้กับฟังก์ชั่นอื่นได้
    ในภาษา Dart มีฟังก์ชั่น main() เป็นฟังก์ชั่นหลักในทุกๆ App เปรียบเหมือนเป็นทางเข้าของโปรแกรม
โดยเป็นฟังก์ชั่นแรกที่ทำงานอัตโนมัติก่อนฟังก์ชั่นอื่น 
 
 

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

    เราลองดูรูปแบบฟังก์ชั่น main() เป็นแนวทาง 
 
void main () {
  // ส่วนของฟังก์ชั่น body 
}
 
    จากฟังก์ชั่น main ข้างต้น เราพอจะเห็นองค์ประกอบคร่าวๆ ของฟังก์ชั่น ตามรูปแบบดังนี้คือ
 
[ประเภทตัวแปรที่คืนค่ากลับ] [ชื่อฟังก์ชั่น]( [พารามิเตอร์] ){
  // ส่วนของฟังก์ชั่น body หรือส่วนสำหรับกำหนดการทำงาน
}
 
    หากเปรียบเทียบกับฟังก์ชั่น main จะได้ว่า void คือการกำหนดประเภทตัวแปรที่คืนค่ากลับมาจากฟังก์ชั่น ซึ่ง void จะหมายถึง
ไม่มีการคืนค่าใดๆ กลับมา  หรือเท่ากับ null  โดยปกติแล้วเราจะกำหนดประเภทตัวแปรที่จะคืนค่ากลับมาหรือไม่ก็ได้ เปรียบเหมือนเป็น
option หนึ่งจะมีหรือไม่ก็ได้  แต่เพื่อความปลอดภัยและความถูกต้องของข้อมูล Dart แนะนำให้กำหนดส่วนนี้เข้าไปด้วย
    ตามด้วยส่วนต่อมาคือ main โดย main ก็คือชื่อฟังก์ชั่นที่เรากำหนด จากนั้นต่อมาก็ส่วนของ พารามิเตอร์ในวงเล็บ ในรูปแบบ
(parameter1, parameter2)  ในส่วนนี้เป็นการกำหนดข้อมูลตัวแปร ที่เราต้องการส่งเข้าไปใช้งานในฟังก์ชั่น ซึ่งในฟังก์ชั่น main()
ข้างต้นไม่มีการกำหนดในส่วนนี้  และสุุดท้ายส่วนของ ฟังก์ชั่น body ที่อยู้เครื่องหมาย { } เป็นส่วนที่เราจะกำหนดการทำงานต่างๆ ให้กับ
ฟังก์ชั่น  เรามาดูตัวอย่างฟังก์ชั่น และคำอธิบายเพิ่มเติม ดังนี้
 
void main () {
  // เรียกใช้งานฟังก์ชั่น
  findArea(); // output: Area: 2000
}

// ฟังก์ชั่นนี้ไม่มีการคืนค่าใดๆ 
findArea(){
  int width = 20;
  int height = 100;  
  int area = width * height; 
  print("Area: $area");
}
 
    ฟังก์ชั่น findArea() ข้างต้น ไม่ได้มีการกำหนดการคืนค่า ซึ่งฟังก์ชั่นใดๆ ทีไม่มีการคืนค่ากลับมา จะมีค่าการคืนค่าเป็น null 
และจะเห็นว่า เราไม่ได้กำหนด void เข้าไป แต่ฟังก์ชั่นก็ยังสามารถทำงานได้  แต่อย่างไรก็ตาม การกำหนด void ให้กับฟังก์ชั่น
ที่ไม่มีการคืนค่า ก็เป็นวิธีที่เหมาะสมกว่า ช่วนให้เราทราบถึงเป้าหมายของการทำงานของฟังก์ชั่นนั้นๆ ให้เราทราบผลลัพธ์ความ
ต้องการของประเภทข้อมูลจากฟังก์ชั่นนั้นๆ 
 
// กรณีกำหนดเป็น void
void findArea(){
  return null; // ในกรณีเป็น void ไม่จำเป็นต้องกำหนด return null ก็ได้
}

// กรณีกำหนดค่าการคืนค่าเป็น int
int findArea(){
  int width = 20;
  int height = 100;  
  int area = width * height; 
  // return "Area: $area"; // หากใช้บรรทัดนี้ จะเกิด error เพราะว่าค่าที่ส่งออกไปเป็น string
  return area; // ค่าที่ส่งกลับเป็น int ตรงกับความต้องการของฟังก์ชั่น
}
 
    เข้าใจอย่างง่ายก็คือ ถ้าเราต้องการค่าจากฟังก์ชั่นนั้นเป็นข้อมูลประเภทไหน เพื่อที่จะนำปใช้งานต่อ เราควรกำหนดประเภทข้อมูลที่ทำการ
คืนค่ากลับมาด้วยเสมอ
 
 

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

    ในฟังก์ชั่น findArea() ข้างต้น จะเห็นว่า ในขั้นตอนการใช้งาน ไม่มีการส่งค่าใดๆ เข้าไปในฟังก์ชั่น ดังนั้นค่าที่ได้ จากการคำนวณหาพื้นที่
จากความกว้างและความสูง จึงเป็นค่าที่ถูกกำหนดตายตัวไว้ในฟังก์ชั่นนั้น และเพื่อให้เราสามารถส่งค่าความกว้างและความสูงเข้าไปในฟังก์ชั่น
เพื่อให้สามารถใช้นั้นๆ ในการคำนวณแทน สามารถทำได้โดยการกำหนด parameter ให้กับฟังก์ชั่นดังนี้
 
void main () {
  // เรียกใช้งานฟังก์ชั่น พร้อมกำหนด argument 2 ค่า ให้กับฟังก์ชั่น
  findArea(20, 100); 
  // อย่าเพิ่งสับสนระหว่างค่า arguments กับ parameters
  // arguments คือค่าหรือตัวแปร ที่ส่งเข้าไปในฟังก์ชั่น ตอนเรียกใช้งาน
  // parameters คือตัวแปรที่กำหนดสำหรับรับค่า ในตอนประกาศฟังก์ชั่น
}

// มีการกำหนด parameters ให้กับฟังก์ชั่น
int findArea(int width, int height){
  return width * height; 
}
 
    จะเห็นว่าฟังก์ชั่น findArea ข้างต้นมีการกำหนด parameters ให้กับฟังก์ชั่นสำหรับรับค่าข้อมูลหรือตัวแปรเข้ามาใช้งานในฟังก์ชั่น
โดยรับค่า width และ height เป็นข้อมูลประเภท int ทั้งสองค่า จากนั้น ฟังก์ชั่นก็ทำการคืนค่า ผลลการคำนวณหากพื้นที่จากสูตรกลับออก
มา ซึ่งค่าที่คืนกลับออกมาก็จะเป็นค่า int 
    ในส่วนของการเรียกใช้งาน เนื่องจากฟังก์ชั่น findArea() มีการกำหนด parameter ดังนั้น เราต้องส่งค่า arguments ตามความต้อง
การของฟังก์ชั่น  ข้างต้นเราส่งค่า width เท่ากับ 20 สำหรับ parameter ในตำแหน่งแรก และส่งค่า height เท่ากับ 100 สำหรับ parameter
ในตำแหน่งที่สอง จะได้เปฌ็น findArea(20, 100); 
    เมื่อโปรแกรมทำงาน ค่าของ findArea(20, 100); จะมีค่าเท่ากับ 2000 แต่เนื่องจากเราไม่มีการนำค่าของมาแสดงหรือนำมาใช้งาน ผลลัพธ์
ของคำสั่งข้างต้นจึงไม่มีอะไรเกิดขั้น เราสามารถทำการแสดงค่าโดยทำการ print ผลลัพธ์จากฟังก์ช่ั่นโดยตรง หรือจะสร้างตัวแปรมารับค่า
และทำการ print ค่าออกมาอีกทีก็ได้ เช่น
 
void main () {
  // สร้างตัวแปรมารับค่า ที่คืนมาจากฟังก์ชั่น
  var area = findArea(20, 100); 
  print("Area: $area");
  // หรือสามารถใช้คำสั่งแสดงผลดังนี้ได้ print(findArea(20, 100));

}
// มีการกำหนด parameters ให้กับฟังก์ชั่น
int findArea(int width, int height){
  return width * height; 
}
 
    ตัวอย่างข้างต้น เราทำการกำหนดค่าตัวแปร area เท่ากับฟังก์ช่ัน findArea(20, 100)  เป็นรูปแบบการใช้งานฟังก์ชันโดยการกำหนด
ค่าให้กับตัวแปร  เรามาดูอีกตัวอย่างการใช้งานฟังก์ชั่น โดยจะเป็นการใช้่ฟังก์ชั่น เป็นตัวแปร arguments หนึ่งของอีกฟังก์ชั่น ดังนี้
 
void main () {

  // เรียกใช้งาน หาปริมาตรทรงกรงกระบอก มีการส่งค่าฟังก์ชั่นเข้าไป
  // ใช้งานในฟังก์ชันอีกที
  var volume = cylinderVVolume(circleArea(10), 15);
  print("Volume of cylinder: $volume");
  // output: Volume of cylinder: 4712.385
  
}

// ฟังก์ชั่นหาพื้นที่ของวงกลม
double circleArea(double radious){
  // ค่า pi ประมาณ 3.14159 สูตรพื้นทีวงกลม pi * (radious * radious)
  return 3.14159 * (radious * radious);
  
}
// ฟังก์ชั่นหาปริมาตรของทรงกระบอก
double cylinderVVolume(double area, double height){
  // ปริมาตรของทรงกระบอกเท่ากับ พื้นวงกลม * ความสูง
  return area * height;
}
 
    จะเห็นว่า เรามีการใช้งานฟังก์ชั่น circleArea() เพื่อหาพื้นที่ของวงกลม ไปใช้เป็นค่า argument ตัวแรกของฟังก์ชั่น cylinderVVolume() 
อีกที เพื่อหาปริมาตรของทรงกระบอก เป็นอีกรูปแบบหนึ่งของการใช้งานฟังก์ชั่น
 
    สำหรับฟังก์ชั่นที่มีชุดคำสั่งการทำงานเดียว เราสามารถเขียนรูปแบบย่อ ที่เรียก arrow ฟังก์ชั่นได้ ยกตัวอย่างฟังก์ชั่น
เกี่ยวกับพื้นที่ และปริมาตรจากตัวอย่างด้านบน สามารถกำหนดเป็นแบบนี้แทนได้
 
// ฟังก์ชั่นหาพื้นที่ของวงกลม
double circleArea(double radious) => 3.14159 * (radious * radious);
// ฟังก์ชั่นหาปริมาตรของทรงกระบอก
double cylinderVVolume(double area, double height) => area * height;
 
    จะเห็นว่าในฝั่งด้านซ้ายของเครื่องหมาย fat arrow (=>) จะเป็นชื่อฟังก์ชั่นและ parameter ในขณะที่ด้านขวาจะเป็น expression 
คำสั่งหรือนิพจน์การตรวจสอบ โดยตัดคำสั่ง return ออก วิธีข้างต้น จะช่วยให้สามารถเขียนโค้ดได้กระชับขึ้น
 
 

ประเภทของ Parameters

    ในการกำหนด parameter ให้กับฟังก์ชั่น จะมีด้วยกัน 2 รูปแบบคือ
  • Required parameters
  • Optional parameters
    โดย required parameter เป็นค่า parameter ที่เราจำเป็นต้องกำหนดค่าสำหรับใช้งานในฟังก์ชั่น ในขณะที่ optional parameter จะเป็น
parameter ตัวเลือก จะกำหนดหรือไม่ก็ได้ และหากไม่กำหนด ก็จะไม่ส่งผลต่อการทำงานของฟังก์ชั่นที่เราสร้าง ซึ่งก็ขึ้นอยู่กับรูปแบบการใช้งาน
ของฟังก์ชั่นนั้นๆ ด้วย  การกำหนด parameter จะกำหนดเป็น required parameter ก่อน แล้วค่อยตามด้วย optional parameter (ถ้ามี)
 
 

Required parameters

    เรามาเริ่มต้นดูที่ตัวอย่าง Required parameter โดยกลับไปดูฟังก์ชั่นเกี่ยวกับการหาพื้นที่และปริมาตรของวงกลม และทรงกระบอกตามลำดับ
 
void main () {

  var volume = cylinderVVolume(circleArea(10), 15);
  print("Volume of cylinder: $volume");
  // output: Volume of cylinder: 4712.385
  
}
// double radious เป็น required parameter
double circleArea(double radious){
  return 3.14159 * (radious * radious);
}
// double area และ double height เป็น required parameter
double cylinderVVolume(double area, double height){
  return area * height;
}
 
    จะเห็นว่า ทั้ง circleArea() และ cylinderVVolume() ฟังก์ชั่นทั้งสอง มีการกำหนด parameter 1 ตัวและ 2 ตัวตามลำดับ และเพื่อให้ฟังก์ชั่น
สามารถทำงานได้ เราจำเป็นต้องทำการส่งค่า argument ไปในฟังก์ชั่นทั้งสอง ไม่เช่นนั้น จะเกิด error ขึ้น อย่างเช่น การหาพื้นที่วงกลม 
หากไม่กำหนดรัศมีเข้าไป ค่า radious ก็จะเป็น null และไม่สามารถคำนวนพื้นที่ของวงกลมได้ เช่นเดียวกับการหาปริมาณ 
    หากกเรากำหนดแค่พื้นที่ของวงกลมไป แต่ไม่กำหนดค่าความสูง หรือค่าความสูงเป็น null การหาปริมาตรของทรงกระบอกก็ไม่สามารทำงานได้ เช่นกัน
นั่นหมายความว่า ตัวแปร parameter double radious ของฟังก์ชั่น circleArea() และตัวแปร parameter double area กับ double height ของฟังก์ชั่น 
cylinderVVolume() จึงเรียกได้ว่าเป็น Required parameters  ซึ่งโดยปกติทั่วไปแล้ว การกำหนดฟังก์ชั่นจะเป็นใช้งานในรูปแบบ required parameter 
เป็นส่วนใหญ่
 
 

Optional parameters

    ในบางกรณี ฟังก์ชั่นของเรา อาจจะไม่จำเป็นต้องใช้งาน parameter ทั้งหมดที่กำหนดในฟังก์ชั่น เราสามารถที่เลือกได้ว่า ตัวแปร paramter ใด ที่ต้องการ
ให้เป็นแบบ option ที่จะมีหรือไม่ก็ได้ โดยใน optional parameter ซึ่งสามารถแยกย่อยออกไปได้อีก 2 แบบ ได้แก่
  • Positional parameters
  • Named parameters
    โดยในฟังก์ชั่นที่มีการใช้งาน optional parameter เราสามารถเลือกได้ว่า จะใช้เป็นแบบ positional หรือ named อย่างใด อย่างหนึ่ง แต่ไม่สามารถใช้
งานหรือกำหนดพร้อมกันในฟังก์ชั่นหนึ่งๆ ได้
 

Positional parameters

    สำหรับรูปแบบการกำหนด positional parameter จะกำหนดโดยใช้เครื่องหมาย [] ปีกกาสี่เหลี่ยม ครอบส่วนของ parameter ที่ต้องการ ดูตัวอย่างฟังก์ชั่น
แสดงข้อมูลลูกค้าด้านล่างประกอบ
 
void main () {
  customer("Ebiwayo","0812345678","ebiwa@google.com");
//   output
//   Name: Ebiwayo
//   Phone: 0812345678
//   Email: ebiwa@google.com   
  customer("Ebiwayo","0812345678");
//   output  
//   Name: Ebiwayo
//   Phone: 0812345678
//   Email: null  
  customer("Ebiwayo");
//   output  
//   Name: Ebiwayo
//   Phone: null
//   Email: null    
}

// การใช้งาน positional parameter 
void customer(String name, [String phone, String email]){
  var customerDetail = '''
  Name: $name
  Phone: $phone
  Email: $email
  ''';
  print(customerDetail);
}
 
    ฟังก์ชั่นข้างต้นจะเห็นว่า name เป็น required parameter ที่เราจำเป็นต้องกำหนดเสมอ ในขณะที่ phone และ email เป็น option parameter ที่จะกำหนด
หรือไม่ได้ โดยการใช้เครื่องหมาย [ ] ครอบส่วนของ parameter ที่ต้องการข้างต้น เป็นการบอกว่า ค่า parameter phone และ email เป็น positional parameter
คุณสมบัติคือเราจะกำหนดค่านั้นหรือไม่ก็ได้ โดยหากไม่มีการกำหนดค่า และมีการเรียกใช้งาน ค่าเริ่มต้นจะเป็น null ตามตัวอย่างผลลัพธ์ข้างต้น  อย่างไรก็ตาม
ค่าของ parameter จะยังอิงกับตำแหน่งเดิม นั่นคือ สมมติเราต้องการกำหนดแค่ name กับ email ไม่กำหนดเบอร์โทร หากใช้ในรูปแบบดังนี้ 
 
customer("Ebiwayo","ebiwa@google.com");

    ตัวแปร parameter ที่สองยังเป็นค่าของ phone ดังนั้น ถึงแม้ไม่เกิด error เนื่องจาก phone และ email เป็น string เหมือนกัน แต่ผลลัพธ์ที่ได้ กลายเป็นว่า
ตัวแปร phone ถูกแทนที่ด้วยค่าที่เป็น email ซึ่งไม่ถูกต้อง กรณีแบบนี้ เราสามารถส่งค่า null เพื่อให้ฟังก์ชั่นทำงานถูกต้องเป็นดังนี้ได้
 
 customer("Ebiwayo",null,"ebiwa@google.com");
 
    เราจะได้ดูเพิ่มเติม เกี่ยวกับการแก้ปัญหานี้ ในอีกวิธีโดยการกำหนดค่าเริ่มต้นให้กับตัวแปร parameter หรือที่เรีรยกว่า default parameter ในลำดับต่อไป
 
 

Named parameters

    สำหรับรูปแบบการกำหนด named parameters คุณสมบัติหลักๆ ก็จะคล้ายๆ กับ positional parameter คือเพือให้สามารถที่กำหนดหรือกำหนด parameter
นั้นหรือไม่ก็ได้ แต่สำหรับ named parameter จะมีความสามารถเพิ่มเติม และมีรูปแบบการกำหนดที่แตกต่างจากทั่วไป 
    เราจะอ้างอิงจากตัวอย่างฟังก์ชั่น customer() ข้างต้น สำหรับ named parameter ในการกำหนดในฟังก์ชั่น จะใช้เครื่องหมาย {} ปีกกา ครอบส่วนของ
paramter  ที่ต้องการให้เป็น named parameter 
    และในการใช้งานฟังก์ชั่น เมื่อมีการกำหนดส่งค่า argument ให้กับฟังก์ชั่น เราจะต้องระบุชื่อของตัวแปรนั้น พร้อมกับค่าข้อมูลในรูปแบบ paraname: value
ด้วยเสมอ ดูตัวอย่างด้านล่างประกอบ
 
void main () {
  
  customer("Ebiwayo", phone:"0812345678",email:"ebiwa@google.com");
//   สามารถสลับตำแหน่งของ named parameter ได้ โดยผลลัพธ์เหมือนเดิม  
//   customer("Ebiwayo", email:"ebiwa@google.com", phone:"0812345678");
//   output
//   Name: Ebiwayo
//   Phone: 0812345678
//   Email: ebiwa@google.com   
  
  customer("Ebiwayo", email:"ebiwa@google.com");  
//   output  
//   Name: Ebiwayo
//   Phone: null
//   Email: ebiwa@google.com  
  
}

// การใช้งาน named parameter 
void customer(String name, {String phone, String email}){
  var customerDetail = '''
  Name: $name
  Phone: $phone
  Email: $email
  ''';
  print(customerDetail);
}
 
    จะเห็นว่าใน named parameter ในตอนเรียกใช้งานฟังก์ชั่น เราต้องกำหนดชื่อของตัวแปรนั้นๆ ด้วย และเราสามารถสลับตำแหน่งของตัวแปร
named parameter ได้  นอกจากนั้น ในกรณีเราต้องการข้าม parameter บางตัว อย่างเช่น phone เราก็สามารถข้ามตัวแปรนั้น โดยไม่กำหนดค่า null
เหมือนกรณีของ positional parameter อีกด้วย
 
 

Default parameter values

    สำหรับ default parameters เป็นวิธีการกำหนดค่าเริ่มต้นให้กับ parameter โดยจะใช้กำหนดใน optional parameter ได้ทั้ง positional และ 
named parameter โดยรูปแบบคือ การกำหนดค่า โดยใช้เครื่องหมาย = ตามด้วยค่าเริ่มเต้นที่ต้องการ เช่น

void main () {
  
  customer("Ebiwayo", email:"ebiwa@google.com");  
//   output  
//   Name: Ebiwayo
//   Graduated: false  
//   Phone: null
//   Email: ebiwa@google.com
  
}

// การใช้งาน named parameter ร่วมกับการกำหนด default parameter
void customer(String name, { bool graduated = false, String phone, String email}){
  var customerDetail = '''
  Name: $name
  Graduated: $graduated  
  Phone: $phone
  Email: $email
  ''';
  print(customerDetail);
}
    จะเห็นว่าเรากำหนดตัวแปร graduated เป็น boolean เพิ่มเข้ามาใน named parameter พร้อมทั้งกำหนดค่าเริ่มต้นเป็น false เมื่อเรียกใช้งาน
โดยไม่ได้ส่งค่า argument ที่ชื่อ graduated เข้ามาด้วย  ตัวฟังก์ชั่นจะใช้ค่าเริ่มต้น ที่เรากำหนด เป็น false แทน ซึ่งปกติ ถ้าไม่กำหนด เหมือนตัวแปร
phone จะเป็นค่า null ตามผลลัพธ์ในตัวเอย่างข้างต้น
 
    การแก้ปัญหากรณีไม่ต้องการให้ parameter เป็นค่า null เมื่อไม่ได้กำหนดไปใน optional parameter นอกจากวิธีการใช้ค่าเริ่มต้น แล้ว เรายัง
สามารถตรวจสอบค่า ภายในฟังก์ชั่น และกำหนดเป็นค่าอื่นตามต้องการได้ อย่างในตัวอย่างข้างต้น จะเห็นว่าตัวแปร phone เราไม่ได้กำหนดค่าเริ่มต้น
และไม่ได้ส่งค่าเข้ามาฟังก์ชั่น ดังนั้นค่าจึงเป็น null  สมมติว่าเรากำหนดค่าเริ่มต้น โดยกำหนดให้กับ phone และ email โดยมีค่าเป็น " - " ขีดละไว้
เพื่อบอกว่าไม่มีข้อมูล ก็สามารถกำหนดได้เป็นดังนี้
 
void customer(String name, { bool graduated = false, String phone = '-', String email = '-'}){}; // โค้ดบางส่วน
 
    และอีกวิธีก็คือกำหนดการตรวจสอบในฟังก์ชั่น ดังนี้
 
// การใช้งาน named parameter 
void customer(String name, { bool graduated, String phone, String email}){
  if (graduated == null) {
    graduated = false;
  }
  if (phone == null) {
    phone = "-";
  }
  if (email == null) {
    email = "-";
  }  
  // หรือเขียนแบบย่อเป็น
//   graduated = graduated ?? false;
//   phone = phone ?? "-";  
//   email = email ?? "-";     
  var customerDetail = '''
  Name: $name
  Graduated: $graduated  
  Phone: $phone
  Email: $email
  ''';
  print(customerDetail);
}
 
 
 

การใช้งาน Anonymous functions

    เราจะเห็นว่าฟังก์ชั่นส่วนใหญ่แล้ว จะมีการกำหนดชื่อให้กับฟังก์ชั่น เช่น main() หรือ customer()  นอกจากฟังก์ชั่นที่มีการกำหนดชื่อแล้ว
เรายังสามารถกำหนดฟังก์ชั่นโดยไม่มีการกำหนดชื่อได้ด้วย หรือที่เรียกว่า anonymous functions บางทีก็เรียก lambda หรือบ้างก็เรียก closure
    โดยรูปแบบของ anonymous functions จะคล้ายกับ named function ทั่วไป มีหรือไม่มี parameter ก็ได้ 

([[Type] param1[, …]]) {
  codeBlock;
};
 
    จะพบการใช้งานฟังก์ชั่น anonymous ร่วมกับตัวแปร List (ตัวแปร array) ตามตัวอย่างต่อไปนี้
 
void main () {
  var list = ['apples', 'bananas', 'oranges'];
  list.forEach((item) {
    print('${list.indexOf(item)}: $item');
  });  
// output
// 0: apples
// 1: bananas
// 2: oranges  
  // ส่วนของ anonymous function
//   (item) {
//     print('${list.indexOf(item)}: $item');
//   }  
}
 
    Anonymous ฟังก์ชั่นข้างต้นมี parameter ที่ชื่อ item ที่จะถูกคำสั่ง forEach วนลูปค่าจากตัวแปร List ที่เป็น array ส่งค่าเข้าไปในฟังก์ชั่น
จากนั้นก็ทำคำสั่งภายในฟังก์ชั่น คือแสดงข้อมูล พร้อมทั้ง key index ของสมาชิกในตัวแปร list
    หากคำสั่งทำงานในฟังก์ชั่น มีคำสั่งเดียว เราสามารถใช้รูปแบบ arrow syntax แบบย่อได้เป็นดังนี้

void main () {
  var list = ['apples', 'bananas', 'oranges'];
  list.forEach((item) => print('${list.indexOf(item)}: $item'));
  // (item) => print('${list.indexOf(item)}: $item')
}
    เนื้อหาเกี่ยวกับการใช้งานฟังก์ชั่นในภาษา Dart เบื้องต้น ก็จะประมาณนี้ หวังวาจะเป็นแนวทางในการทบทวนและทำความเข้าใจ
เพื่อนำไปประยุกต์ใช้ต่อไป


เพียงกด Like หรือ Share เป็นกำลังใจ ในการสร้างบทความใหม่ๆ น่ะครับ



อ่านต่อที่บทความ









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



Tags:: dart ฟังก์ชั่นในภาษา dart function in dart







URL สำหรับอ้างอิง











เว็บไซต์ของเราให้บริการเนื้อหาบทความสำหรับนักพัฒนา โดยพึ่งพารายได้เล็กน้อยจากการแสดงโฆษณา โปรดสนับสนุนเว็บไซต์ของเราด้วยการปิดการใช้งานตัวปิดกั้นโฆษณา (Disable Ads Blocker) ขอบคุณครับ