Now that we've got our new Swift file ready to go,

it's time to create our data model.

If you remember back from object-oriented programming,

two objects that we've already learned about are structs and classes.

I said in the past that we'd be creating structs for our data models.

Structs are great when the data model is simple and

when we don't care about which particular instance that we're working with.

Right now, the primary use for a data model is to hold an array of facts.

So a struct is perfect is perfect for that.

You could use a class here and have no problems.

But in any case where a struct will suffice, it's nice to just go ahead and

use them because of how simple they are.

The really great thing about structs is that we don't have to worry about creating

initializers.

Structs will create their own initializers automatically for

us, right out of the box.

Which saves us a little bit of coding.

To create a struct, we need to start with the struct keyword.

So struct, followed by the name that we want in upper CamelCase.

So let's go ahead and call our model RandomFactProvider.

Just as a side note, it's always good practice to keep your file name

as the same name as the model inside.

So here we have RandomFactProvider.swift, and our model name is RandomFactProvider.

Nothing's gonna break if you don't do this, but it's just good practice.

All right, and let's finish this off by adding some curly braces.

Remember that Swift objects like classes and

structs can contain stored properties to hold data.

Currently in our ViewController.swift file, our random color and

random facts arrays are stored property of our ViewController class.

I wanna grab our random facts array out here.

So let's highlight our facts, and make sure you get this little bracket here.

And cut it with Cmd+X.

And back in our model, let's just paste it right in using Cmd+V.

Nice, but now we've got some errors back in our ViewController file.

You can even see that right up here, that we've got three new errors.

So let's go back to our ViewController file.

And it looks like we're trying to subscript an array that

doesn't exist anymore.

We just moved our facts array out of our ViewController class and into a model.

So now, we'll just need to use our model instead.

To access the array in our data model,

we'll need to create an instance of our RandomFactProvider.

So let's go up top and create a new stored property by typing,

let randomfactProvider.

And then set that equal to an instance of our RandomFactProvider.

And you can see it pop up right here.

When we create an instance of an object,

we use these parentheses here to initialize

any value in our object that need to have their values set upon initialization.

Because our RandomFactProvider struct only has one stored property,

which is an array that already has values in it,

we can just use an empty initializer, just like we did here.

If any of that sounded really foreign to you,

we cover it all in the object oriented Swift course.

Now we can go ahead and replace the code we had earlier, to use our new data model.

So first up, in viewDidLoad, we'll say randomFactProvider.

And it's really important here that we use our randomFactProvider variable that we

created up top.

The capitalized one is actually just our struct.

And we're not trying to use that,

we're trying to use our stored property that we created up top.

All right, nice.

Now our random fact generator instance has a property that's called facts,

which is what we created in our model.

So using dot notation, we can access our facts array.

Nice, so let's hit Tab.

Right now this is getting us back our entire array.

So just like before,

we wanna use subscript notation to get the first item out.

So use brackets for subscript notation.

And we want the first value out, so we'll use a 0.

Okay, nice, so we don't have an error here anymore.

Let's check out what's wrong down in our showAnotherFunFact method now.

It looks like we're running into the same problem.

We're trying to access a facts array that doesn't exist anymore.

So let's get rid of all this code for our upper bound.

And for our upper bound now,

we need the count of our facts array from our model minus one.

So randomFactProvider.facts, to get our array out.

And then just like before, we need the count property.

And remember we need to minus one.

So this is exactly the same logic that we had before, but

now we're just using our model's array.

And finally, right here, we need to solve the same problem again.

We're trying to use our randomNumber to subscript an array

that doesn't exist here anymore.

So let's get rid of all this.

And do randomFactProvider, .facts, to get our array out.

And then to get our random value out of our array,

we're just gonna use this randomNumber again.

So all we've done here is make sure that anywhere we were accessing

our array before, we just replaced it to access our model's factor right now.

Our logic is exactly the same.

Let's go ahead and run our app, and make sure everything's still working.

Okay, nice.

So our first fact is set, right off the bat.

Which we told it to do in viewDidLoad.

And when we tap on our button, nice.

We're getting random facts every single time.

We can abstract our code away even more though.

Our RandomFactProvider isn't really providing a random fact for us right now.

It's just holding our array.

We can move the functionality of picking a random fact out of our ViewController and

into our fact provider.

So back in our model, let's go ahead and create a new function.

Let's name it func randomFact, and we don't want any parameters.

And we want it to return a randomFact out of our array.

So we'll return a String, and we'll close it off.

Let's go ahead and grab the randomNumber logic from our ViewController

by cutting and pasting again.

Back in our ViewController, here's our logic for

getting a random number out of our facts array.

So let’s cut it by using Cmd+X, and we'll paste it into our new function.

Now that we’re inside of our model and

not using an instance property to access our facts array,

we can just get rid of this first part here, where we're accessing our instance.

Delete that.

So now, right from within our model, we'll be able to create a randomNumber

between 0 and our local facts.count- 1.

Now all we need to do is use this randomNumber to return a randomFact

from our facts array.

So we can do return.

And then just like before, subscript our facts array with our randomNumber.

So now this randomFact method will return a random fact out of our facts array.

Finally, back in our ViewController,

instead of doing this little bit of logic in our ViewController, we can just set our

randomFactLabel.text equal to our randomFactProvider.

Which again, is our local instance of randomFactProvider.

And access our new property called randomFact.

All right, so let's run our app one more time and make sure that all still works.

Okay, everything looks good so far.

And if we tap on our button, awesome, it's still working.

Perfect.

This might have seemed like a lot of work for the same results as we had before.

But it's great to get into the habit of refactoring as early as you can.

Keeping your code readable and reusable should always be a high priority, and

something you're thinking about as you write your code.

If your ViewController file has a bunch of logic or collections in it,

chances are a lot of that code could be abstracted away by refactoring.

Employers and fellow coders are gonna want to see that you care about how clean and

organized your code is.

I can also speak from experience.

It's a lot easier going back to work on an old project that you haven't worked on in

a while, if you've taken the time to make it readable and organized.

Next, let's create our random background color provider.

If you're feeling comfortable, I'd encourage you to try to create this second

model called random background color provider by yourself, before moving on.

I've left an array of colors down in the teacher's notes if you wanna

give it a try.

If you're not ready for all that, that's totally okay.

Maybe just try to think about the steps we might take to make our model.