1.7 تابع (function)

1.7.1 تابع چیست؟ #

در برنامه‌نویسی، تابع به تکه کدهایی سازمان یافته گفته می شود که برای انجام عملی خاص استفاده می شوند. به کمک توابع می توانیم تکه کدهارو از یکدیگر جدا کنیم و از تکرار کدهای تکراری جلوگیری کنیم و به برنامه مون نظم بیشتری بدیم.

همانند شکل زیر تابع مانند یک جعبه (یا قطعه کد) می باشد. که یک مقدار ورودی گرفته و روی آن پردازش هایی انجام می دهد و یک خروجی تولید می کند. در برنامه نویسی تابع می تواند یک یا چند ورودی و خروجی داشته باشد. و ممکن است یک تابع هیچ ورودی نداشته باشد و خروجی داشته باشد یا بلعکس.

1.7.1.1 چرا از توابع در برنامه نویسی استفاده می کنیم؟ #

• با استفاده از توابع، می توانیم یک قطعه کد را یک بار بنویسیم و چندین بار از آن در برنامه استفاده کنیم.
• با استفاده از توابع، حجم کدنویسی ما کم تر میشه و سرعت توسعه نرم افزار بیشتر می شود.
• توابع به ما کمک می کنند تا کد خود را به تکه هایی کوچک تر تقسیم کنیم تا برنامه ما خوانا و قابل درک تر باشد. همچنین نگهداری و اشکال زدایی کد را آسان تر می کند.

1.7.2 توابع در زبان گولنگ #

توابع یکی از قابلیت های مهم هر زبانی محسوب می شوند. توابع در زبان برنامه نویسی گولنگ داری سینتکس ساده ای هستند.

1.7.2.1 تعریف یک تابع #

1func function_name( [parameter list] ) [return_types] {
2
3   // body of the function
4
5}

1. func - با این کلید واژه یک تابع تعریف می کنیم
2. Function Name - نام تابع باید یکتا و در طول برنامه منحصر به فرد باشد. همچنین معمولاً نمی‌توان تابعی با نام توابع از پیش تعریف شده داشت.
3. Parameters - پارامترهای ورودی در این قسمت تعریف می‌شوند. پارامترها اختیاری هستند یعنی ممکن است یک تابع هیچ پارامتری نداشته باشد.
4. Return Type - نوع داده های بازگشتی را در این قسمت مشخص می کنیم و در برخی توابع عملیات موردنظر را بدون بازگرداندن مقداری انجام می دهند در این توابع نیازی به تعیین return_type نمی باشد.
5. Function Body - این قسمت شامل کدهایی است که نشان می دهد تابع چه کارهایی انجام می دهد

1.7.2.1.1 مثال #

 1package main
 2
 3import "fmt"
 4
 5func plus(a int, b int) int {
 6	return a + b
 7}
 8
 9func main() {
10	fmt.Println(plus(4, 13))
11}

1$ go run func.go
217

1. در اینجا یک تابع با نام plus تعریف کردیم که دو پارامتر a, b را با نوع داده int دریافت می کند و جمع این دو عدد را حساب می کند. توجه کنید که همیشه باید نوع داده را مشخص کنیم.
2. بعد از تعریف پارامترهای ورودی و قبل از قرار دادن کد داخل براکت int را می بینید که نوع خروجی داده را مشخص می کند, یعنی خروجی این تابع باید از نوع int باشد.
3. برای صدا زدن توابع کافی است نام تابع رو همراه با پرانتز باز و بسته تایپ کنید, برای مثال ()plus.

در صورتی که نوع پارامترهای ورودی از یک نوع باشند بجای تعریف تک تک نوع داده ها می توانیم نوع داده را در آخر همه پارامترهای هم نوع مشخص کنیم.

1func plus(a, b int)
2// or
3func name(a string, b,c int)

1.7.2.1.2 الگو دیگر تعریف تابع: #

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6	plus := func (a int, b int) int {
 7		return a + b
 8	}
 9	fmt.Println(plus(3, 4))
10}

1$ go run main.go
27

1.7.3 قوانین نام گذاری تابع در گولنگ #

• نام تابع باید با یک حرف شروع شود.
• نام تابع فقط می تواند شامل حروف-عدد و underscores باشد.  (A-z, 0-9,  _ )
• نام تابع به حروف کوچک و بزرگ حساس می باشد.
• در نام گذاری تابع از فاصله نمی توانیم استفاده کنیم.

‬1.7.4 توابع چند بازگشتی در گولنگ (Multiple results) #

همچنین در گولنگ توابع می توانند چندین مقادیر را برگردانند.

 1package main
 2
 3import "fmt"
 4
 5func vals() (int, int) {
 6    return 3, 7
 7}
 8
 9func main() {
10
11    a, b := vals()
12    fmt.Println(a)
13    fmt.Println(b)
14
15    _, c := vals()
16    fmt.Println(c)
17}

1$ go run main.go
23
37
47

1. در کد بالا تابعی ساختیم با اسم vals که دو خروجی از نوع int دارد بنابراین نوع تعریف توابع چندبازگشتی متفاوت است و بصورت (data-type, data-type, … ) می باشد.
2. در مثال اول ما با کمک دو متغیر a,b دو خروجی تابع vals را دریافت کردیم.
3. در مثال دوم ما با استفاده از _ blank identifier از دریافت یا استخراج خروجی اول صرف نظر کردیم و فقط خروجی دوم با متغیر c را دریافت کردیم.

