Functions

Go makes it easy to declare your own functions. 0:00 You do so using the func key word followed by the name you want the function to have. 0:03 So we'll name this function myFunction. 0:09 Then you include a pair of parenthesis 0:13 followed by a code block in curly braces that gets run when the function is called. 0:16 So on this function, myFunction, we'll just make a call to the print 0:21 line function and we'll pass up the string Running myFunction. 0:27 Once you've declared a function you can call it by typing the function name, 0:36 myFunction, followed by a pair of parentheses again. 0:41 So, save this and run it down here in the console. 0:44 The main function gets called when the program is run and then it makes a call 0:48 to myFunction, which then prints out the string Running myFunction. 0:53 You can see that down here on the output. 0:57 The rules for naming functions are the same as they are for variables. 1:00 A function name has to start with a letter. 1:03 A capital letter means the function is exported from the current package, whereas 1:06 lowercase means it's unexported, that is, not visible outside the current package. 1:09 And again, there's a convention that if a function name has multiple words, 1:14 then all words after the first should begin with a capital letter. 1:18 If we try to refer to function names from outside the package, 1:22 we're only allowed to refer to functions that have been exported, that is, 1:25 those whose names begin with a capital letter. 1:28 If we try to refer to a non-exported function name, 1:31 we'll get a compile error saying cannot refer to unexported name. 1:34 If you want your functions to accept parameters, 1:39 you can declare those within the parentheses when declaring the function. 1:42 A parameter is just like any other variable, you need to give it a name and 1:46 you need to declare a type for it. 1:49 If you need a function to accept multiple parameters, 1:52 you can separate those with commas. 1:54 If you have multiple parameters of the same type, 1:57 you can just list the type after the last parameter. 1:59 So up here we make calls to the functions we've declared and 2:03 pass arguments into each of those parameters. 2:06 Let's try running this real quick. 2:09 So here we call the square function which 2:11 multiplies the number by itself then prints the value out. 2:14 So 3 times 3 is 9. 2:18 Here we call the add function and we pass it arguments of 2 and 4, 2:20 which it adds together and prints the result out. 2:25 So 2 plus 4 is 6. 2:27 And here we call subtract. 2:28 We pass up the arguments 10 and 3, it subtracts 3 from 10, 2:30 gives us the result, 7. 2:34 And since we declare the types of all the parameters, 2:36 that allows Go to enforce the use of the correct arguments. 2:38 So for example, if we were to try to pass a string to the square function and 2:42 then try to run this, we'll get an error. 2:46 Cannot use type string as type int as an argument to the square function. 2:48 There's certain features for 2:53 method declarations that you may be used to in other languages, but 2:54 the Go omits in order to keep method call simple, clear, and fast. 2:58 Go doesn't allow default values for parameters, 3:03 it doesn't allow you to name parameters, and it doesn't allow method overloading. 3:06 That means declaring multiple methods with the same name but different parameters. 3:10 That means that when you call a method you're always going to 3:15 use the same number of arguments in the same place. 3:18 The goal is to make calling methods simple, clear, and fast. 3:22 And of course, as in most other programming languages, 3:26 functions can return values. 3:29 So let's suppose that we wanted to update all these functions to 3:32 return a value instead of simply printing a value out. 3:35 We'll set up our square function to return an int, 3:38 by specifying the int type here following the parentheses. 3:42 And then instead of taking the number times itself and 3:46 printing that, we're going to return that value using the return keyword. 3:49 You can set up a variable to hold the return value, 3:57 which is also known as naming the return value. 4:00 Sometimes that's useful as documentation. 4:02 So if we want to do that, we place parentheses here 4:05 after the parentheses that accept the parameters for the function. 4:08 And we provide a name for the return value. 4:13 So we'll call this one sum, and of course its type is going to be a float64, 4:16 since we're adding two float64 numbers together. 4:21 And then as before instead of printing the value out, we'll just return it. 4:26 If you've named a return value, then you can use what's called a bare return. 4:31 So let's name the return value for the subtract function to be difference, 4:36 and it's going to have a type of float64. 4:41 That sets up a variable that we can assign to and 4:47 then that value will be used as our return. 4:49 So we can say difference = a minus b. 4:52 And then, that allows us use to use a bare return here at the end of the function. 5:00 So we can just use the return key word all by itself. 5:04 And that will, since we've set difference up as a named return value 5:08 that's the value that will be returned. 5:12 So let's save this. 5:14 And up here in the main function now that we're returning values instead, 5:16 we'll need to print them out up here. 5:21 So we'll say format.printline. 5:22 We'll print the return value of square. 5:27 We'd better change that back to an acceptable argument type. 5:30 So we'll say square(3). 5:34 And then fmt.Println(add(2, 4)). 5:37 And fmt.Println(subtract(10, 3)). 5:42 Subtract 3 from 10. 5:45 Save that, run it, and there are our results. 5:47 The square of 3 and 3 is 9. 5:52 The result of the adding 2 and 4 is 6. 5:54 And the result of subtracting 3 from 10 is 7. 5:57 The values were returned from each of the function calls 6:01 up here in the main function and we printed each one of them. 6:04 If you were to add a statement after the return statement within a function, 6:08 that line of code would never be breached. 6:12 Go protects you from this sort of situation by giving you a compile error. 6:14 So let's suppose that we were to add a call to fmt.Println( 6:18 down here after the return statement within the square function. 6:23 Let's try running that, and you see we get a compile error. 6:31 Missing return at end of function. 6:34 So if a function is supposed to return a value, 6:36 you need to ensure that the last line of that function is a return statement. 6:38