Defining Simple Variables
=========================

If you're familiar with C-style variable declarations (in languages like C,
C++, and Java_), Go's declaration syntax takes a little getting used to. But
it is quite straightforward and readable once you get the hang of it.


Basic Declarations Using var
----------------------------

One way to declare variables in Go_ is to use ``var``. For example::

    var n int     // n is an int initialized to 0
    var s string  // s is a string initialized to ""

Since we haven't given an initial value to either variable, Go_ automatically
assigns them the **zero-value** associated with that type. So ``n`` is
initialized to 0, and ``s`` is initialized to ``""``.

You can also provide your own initial value like this::

    var n int = 5          // declare n to be an int with initial value 5
    var s string = "apple" // declare s to be a string with initial value "apple"

    var a, b int           // declare a and b to be ints with initial value 0

    var a, b int = 2, 3    // declare a to be an int with initial value 2
                           // declare b to be an int with initial value 3

Multiple variable declarations can be grouped together like this::

    var (
        n int
        s string = "apple"
        a, b int = 2, 3
    )


Declarations Using var Without a Type
-------------------------------------

Go_ also lets you declare variables without explicitly declaring a type. For
example::

    var n = 3  // 3 is an int, so n is inferred to be of type int

    var m = n  // m is inferred to be of type int because n is an int

An even shorter form of variable declaration is to use the ``:=`` operator,
e.g.::

    n := 3        // declare n and initialize it to 3

    s := "apple"  // declare s and initialize it to "apple"

The ``:=`` is used quite often in practice since it is quick to type and easy
to read.

A restriction on variable declarations using ``:=`` is that they may only
occur inside a function. For example, this is *not* allowed::

    package main

    import "fmt"

    m := 4  // compiler error: can't use := outside functions

    func main() {
        fmt.Println(m)
    }

Replacing ``m := 4`` in this example with either ``var m = 4`` or ``var m int
= 4`` would fix the problem.


Declaring and Assigning Multiple Variables
------------------------------------------

Go_ lets you declare multiple variables with a single ``:=``. For example::

    name, age := "Jane", 22

You can also assign multiple variables using ``=``. For instance, here is a
convenient way to swap the values of two variables::

    x, y := 1, 3

    x, y = y, x    // swap x and y

    // now x == 3 and y == 1


The Redeclaration Rule
----------------------

One other difference between variables declared with ``:=`` and those with
``var`` is that, in some cases, ``:=``-style variables can be redeclared. For
example, most programmers would not be surprised that this code *doesn't*
compile::

    var z int
    fmt.Println(z)

    var z int       // compiler error: z is re-declared
    fmt.Println(z)

Or that this code also fails to compile::

    z := 1
    fmt.Println(z)
    z := 2          // compiler error: no new variables on left side of :=
    fmt.Println(z)

While the error is expected, the *reason* for the error is not the same as in
code that declared ``z`` using ``var``. Here, the error message implies that
everything would be okay if you put a new variable on the left side of ``:=``.
So lets try that::

    z := 1
    fmt.Println(z)  // prints 1

    r, z := 0, 2    // okay: this compiles!
    fmt.Println(r)
    fmt.Println(z)  // prints 2

The variable ``z`` has been re-declared. Allowing a variable to be re-declared
seems rather odd, but the reason is to allow for things like error values. For
example, many Go_ functions return two values, the main value of the function
and an error flag. For example::

    f1, err := os.Open("story1.txt")

    f2, err := os.Open("story2.txt")

Without Go's redeclaration rule, we'd have to write ``err1`` and ``err2``
instead of just ``err``.


Unused Variables
----------------

Go_ considers unused variables errors. For example, this code won't compile::

    a := 3      // compiler error: a declared but not used
    b := 4
    c := 2 * b

    fmt.Println(c)

Unused variables are often a sign of an error, and so this can be a very
useful sort of error. However, it can be a nuisance in smaller programs,
especially ones you might write to help understand details of the language.


The Blank Identifier
--------------------

Another variable you will often see in Go_ is the ``_``, which is known as the
**blank identifier**. It's normally used when you must create a variable you
don't care about. For example::

    f, _ := os.Open("story.txt")

The ``_`` indicates we don't care about the second value (which happens to be
an error flag) that ``os.Open`` returns.


Questions
---------

#. Show *three* different ways to declare a variable of type ``string`` whose 
   initial value is ``""`` (the empty string).

#. Is the following statement legal in Go_?

   ::

      var x

   Why, or why not?

#. Is the following statement legal in Go_?

   ::

      var x := 3

   Why, or why not?


#. Explain in brief, clear English, when you are allowed to redeclare a 
   variable in a block of code.

#. What is the blank identifier? Give an example of how it might be used 
   in Go_.