ไป - ฟังก์ชั่น

ฟังก์ชันคือกลุ่มของคำสั่งที่ทำงานร่วมกัน โปรแกรม Go ทุกโปรแกรมมีฟังก์ชันอย่างน้อยหนึ่งฟังก์ชันซึ่งก็คือmain(). คุณสามารถแบ่งรหัสของคุณออกเป็นฟังก์ชันแยกกันได้ การแบ่งรหัสของคุณระหว่างฟังก์ชันต่างๆนั้นขึ้นอยู่กับคุณ แต่เหตุผลแล้วการแบ่งควรเป็นเช่นนั้นเพื่อให้แต่ละฟังก์ชันทำงานเฉพาะ

ฟังก์ชั่น declarationบอกคอมไพเลอร์เกี่ยวกับชื่อฟังก์ชันชนิดการส่งคืนและพารามิเตอร์ ฟังก์ชั่นdefinition ให้ตัวจริงของฟังก์ชั่น

ไลบรารีมาตรฐาน Go มีฟังก์ชันในตัวมากมายที่โปรแกรมของคุณสามารถเรียกใช้ได้ ตัวอย่างเช่นฟังก์ชันlen()รับอาร์กิวเมนต์ประเภทต่างๆและส่งกลับความยาวของประเภท ถ้าสตริงถูกส่งผ่านไปฟังก์ชันจะส่งกลับความยาวของสตริงเป็นไบต์ ถ้าอาร์เรย์ถูกส่งผ่านไปฟังก์ชันจะส่งกลับความยาวของอาร์เรย์

ฟังก์ชั่นเรียกอีกอย่างว่า method, sub-routine, หรือ procedure.

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

รูปแบบทั่วไปของนิยามฟังก์ชันในภาษาโปรแกรม Go มีดังนี้ -

func function_name( [parameter list] ) [return_types]
{
   body of the function
}

ฟังก์ชั่นความหมายไปในการเขียนโปรแกรมภาษาประกอบด้วยส่วนหัวของฟังก์ชั่นและการทำงานของร่างกาย นี่คือส่วนทั้งหมดของฟังก์ชัน -

• Func - เริ่มการประกาศฟังก์ชัน

• Function Name- เป็นชื่อจริงของฟังก์ชัน ชื่อฟังก์ชันและรายการพารามิเตอร์ประกอบกันเป็นลายเซ็นฟังก์ชัน

• Parameters- พารามิเตอร์เปรียบเสมือนตัวยึด เมื่อเรียกใช้ฟังก์ชันคุณจะส่งค่าไปยังพารามิเตอร์ ค่านี้เรียกว่าพารามิเตอร์หรืออาร์กิวเมนต์จริง รายการพารามิเตอร์หมายถึงประเภทลำดับและจำนวนพารามิเตอร์ของฟังก์ชัน พารามิเตอร์เป็นทางเลือก นั่นคือฟังก์ชันอาจไม่มีพารามิเตอร์

• Return Type- ฟังก์ชันอาจส่งคืนรายการค่า return_types คือรายการชนิดข้อมูลของค่าที่ฟังก์ชันส่งกลับ บางฟังก์ชันดำเนินการตามที่ต้องการโดยไม่ส่งคืนค่า ในกรณีนี้ return_type เป็นสิ่งที่ไม่จำเป็น

• Function Body - ประกอบด้วยชุดคำสั่งที่กำหนดสิ่งที่ฟังก์ชันทำ

ตัวอย่าง

ซอร์สโค้ดต่อไปนี้แสดงฟังก์ชันที่เรียกว่า max(). ฟังก์ชันนี้รับสองพารามิเตอร์ num1 และ num2 และส่งกลับค่าสูงสุดระหว่างสอง -

/* function returning the max between two numbers */
func max(num1, num2 int) int {
   /* local variable declaration */
   result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result 
}

เรียกใช้ฟังก์ชัน

ในขณะที่สร้างฟังก์ชัน Go คุณให้คำจำกัดความว่าฟังก์ชันนี้มีไว้ทำอะไร ในการใช้ฟังก์ชันคุณจะต้องเรียกใช้ฟังก์ชันนั้นเพื่อทำงานที่กำหนดไว้

เมื่อโปรแกรมเรียกใช้ฟังก์ชันตัวควบคุมโปรแกรมจะถูกโอนไปยังฟังก์ชันที่เรียก ฟังก์ชันที่เรียกว่าทำงานตามที่กำหนดไว้และเมื่อคำสั่ง return ถูกเรียกใช้งานหรือเมื่อถึงวงเล็บปีกกาปิดฟังก์ชันสิ้นสุดฟังก์ชันจะส่งคืนการควบคุมโปรแกรมกลับไปที่โปรแกรมหลัก

