Bummer! This is just a preview. You need to be signed in with a Basic account to view the entire video.

Preview

Start a free Basic trial
to watch this video

Sign up for Treehouse

Functions

6:43 with Jay McGavren

Declaring a function consists of providing a function name, names and types of any parameters, and one or more return values.

  • Declaring a function
    • func keyword
    • Function name
    • Parentheses
    • Code block in curly braces that gets run when function is called
package main

import "fmt"

func main() {
  myFunction()
}

func myFunction() {
  fmt.Println("Running myFunction")
}

  • Naming rules

    • Same naming rules as variables, types, etc.
    • Must start with letter
    • Capital letter means exported from the current package, lower case means unexported
    • Convention is to use camelCase for multiple words

  • Can declare parameters:

package main

import "fmt"

func main() {
    square(3)
    add(2, 4)
    subtract(10, 3)
}

func square(number int) {
    fmt.Println(number * number)
}

func add(a float64, b float64) {
    fmt.Println(a + b)
}

func subtract(a, b float64) {
    fmt.Println(a - b)
}

  • Parameters are type enforced. square("hello") fails at compile time.

  • Return values

    • Must specify return value type.
    • Can name return values - sometimes useful as documentation.
    • Can use bare returns if return values are named.
package main

import "fmt"

func main() {
    fmt.Println(square(3))
    fmt.Println(add(2, 4))
    fmt.Println(subtract(10, 3))
}

func square(number int) int {
    return number * number
}

func add(a float64, b float64) (sum float64) {
    return a + b
}

