Use Maps in Go and learn how to connect data together.

Go Maps

In Go, there are two ways to create a map. We'll be covering both
in this exercise.

#### Creating a map with make

We can use the `make` function to create an empty map. The format is:

 ```go
variableName := make(map[keyType]valueType)
 ```

For example, we could create an empty map of product name to price:

```go
prices := make(map[string]float32)
```

Creating empty maps is useful when we don't know what the content of our map will be. But sometimes the content of
the map is known ahead of time.

#### Creating a map with values

If we know some map values, we can specify them as follows:

```go
variableName := map[keyType]valueType{
	name1: value1,
	name2: value2,
	name3: value3,
}
```

For example, we can create a contact list with:

```go
contacts := map[string]int{
	"Joe":    2126778723,
	"Angela": 4089978763,
	"Shawn":  3143776876,
	"Terell": 5026754531,
}
```

We've learned how to create our maps, but how do we access the elements within them? We'll do that in the next exercise.
Before that, let's practice creating some maps!

Map Creation

In this lesson, we have introduced concepts and syntax related to using **maps** in our Go programs. Let's
take a moment to review what we've learned.

#### Map Creation
Maps can be initialized with or without data.

```go
customers := map[string]int

employees := map[string]int{
  "John":  1001,
  "Ezira": 1002,
  "Emily": 1003,
}
```

#### Accessing
We can look up values with a key. We can also get a `status` value to determine if the key was set in the map.

```go
count,status := inventory["sporks"]

if status {
  fmt.Println("we have %d sporks!", count)
} else {
  fmt.Println("what is a spork?")
}
```

#### Adding and Updating

Adding and updating key-values in our map follows the same format:

```go
customers["George"] = 10.50
```

#### Deleting

We use the `delete` function to remove key-value pairs from our map:

```go
delete(inventory, "sporks")
```

#### Conclusion

We can use maps for all sorts of things! Examples include:

- Organizing collections such as types of coins, kinds of donuts, etc.
- Mapping different data such as people names to balance due.
- Storing frequently used content for a user.

We now can use maps in our programs! Try this out anywhere where we need to associate related information.


Review

Maps are also easy to add key-value pairs or to change the value of an existing pair.
In both cases we specify the map name, the key, and the value:

```go
yourMap[newKey] = newValue
```

So to add a new customer balance, we could do:

```go
customers["Samantha"] =  1.25
```

We can use the same format to change an existing value. The format is the same!
So when Samantha buys another donut:

```go
customers["Samantha"] =  2.75
```

We now have the ability to add and update values in our maps. In the next exercise, we'll learn how to remove key-value pairs. Before then let's practice adding and updating!

Adding and Modifying

Sometimes we have a key that we no longer need in our map.
Go allows us to remove elements using the **`delete`** function:

```go
delete(yourMap, keyValueToDelete)
```

Let's say we want to remove a contact from our phone:

```go
delete(contacts, "Gary")
```

If we call the `delete` function with a key that is not in the map nothing bad happens. Other languages may crash or throw an exception!

Let's practice the delete operation and then we will review everything that we have learned.

Removing

Maps make it easy to look up values and store the value in a variable for further use:

```go
variable := yourMap[keyValue]
```

But what happens if we never added the requested key-value pair to the map but try to look it up?

If a key is not in the map, a default value for value type is returned. We can also get a second return value to determine if the key is in the map.

```go
customer,status := customers["billy"]

if status {
  fmt.Println("we found the customer")
} else {
  fmt.Println("no such customer!")
}
```

Notice how we have a `boolean` called **`status`** that we can check. When `status` is `true`, the key was found in our map!

Now we know how to access values in our maps. But how do we add or change these values? We will do that in the next exercise but let's first practice accessing maps.

Accessing values in the Map

Think of a list of contacts on a phone. We can search by name to find the associated phone number. In
programming, we often need to connect one data piece with another. This association is what maps are perfect for!

A **map** is an unordered collection of **keys** and **values**. Here is an example of connecting a key of type `string`
with a value of type `int`:

| Key | Value |
| --- | ----------- |
| Joe | 2126778723 |
| Angela | 4089978763 |
| Shawn | 3143776876 |
| Terell | 5026754531 |

We are able to access map values by looking them up with a key. Unlike an array, values in a map are not accessed by
indices. Maps allow for very fast lookups by organizing the values for retrieval.

We use maps for tasks such as:

- Counting the number of times unique names appear in a list.
- Mapping simple identifiers, such as an employee id, to related values.
- Anytime we need to associate any piece of data with another!

Throughout this lesson, we will introduce:

- Creating maps
- Accessing map values
- Adding and modifying values
- Removing key-value pairs

To begin using maps, we will first have to create them. We will get started in the next exercise!