ในการเรียกใช้ฟังก์ชันคุณเพียงแค่ส่งพารามิเตอร์ที่ต้องการพร้อมกับชื่อฟังก์ชัน หากฟังก์ชันส่งคืนค่าคุณสามารถจัดเก็บค่าที่ส่งคืนได้ ตัวอย่างเช่น -

package main

import "fmt"

func main() {
   /* local variable definition */
   var a int = 100
   var b int = 200
   var ret int

   /* calling a function to get max value */
   ret = max(a, b)

   fmt.Printf( "Max value is : %d\n", ret )
}

/* function returning the max between two numbers */
func max(num1, num2 int) int {
   /* local variable declaration */
   var result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result 
}

เราได้เก็บฟังก์ชัน max () ไว้พร้อมกับฟังก์ชัน main () และรวบรวมซอร์สโค้ด ในขณะที่รันไฟล์ปฏิบัติการขั้นสุดท้ายจะให้ผลลัพธ์ดังนี้ -

Max value is : 200

การคืนค่าหลายค่าจากฟังก์ชัน

ฟังก์ชัน Go สามารถคืนค่าได้หลายค่า ตัวอย่างเช่น -

package main

import "fmt"

func swap(x, y string) (string, string) {
   return y, x
}
func main() {
   a, b := swap("Mahesh", "Kumar")
   fmt.Println(a, b)
}

เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Kumar Mahesh

อาร์กิวเมนต์ของฟังก์ชัน

ถ้าฟังก์ชันจะใช้อาร์กิวเมนต์ฟังก์ชันจะต้องประกาศตัวแปรที่ยอมรับค่าของอาร์กิวเมนต์ ตัวแปรเหล่านี้เรียกว่าformal parameters ของฟังก์ชัน

พารามิเตอร์ที่เป็นทางการจะทำงานเหมือนกับตัวแปรท้องถิ่นอื่น ๆ ภายในฟังก์ชันและถูกสร้างขึ้นเมื่อเข้าสู่ฟังก์ชันและถูกทำลายเมื่อออก

ในขณะที่เรียกใช้ฟังก์ชันมีสองวิธีที่สามารถส่งผ่านอาร์กิวเมนต์ไปยังฟังก์ชัน -

ซีเนียร์ No	ประเภทการโทรและคำอธิบาย
1	โทรตามค่า วิธีนี้คัดลอกค่าที่แท้จริงของอาร์กิวเมนต์ลงในพารามิเตอร์ที่เป็นทางการของฟังก์ชัน ในกรณีนี้การเปลี่ยนแปลงที่เกิดขึ้นกับพารามิเตอร์ภายในฟังก์ชันจะไม่มีผลกับอาร์กิวเมนต์
2	โทรตามข้อมูลอ้างอิง วิธีนี้คัดลอกที่อยู่ของอาร์กิวเมนต์ลงในพารามิเตอร์ที่เป็นทางการ ภายในฟังก์ชันจะใช้แอดเดรสเพื่อเข้าถึงอาร์กิวเมนต์จริงที่ใช้ในการโทร ซึ่งหมายความว่าการเปลี่ยนแปลงที่เกิดขึ้นกับพารามิเตอร์มีผลต่ออาร์กิวเมนต์

ตามค่าเริ่มต้น Go ใช้การโทรตามค่าเพื่อส่งผ่านอาร์กิวเมนต์ โดยทั่วไปหมายความว่าโค้ดภายในฟังก์ชันไม่สามารถเปลี่ยนแปลงอาร์กิวเมนต์ที่ใช้เรียกฟังก์ชันได้ โปรแกรมข้างต้นในขณะที่เรียกใช้ฟังก์ชัน max () ใช้วิธีการเดียวกัน

การใช้งานฟังก์ชัน

สามารถใช้ฟังก์ชันได้หลายวิธีดังต่อไปนี้:

ซีเนียร์ No	การใช้งานฟังก์ชั่นและคำอธิบาย
1	ฟังก์ชั่นเป็นค่า สามารถสร้างฟังก์ชันได้ทันทีและใช้เป็นค่าต่างๆได้
2	การปิดฟังก์ชัน การปิดฟังก์ชันเป็นฟังก์ชันที่ไม่ระบุชื่อและสามารถใช้ในการเขียนโปรแกรมแบบไดนามิกได้
3	วิธี วิธีการเป็นฟังก์ชั่นพิเศษกับเครื่องรับ