func subtract(a, b float64) (difference float64) {
    difference = a - b
    return
}
  • Compile error if last statement of function is not a return, because that line of code will never be reached.
  • 0:00

    Go makes it easy to declare your own functions.

  • 0:03

    You do so using the func key word followed by the name you want the function to have.

  • 0:09

    So we'll name this function myFunction.

  • 0:13

    Then you include a pair of parenthesis

  • 0:16

    followed by a code block in curly braces that gets run when the function is called.

  • 0:21

    So on this function, myFunction, we'll just make a call to the print

  • 0:27

    line function and we'll pass up the string Running myFunction.

  • 0:36

    Once you've declared a function you can call it by typing the function name,

  • 0:41

    myFunction, followed by a pair of parentheses again.

  • 0:44

    So, save this and run it down here in the console.

  • 0:48

    The main function gets called when the program is run and then it makes a call

  • 0:53

    to myFunction, which then prints out the string Running myFunction.

  • 0:57

    You can see that down here on the output.

  • 1:00

    The rules for naming functions are the same as they are for variables.

  • 1:03

    A function name has to start with a letter.

  • 1:06

    A capital letter means the function is exported from the current package, whereas

  • 1:09

    lowercase means it's unexported, that is, not visible outside the current package.

  • 1:14

    And again, there's a convention that if a function name has multiple words,

  • 1:18

    then all words after the first should begin with a capital letter.

  • 1:22

    If we try to refer to function names from outside the package,

  • 1:25

    we're only allowed to refer to functions that have been exported, that is,

  • 1:28

    those whose names begin with a capital letter.

  • 1:31

    If we try to refer to a non-exported function name,

  • 1:34

    we'll get a compile error saying cannot refer to unexported name.

  • 1:39

    If you want your functions to accept parameters,

  • 1:42

    you can declare those within the parentheses when declaring the function.

  • 1:46

    A parameter is just like any other variable, you need to give it a name and

  • 1:49

    you need to declare a type for it.

  • 1:52

    If you need a function to accept multiple parameters,

  • 1:54

    you can separate those with commas.

  • 1:57

    If you have multiple parameters of the same type,

  • 1:59

    you can just list the type after the last parameter.

  • 2:03

    So up here we make calls to the functions we've declared and

  • 2:06

    pass arguments into each of those parameters.

  • 2:09

    Let's try running this real quick.

  • 2:11

    So here we call the square function which

  • 2:14

    multiplies the number by itself then prints the value out.

  • 2:18

    So 3 times 3 is 9.

  • 2:20

    Here we call the add function and we pass it arguments of 2 and 4,

  • 2:25

    which it adds together and prints the result out.

  • 2:27

    So 2 plus 4 is 6.

  • 2:28

    And here we call subtract.

  • 2:30

    We pass up the arguments 10 and 3, it subtracts 3 from 10,

  • 2:34

    gives us the result, 7.

  • 2:36

    And since we declare the types of all the parameters,

  • 2:38

    that allows Go to enforce the use of the correct arguments.

  • 2:42

    So for example, if we were to try to pass a string to the square function and

  • 2:46

    then try to run this, we'll get an error.

  • 2:48

    Cannot use type string as type int as an argument to the square function.

  • 2:53

    There's certain features for

  • 2:54

    method declarations that you may be used to in other languages, but

  • 2:58

    the Go omits in order to keep method call simple, clear, and fast.

  • 3:03

    Go doesn't allow default values for parameters,

  • 3:06

    it doesn't allow you to name parameters, and it doesn't allow method overloading.

  • 3:10

    That means declaring multiple methods with the same name but different parameters.

  • 3:15

    That means that when you call a method you're always going to

  • 3:18

    use the same number of arguments in the same place.

  • 3:22

    The goal is to make calling methods simple, clear, and fast.

  • 3:26

    And of course, as in most other programming languages,

  • 3:29

    functions can return values.

  • 3:32

    So let's suppose that we wanted to update all these functions to

  • 3:35

    return a value instead of simply printing a value out.

  • 3:38

    We'll set up our square function to return an int,

  • 3:42

    by specifying the int type here following the parentheses.

  • 3:46

    And then instead of taking the number times itself and

  • 3:49

    printing that, we're going to return that value using the return keyword.

  • 3:57

    You can set up a variable to hold the return value,

  • 4:00

    which is also known as naming the return value.

  • 4:02

    Sometimes that's useful as documentation.

  • 4:05

    So if we want to do that, we place parentheses here

  • 4:08

    after the parentheses that accept the parameters for the function.

  • 4:13

    And we provide a name for the return value.

  • 4:16

    So we'll call this one sum, and of course its type is going to be a float64,

  • 4:21

    since we're adding two float64 numbers together.

  • 4:26

    And then as before instead of printing the value out, we'll just return it.

  • 4:31

    If you've named a return value, then you can use what's called a bare return.

  • 4:36

    So let's name the return value for the subtract function to be difference,

  • 4:41

    and it's going to have a type of float64.

  • 4:47

    That sets up a variable that we can assign to and

  • 4:49

    then that value will be used as our return.

  • 4:52

    So we can say difference = a minus b.

  • 5:00

    And then, that allows us use to use a bare return here at the end of the function.

  • 5:04

    So we can just use the return key word all by itself.

  • 5:08

    And that will, since we've set difference up as a named return value

  • 5:12

    that's the value that will be returned.

  • 5:14

    So let's save this.

  • 5:16

    And up here in the main function now that we're returning values instead,

  • 5:21

    we'll need to print them out up here.

  • 5:22

    So we'll say format.printline.

  • 5:27

    We'll print the return value of square.

  • 5:30

    We'd better change that back to an acceptable argument type.

  • 5:34

    So we'll say square(3).

  • 5:37

    And then fmt.Println(add(2, 4)).

  • 5:42

    And fmt.Println(subtract(10, 3)).

  • 5:45

    Subtract 3 from 10.

  • 5:47

    Save that, run it, and there are our results.

  • 5:52

    The square of 3 and 3 is 9.

  • 5:54

    The result of the adding 2 and 4 is 6.

  • 5:57

    And the result of subtracting 3 from 10 is 7.

  • 6:01

    The values were returned from each of the function calls

  • 6:04

    up here in the main function and we printed each one of them.

  • 6:08

    If you were to add a statement after the return statement within a function,

  • 6:12

    that line of code would never be breached.

  • 6:14

    Go protects you from this sort of situation by giving you a compile error.

  • 6:18

    So let's suppose that we were to add a call to fmt.Println(

  • 6:23

    down here after the return statement within the square function.

  • 6:31

    Let's try running that, and you see we get a compile error.

  • 6:34

    Missing return at end of function.

  • 6:36

    So if a function is supposed to return a value,

  • 6:38

    you need to ensure that the last line of that function is a return statement.

You need to sign up for Treehouse in order to download course files.

Sign up