One very common construct in programming is the dictionary.

In Objective-C., we use two classes of dictionaries.

NSDictionary and NSMutableDictionary.

If you don't know what mutable means, it simply means changeable.

So you can probably guess that instances of NSMutableDictionary

can be changed in more ways than just a regular dictionary.

In fact, it's best to use NSDictionary only for

static dictionaries that you don't really ever intend on changing.

In about three minutes, we'll wheel out the old Xcode and give those two a try.

But before that, let's talk about dictionaries in general.

So as I mentioned, dictionaries can be found in lots of computer languages and

for obvious reason, they're a natural reflection of how we think about and

categorize data in the real world.

I mean that sort of makes sense.

Way before we ever had one of these on our desktop, we all had one of these.

Now a paper dictionary is set up in key-value pairs.

The Key is the word you're defining and the Value is the definition or

list of definitions.

If we look at the key dog.

We see a value of, I don't know, a furry animal far superior to the cat.

That key value pair is also called an entry.

Our paper dictionary has hundreds of pages and defines tens of thousands of words,

but it only has the word dog defined in one place.

That key only appears once.

Yes, it might have several definitions but

those are all collectively, the value of that one key.

In a paper dictionary, we're confined to just using strings of letters and words.

But in the realm of programming, dictionaries are much more versatile.

The keys are strings but the values can be all sorts of objects.

Now it's important to note that objects mean objects.

You can't store primitive values like ints or floats in an NSDictionary.

Instead you have to convert them into a numerical object first,

like an NSInteger or an NSNumber.

That isn't hard by the way, but it does often trip people up.

Let's say we wanna store data about runners on our track team.

We wanna record their first name, last name, weight, gender,

fastest 100m dash and also what other sports they like to play.

We could do that for a theoretical runner really easily like this.

Here we see, we've used a mix of strings, numbers, and

perhaps something like an enum for gender.

We even have a collection being used to hold the list of other sports.

Now remember that collection is still just one value tied to the key "other sports".

The value just happens to be a collection.

You can see how this type of construct would be useful

since we could create a similar dictionary for every member of the team.

Once we do we,

we have a spot perfectly designed to hold the information we know we'll want.

Similarly when a runner breaks their own record,

we have a spot to enter the new time which will automatically replace the old time.

In thinking about our track team as a whole,

the dictionary comes in handy again.

When it's time to rank all the runners by speed, we could just

loop through all the dictionaries focusing on the 100m best values.

Or if we wanted a list of just male runners, we could again get through and

filter based on the gender value.

In both cases, we're keeping a lot of data neatly organized for

each runner, but we can selectively act on or ignore that data as we like.

Saving us lots of potential confusion and processor time.

Now you folks all know me from Treehouse, so

you probably think I spend all my time thinking about computers and code but

in actuality I spend most of my time thinking and talking about food.

With that in mind, let's create a new command line tool.

And we'll call it Burger Barn because hey,

who doesn't wanna eat their burgers in a barn, right?

Now remember, since we're just focusing on learning the language of Objective-C.

We use a command line tool,

that way we don't have to worry about any user interface.

Once you start building real apps,

you'll build much of your app graphically, not simply in code.

Okay, so Burger Barn is a very simple restaurant, so

simple in fact that they only sell two things, burgers and shakes.

And yes those burgers come with fries, so

don't worry about us cheating our make believe patrons.

Now the owner of the barn, named Barney,

by total coincidence, wants to start tracking the orders in a computer system.

Up until now, everything just gets written on a notepad.

That works for the cooks and the waitstaff, but

management is left with a stack of papers rather than any actionable data.

Barney, the owner, gave us a list of things he wants to know about each order.

I'll open up our main, and then we can paste

that information that we wanna keep track of down here In a comment.

We wanna know the number of burgers, the number of shakes, the number of customers.

If the order was for take out or not and then the order subtotal.

Seems like we could use a dictionary to store that stuff, right?

To do that, let's give ourselves some room here in the main function.

Then begin with the class we want.

That's gonna be NSDictionary.

Then *orderDict, which is what we'll call this instance of the NSDictionary class.

After that we can simply say = and

begin typing in the key value pairs we wanna store.

I'll type it all in and then we'll review it.

Okay, the first thing to know is that we're assigning keys and

values to this dictionary using literal syntax.

That's what all these @ symbols are about.

Our NSDictionary begins with an @{ which tells the compiler,

hey what's coming next is a dictionary.

Then inside our dictionary, we create our keys which are strings using @ and

quotes just like any NSString.

Our values on the other hand, are a mix.

Some are NS numbers and Boules.

And for those, we just use an @ symbol before the value we want

as that will convert it to an NS number object.

By the way, I've included a handy guide to literal syntax in the teacher's notes.

It's worth checking out.

So now we have a dictionary representing an order of five burgers,

three shakes for a table of four customers that is not take out and

the subtotal is still $0.00.

I left the subtotal as 0 because we'll be computing it ourselves in a minute.

But before we go there, let's drop in a breakpoint, run our app and

see what we get.

All right, just as we expected, we have a dictionary with five key value pairs and

they're all the values that we want.

Now Barney told us that the burgers cost $4 and shakes cost $3.

Let's see if we can extract the values from our dictionary and use them to

compute the subtotal, then insert that value back into the orderDict we created.

Now we use magic numbers in our sample dictionary.

But what variables will we want to help create and build our logic?

Take a minute, jot down the variables you'll wanna create,

and then continue to the next video where we'll put it all into action.