در توابع چند بازگشتی خروجی آنها را باید با , از هم جدا کرد

1.7.4.1 مقادیر بازگشتی نام گذاری شده (Named Return Values) #

در گولنگ می توانیم مقدار بازگشتی یک تابع را نامگذاری کنیم. به مثال زیر توجه کنید.

 1package main
 2
 3import "fmt"
 4
 5func split(sum int) (x, y int) {
 6	x = sum * 4 / 9
 7	y = sum - x
 8	return
 9}
10
11func main() {
12	fmt.Println(split(17))
13}

1$ go run main.go
27 10

1. ما در این تابع مقدار بازگشتی را x, y از نوع int نام گذاری می کنیم.
2. در اینجا یک دستور return بدون تعیین آرگومان بازگشتی، مقادیر نام گذاری شده را باز می گرداند. که به عنوان Naked return شناخته می شود.
3. از naked return باید در توابع کوتاه مانند مثال بالا استفاده شود. استفاده آن در تابع طولانی منجر به کاهش خوانایی کد می شود.

1.7.5 توابع متنوع در گولنگ (Variadic Functions) #

یکی از قابلیت های گو وجود توابع متنوع است. منظور از توابع متنوع توابعی هستند که بدون محدودیت پارامتر دریافت میکنند (این نکته رو در نظر بگیرین که نباید نوع یا همون تایپ ورودی ها با هم دیگه فرق کنه, برای مثال همشون باید int باشن). ‍‍

 1package main
 2
 3import "fmt"
 4
 5func sum(nums ...int) {
 6    fmt.Print(nums, " ")
 7    total := 0
 8
 9    for _, num := range nums {
10        total += num
11    }
12    fmt.Println(total)
13}
14
15func main() {
16
17    sum(1, 2)
18    sum(1, 2, 3)
19
20    nums := []int{1, 2, 3, 4}
21    sum(nums...)
22}

1$ go run variadic-functions.go 
2[1 2] 3
3[1 2 3] 6
4[1 2 3 4] 10

1. در اینجا تابعی تعریف کردیم که تعداد دلخواهی از آرگومان ها از نوع int را به کمک … (بهش میگن Ellipsis) که قبل از نوع داده قرار گرفته به داخل تابع منتقل می کند.
2. برای صدا زدن این توابع میتوان به روش sum(num1, num2, …) عمل کرد.
3. اگر شما داده ای با نوع slice دارید می توانید آن را به کمک اپراتور …(Ellipsis) به صورت sum(nums…) به داخل تابع انتقال بدید.

1.7.6 توابع نانشناس در گولنگ (Anonymous Functions) #

در زبان گولنگ می توانیم تابع بدون نام تعریف کنیم. که به عنوان توابع ناشناس شناخته می شوند.

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6
 7  // anonymous function
 8  var sum = func(n1, n2 int) int {
 9    sum := n1 + n2
10  
11    return sum
12  } 
13
14  // function call
15  result := sum(5, 3)
16
17  fmt.Println("Sum is:", result)
18
19}

1$ go run main.go
2Sum is: 8

1. از آنجایی که توابع ناشناس نامی ندارد ما در بعضی اوقات آن ها را به یک متغیر اختصاص می دهیم سپس از نام متغیر برای فراخوانی تابع استفاده می کنیم. در این مثال می بینید که ما از sum برای فراخوانی تابع استفاده می کنیم.
2. مانند توابع معمولی ما میتونیم برای تابع ناشناس پارامتر تعریف کنیم و همچنین مقداری را از تابع برگردانیم در این مثال تابع دو مقدار با نوع داده int دریافت میکنید و یک خروجی با نوع int دارد.
3. تابع ناشناس را می توان برای عملکردهایی که نیازی به نامگذاری ندارند و معمولا برای استفاده کوتاه مدت هست، استفاده کرد.

اما یکی از موارد کاربردی توابع ناشناس در گولنگ پاس دادن آن ها به توابعی هستند که تابعی را تحت عنوان پارامتر ورودی دریافت میکنند. در مثال زیر ما یک تابع تعریف کردیم که در پارامتر سوم یک تابع دریافت میکند که باید دو ورودی int و یک خروجی int داشته باشد.

 1package main  
 2  
 3import "fmt"  
 4  
 5func add10AndSum(num1 int, num2 int, sum func(n1, n2 int) int) {  
 6   result := sum(num1+10, num2+10)  
 7   fmt.Println("Sum by adding 10 is:", result)  
 8}  
 9  
10func main() {  
11   add10AndSum(5, 3, func(n1, n2 int) int {  
12      sum := n1 + n2  
13  
14      return sum  
15   })  
16}

1$ go run main.go
2Sum by adding 10 is: 28

1.7.7 توابع از پیش تعریف شده (Built-in Function) #

در گولنگ علاوه بر تابع هایی که توسط کابر تعریف میشه. یکسری توابع وجود دارد که از قبل تعریف شده اند که طراحان این زبان برای سهولت کار برنامه نویسان این توابع را نوشته اند و آن را همراه زبان گولنگ ارائه می دهند.

https://book.gofarsi.ir/chapter-1/go-builtins/