Original subtitles

In the last lecture, we have started talking about a basic Voges concepts in it is like to continue

with this and I will introduce you that properties.

OK, let's start there.

We have finished in our home view.

And let's introduce here a couple of computer properties.

You will vary the couple properties like these you already computed.

I usually riding it about them.

Efforts computed and the same as a methods.

You will choose the name of your computed property.

In this case, I would like to create two computed properties.

One computed property will determine the length of my exchange list, and other computed property will

be reacting to the count if the count will be a larger than 15.

It will return true.

Otherwise, it will return false.

As you could see in the last lecture of the new jazz framework is super reactive.

You don't need to write much code and you can achieve a lot of functionalities.

And I really like this episode of jazz and a cappella properties are one of my favorite feature.

So, for example, I will create here to compete properly.

You can call it as you want.

Call it Exchange List Exchange List Length X Change Just extension length, by the way.

Exchange length, it's enough and what you're doing.

I compare the properties you are reacting to the data or to the other complex properties.

In this case, we want to react to the data of our exchanges here, but we'll say here a larger atrium

because every communal property should return value.

The value return in this exchange is not linked.

So now the exchange length will determine the length of the exchanges in a data, it can gather exchange

length.

You can go up here and you can simply let's try this value here, right here.

Exchange linked, linked here.

So you know what the value is, we are getting ground here.

OK, so what is the exchange length?

We have only two items of exchange like should be to right.

So let's refresh and you can see exchange length is is.

So I counted an exchange linked to.

It's not very nice promoted.

So I will give up all of these elements into deals here like this.

And also, what about this that they've.

And Steve, here, so they are on the separate lines.

OK.

Exchange like two, but you can really see the power of the of these because if I will change and they'll

exchange existentialist data, I will add here dynamically more items or I would remove the items this

that properly would be reacting to this, which is very interesting.

So the company property is all this checking.

If there is dependencies that are changing dependencies in this case is the exchanges, because that's

what we are using from our data.

So if the exchanges data would to change, we would remove the items or other items.

Diesel would dynamically change.

And also our view would be dynamically changing depending on the items we would have in our data.

I'll show you this on the counter-example.

Let's read here another company property, and let's call it is bigger than a 15 is bigger than 15.

And this property will be reacting to the change of the count.

So the idea if this account is larger than the 15 returning false or it'll be true, actually, that's

really true.

Otherwise, a return me later may be false.

OK?

They can also simplify it.

You can also have all of these.

You know that as a one line, there are just simply video return.

And this is larger than 15.

OK, and you can.

The name of this is exactly the same, but they are checking each one later.

So if this is larger than 15, they'll be turning.

The true value of this is smaller operator.

Be telling a false value, not able to get it yet to go up back to my template and I will be right here.

Very happy to hear an ADF.

Actually, the county badger DPH is is larger.

Then 15, OK.

The curly brackets.

Let's close a deal here, OK, and now we will see how how reactive it really is.

OK?

Properly, there'll be all this checking the count.

OK, you can see if India is larger than 15.

It's false because the count is then as there will be changing it 11, 12, 13, 14, 15 16.

It's change you throw.

OK, so that's the reactivity feature out of the box, and the compute properties is always checking

for its dependencies.

OK, so.

These complex properties, every time we execute that whenever you are changing the count and your return

again, your value are getting updated into the view, I can show it to you.

All right, your console look.

Re executing well, right, and you will see that every time.

I'll change the value refresh.

This copy of properties are executed and it will be returning the new value.

OK, so that's I think it was going to be for these lecture.

They can look at their computer properties, remember they are like a function, but they are really

properties that you don't need to call them, who does need to access the cockpit properly without breaking

any brackets to simply be connected to them as they count, for example.

But they are in the background, also executing depending if their dependencies are executing their

dependencies.

Are the data here exchanges and the count?

So that's going to be to let's continue in the next lecture, I see where you guys cheers.