Named return parameters in Golang

In Golang , named return parameters are commonly known as named parameters. Golang allows naming the return parameters or results of functions in the function signature or definition. Or you can say it is the explicit naming of return variables in the function definition. It basically removes the need to mention the variable name with the return statement. By using named return parameters or named parameters, one can simply use the return keyword at the end of the function to return the result to the caller. This concept is commonly used when a function has to return multiple values. So, for the convenience of the users and to increase the readability of the code, Golang provides this facility.

Declare named return parameters

To declare a named result or return parameter, simply use the return type part of the function signature. Here is the general syntax for declaring a function in Golang. The syntax for declaring a function without a named return parameter is:

func function_name(Parameter-list)(Return_type){
    // function body.....
}

Here, Return_Type is optional and it contains the type of value that the function returns. If you are using Return_Type in your function, then you need to use the return statement in your function.
The syntax to declare a function with a named return argument is:

func function_name(Parameter-list)(result_parameter1 data-_type, result_parameter2 data_type, ….){ 
// function body…..
return 
} 

Here, (result_parameter1 data-_type, result_parameter2 data_type, ….) is the list of named return arguments along with their types. You can declare n number of named return parameters.

Example: Example: In the program below, the line func calculator(a, b int) (mul int, div int) contains named return arguments. The return statement at the end of the function does not contain any parameters. The Go compiler will automatically return the parameters.

// Chương trình Go mình họa 
// cách dùng đối số trả về được đặt tên

package main

import "fmt"

// Phương thức chính
func main() {

	// tại đây gọi hàm này
	// hàm trả về hai giá trị
	m, d := calculator(105, 7)

	fmt.Println("105 x 7 = ", m)
	fmt.Println("105 / 7 = ", d)
}

// hàm có các đối số được đặt tên
func calculator(a, b int) (mul int, div int) {

	// tại đây phép gán đơn giản sẽ
	// khởi tạo giá trị cho nó
	mul = a * b
	div = a / b

	// tại đây bạn sẽ có từ khóa return
	// không có bất kỳ tham số kết quả nào
	return
}

Result:

105 x 7 =  735
105 / 7 =  15

Important Note:

• If the types of all the return arguments are named in common or are the same, then you can specify a common data type. Compare the code below with the example you read above to understand better.

// hàm có đối số đã được đặt tên
func calculator(a, b int) (mul, div int) {

• Here, the variables mul and div are both of type int . So you can also declare named arguments with generic data types as function variables (i.e. a and b)
• Using named return parameters enhances code readability as one can know about the return parameters just by reading the function signature.
• After using a named return parameter, the return statement is often referred to as a Naked or Bare return .
• By default, Golang defines all named variables with a value of zero and functions will be able to use them. In case the function does not modify the values, a value of zero will be returned automatically.
• If you use the short declaration operator ( : = ) to initialize named return parameters, it will throw an error because it has already been initialized by the Go compiler. So you can use simple assignment ( = ) to assign values ​​to named return parameters.

// hàm có đối số được đặt tên
func calculator(a, b int) (mul int, div int) {

    // tại đây, nó sẽ báo lỗi
        // dưới dạng tham số đã được xác định
        // trong chữ ký hàm
    mul := a * b
    div := a / b

    // tại đây bạn có từ khóa return
    // không có bất kỳ tham số kết quả nào
    return
}

• Named return arguments or minimal return statements are only good for short function signatures. For longer functions, explicitly return the result parameters (don't use named return parameters) to maintain readability of the code.
• In case of named return arguments, a minimal or simple return statement is required.