Slices, maps and looping

To work with a sequence of elements in Go, we can use either a slice or an array.

Slices are dynamic in size, while arrays are fixed in size.

In Go, it typically reads for a slice, but I want to show you an example of both.

So let's create an array here, let's call it accounts and say this variable can have two strings.

And let's just assign some values, let's say we have our Alice account and our Bob account here.

Now, it's important to note that the size or capacity of this array makes it into a distinct type.

So what that means is that if we had another array that was also holding strings,

but let's say it could have three strings instead of two,

we could not combine these two because they are technically distinct types.

Now, the slices or slice version of this would be, let's call it accounts slice.

And instead of specifying the capacity, we leave that empty and we are again going to be using a string here.

And I'm going to add Alice and Bob to this slice again.

Now, as I said, slices are dynamic and can grow in size so we can continuously add elements to a slice.

Slices are built on top of each other.

Slices are built on top of arrays.

And this simply means that whenever we create a slice, it gets a default set capacity.

And once that capacity has been reached, this slice will be reallocated to a larger underlying array by the Go compiler.

Now, to add to this slice, we could say, here, let's say account slice.

Then we're going to use the append function where we are going to again say we want to append to account slice.

And let's add Charlie to the slice.

So now our account slice have three elements, Alice, Bob and Charlie.

There's also built in support for maps, which is a simple key value data structure.

And to create a map, we are going to specify the map keyword and then the data type of the key and then the data type of the value.

So let's create a new map here and let's call it user account balance.

And we're going to say the key is going to be a string and the value is going to be 64.

In here, let's say we have Alice and Alice has an account of 100 and Bob has an account of 50.

We could also create an empty map and then add to it so we could jump up here and say, wow, let's call it.

Savings or user, let's call it user savings account.

And that is going to be equal to a map string and it's 64.

Hi, Future Morten here.

I'm currently missing a step in the example I'm showing you on screen right now, and that is to initialize the map.

If you were to run the example right now, it will cause a panic.

And that's because we haven't initialized the map.

So to do that, go to the variable we are creating.

For the map.

And then you simply wrap the map part in a make function and then set it to zero.

And that way we can actually run the examples on screens on the screen.

Okay, back to the video and then down here.

You could now add to this map by saying user.

Oh, sorry for that user savings account.

Let's create a savings account for Alice.

Alice has 50.

And then we could repeat this for Bob and say Bob has a savings of 200.

So this is just different ways that you can you can work with with maps and add data to it.

Finally, we can loop through these data structures and I'm just going to show you some different ways.

But technically we only have one real way of doing loops in go with the four keyword.

So let's say we wanted to loop through all of the accounts.

Of the accounts array.

We could say for four I equals zero and then as long as zero is I is less than the length of the accounts array.

Then we're going to increase I and for each iteration.

We could say something like if FMT prints say account and let's just say account, right?

So we're going to say.

Say account count index.

And balance is going to be a value here.

Then we can specify the index and we can specify the accounts.

And of course, this is not going to be balanced.

This is going to be owner.

You can also say for key value equals range and let's range.

Over the user.

Account balance map instead this time and again here we can print out the values.

So instead of saying account index, we could say something like.

Yeah, let's just say the ID is going to be.

String and then we will say the balance is going to be a value.

Like this remove this and then we say key and then we say value.

So for each iteration we get.

We get how I need to use the correct.

There we go.

So for each iteration when we loop over the user account balance,

we get the key and then we get the value.

Now we can also.

Use the index directly.

So if you were to say something like index count.

And then we loop over the let's say the accounts.

Counts slice here.

Then again, let's just print out these values.

So we can again say index.

And we then have the.

Owner.

So this is going to be the index and this is going to be the account.

Finally, we can also say for I equals accounts.

So we need a range here, of course, and then let's just copy this one more time and say.

Accounts at index.

And then we just provide the.

Index.

And we are getting a diagnostic error here.

This is some of the more modern versions of looping that we could use.

So we can just let's replace this.

So we basically have basically have what we have down here.

But this is how you work with slices and arrays and maps and how you can loop through the blue food and get the values.

values out if you ever need to do so.