{"id":216,"date":"2024-09-12T17:13:01","date_gmt":"2024-09-12T10:13:01","guid":{"rendered":"https:\/\/gotutorial.org\/?page_id=216"},"modified":"2024-09-27T09:46:43","modified_gmt":"2024-09-27T02:46:43","slug":"go-functions","status":"publish","type":"page","link":"https:\/\/www.gotutorial.org\/go-tutorial\/go-functions\/","title":{"rendered":"Go Functions"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you will learn how to define Go functions to modulize your code and make it more reusable.<\/p>\n\n\n\n

Functions are basic building blocks in Go. Functions allow you to encapsulate reusable logic, making your code more reusable.<\/p>\n\n\n\n

Defining a function<\/h2>\n\n\n\n

To define a function, you use the func<\/code> keyword, followed by the function name, parameters (optional), and the return type (if any):<\/p>\n\n\n

func<\/span> name<\/span>(parameters)<\/span> type<\/span><\/span> {\n   \/\/ body  <\/span>\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
For example, the following defines a function sayHi<\/code>:<\/p>\n\n\n
func<\/span> sayHi<\/span>()<\/span><\/span> {\n    fmt.Println(\"Hi\"<\/span>)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Calling a function<\/h2>\n\n\n\n
To call a function, you use the function name followed by the parentheses. For example, the following illustrates how to call the sayHi()<\/code> function inside the main()<\/code> function:<\/p>\n\n\n
package<\/span> main\n\nimport<\/span> \"fmt\"<\/span>\n\nfunc<\/span> sayHi<\/span>()<\/span><\/span> {\n    fmt.Println(\"Hi\"<\/span>)\n}\n\nfunc<\/span> main<\/span>()<\/span><\/span> {\n    sayHi()\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Hi<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Function parameters<\/h2>\n\n\n\n
Functions may accept one or more parameters, allowing you to pass values to them. To define parameters for a function, you specify them within the parentheses following the function name.<\/p>\n\n\n\n
For example, the following modifies the sayHi()<\/code> function that accepts a string parameter:<\/p>\n\n\n
func<\/span> sayHi<\/span>(name string<\/span>)<\/span><\/span> {\n    fmt.Println(\"Hi\"<\/span>, name)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
When calling the sayHi()<\/code> function, you need to pass a value to the name<\/code> parameter:<\/p>\n\n\n
package<\/span> main\n\nimport<\/span> \"fmt\"<\/span>\n\nfunc<\/span> sayHi<\/span>(name string<\/span>)<\/span><\/span> {\n    fmt.Println(\"Hi\"<\/span>, name)\n}\n\nfunc<\/span> main<\/span>()<\/span><\/span> {\n    sayHi(\"Joe\"<\/span>)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Hi Joe<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
The string \"Joe\"<\/code> is called an argument of the sayHi()<\/code> function.<\/p>\n\n\n\n
Parameters are defined in the function declaration while arguments are values you pass to the function.<\/p>\n\n\n\n
Return values<\/h2>\n\n\n\n
A function may return a value. In this case, you need to specify the function’s return type after the parameter list.<\/p>\n\n\n\n
For example, the following defines the sayHi()<\/code> function that returns a string:<\/p>\n\n\n
func<\/span> sayHi<\/span>(name string<\/span>)<\/span> string<\/span><\/span> {\n\treturn<\/span> \"Hi \"<\/span> + name\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Here’s the complete code:<\/p>\n\n\n
package<\/span> main\n\nimport<\/span> \"fmt\"<\/span>\n\nfunc<\/span> sayHi<\/span>(name string<\/span>)<\/span> string<\/span><\/span> {\n    return<\/span> \"Hi \"<\/span> + name\n}\n\nfunc<\/span> main<\/span>()<\/span><\/span> {\n    fmt.Println(sayHi(\"Joe\"<\/span>))\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Hi Joe<\/code><\/span><\/pre>\n\n\n
Named Return Value<\/h3>\n\n\n\n
Go allows you to assign a name to the return value. For example:<\/p>\n\n\n
func<\/span> sayHi<\/span>(name string<\/span>)<\/span> (message string<\/span>)<\/span><\/span> {\n\tmessage = \"Hi \"<\/span> + name\n\treturn<\/span>\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, we assign the message<\/code> as the name of the return value of the sayHi<\/code> function. Go treats the message<\/code> as a variable<\/a> defined at the top of the sayHi<\/code> function.<\/p>\n\n\n\n
Typically, you use the named return value to document the meaning of the return value.<\/p>\n\n\n\n
A return<\/code> statement that does not have any argument will return the named return value. It is known as a “naked” return:<\/p>\n\n\n
return<\/span><\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
In practice, you should use the naked return value in short functions only since it will make the code less readable.<\/p>\n\n\n\n
Variadic Functions<\/h2>\n\n\n\n
A function can accept a variable number of arguments using the ...<\/code> syntax. It means a function may accept one parameter, two parameters, and so on. This function is called a variadic function<\/strong>. For example:<\/p>\n\n\n
package<\/span> main\n\nimport<\/span> \"fmt\"<\/span>\n\nfunc<\/span> sayHi<\/span>(names ...string<\/span>)<\/span><\/span>  {\n\tfor<\/span> _, name := range<\/span> names {\n\t\tfmt.Println(\"Hi\"<\/span>,name )\n\t}\n}\n\nfunc<\/span> main<\/span>()<\/span><\/span> {\n\tsayHi(\"Joe\"<\/span>,\"Jane\"<\/span>, \"Bob\"<\/span>);\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Hi Joe\nHi Jane\nHi Bob<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Function Literal<\/h2>\n\n\n\n
In Go, you can define functions without names. These functions are called functional literals<\/em>. In other programming languages such as JavaScript, they are known as anonymous functions<\/em>.<\/p>\n\n\n\n
For example, the following shows how to define a function literal function and call it immediately:<\/p>\n\n\n
package<\/span> main\n\nimport<\/span> \"fmt\"<\/span>\n\n\nfunc<\/span> main<\/span>()<\/span><\/span> {\n    func<\/span>(names ...string<\/span>)<\/span><\/span>{\n        for<\/span> _, name := range<\/span> names {\n            fmt.Println(\"Hi\"<\/span>,name )\n        }\n    }(\"Joe\"<\/span>,\"Jane\"<\/span>, \"Bob\"<\/span>)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example:<\/p>\n\n\n\n
First, define the function literal that accepts zero or more string parameters:<\/p>\n\n\n
func<\/span>(names ...string<\/span>)<\/span><\/span>{\n   for<\/span> _, name := range<\/span> names {\n\tfmt.Println(\"Hi\"<\/span>,name )\n   }\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Second, immediately call the functional literal and pass three string arguments:<\/p>\n\n\n
func<\/span>(names ...string<\/span>)<\/span><\/span>{\n   for<\/span> _, name := range<\/span> names {\n\tfmt.Println(\"Hi\"<\/span>,name )\n   }\n}(\"Joe\"<\/span>,\"Jane\"<\/span>, \"Bob\"<\/span>)<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
In practice, you often use function literals as inline functions.<\/p>\n\n\n\n
Summary<\/h3>\n\n\n\n
    \n
  • Use functions to encapsulate reusable logic.<\/li>\n\n\n\n
  • Use the func<\/code> keyword to define a function.<\/li>\n\n\n\n
  • A function can accept parameters and return values.<\/li>\n\n\n\n
  • A variadic function can accept a variable number of arguments.<\/li>\n\n\n\n
  • A functional literal is a function without a name.<\/li>\n<\/ul>\n
    \n\t
    Was this tutorial helpful?<\/div>\n\t
    \n\t\t\n\t\t\t\n\t\t\t\t<\/path>\n\t\t\t<\/svg>\n\t\t\t Yes <\/span>\n\t\t<\/button>\n\n\t\t\n\t\t\t\n\t\t\t\t<\/path>\n\t\t\t<\/svg>\n\t\t\t No <\/span>\n\t\t<\/button>\n\t<\/div>\n\n\t
    \n\t\t
    \n\t\t\t
    <\/div>\n\t\t\t
In this example, the sayHi function has a variable number of string parameters<\/em>. Inside the function, we iterate over each parameter using a for range loop<\/a> and display the corresponding greeting message.<\/p>\n\n\n\n