Video 3.3 core nodes to In this video, we will learn the next set of coordinates on your pallet switch change template will also see the other features of the function node. Ready for this video, let's go. There are three more features present in the function node. They are sending asynchronous messages, adding additional modules to use within the function node and using context variables to store data. Of these. We're going to see the last one in this video.

The first two we'll see later. Don't worry if nothing makes sense. Things will get clear as we progress. Okay, let us build a cool application. We'll have two fields. The first one should keep track of how many times the flow has been triggered.

And the second one must use this and print out the count value one by one. But how can we do this? The first one itself sounds impossible. How can we store the count value in some variable? The variables get refreshed every time we trigger a float right? Then how can we store things inside nodes?

And even if we store How can we use it in another flow? Well, nothing is impossible with no dread. We'll start with the first flow. Now for this, we'll need an inject node to trigger the flow. And we need to see the output in the debug console. So debug node good.

See you getting the hang of it. Now make sure you have the debug node to output the Complete message object. Okay, what else do we need? function node? Yes. We've seen only that till now.

So yes, but again, how can we store data inside a node? This is the part where context variables reveal themselves. These variables store data in the context store, which is stored in a memory. There are three such variables called context flow and global. Sounds familiar? We've obviously seen these somewhere.

Yes, we saw them in the inject node. These are predefined variables to access the context. Okay, what exactly are they and how do we use them? Let me explain. The context variable stores data within a note, no matter how many times you trigger the flow Pretty cool isn't it? The flow variable stores data for the flow, or the current tab or workspace, and the global variable stores data for the workspace.

The global variable can even be accessed across workspaces. Note that the context variables except for the global variable are cleared on redeploying your flow. You can also have persistent context by storing the context data in a context or present in the local file system. If you want to know more, look out for the link in the resources. Okay, for the counter we're going to build which variable do we need? If you said context, you are right.

Okay, let's configure the function node. Now, I have some JS code already written here. Let's check it out. We need some variable to store our data, right? So we'll initialize a variable called count to zero for now, forget the first spot. Next, we should increment this variable by one okay, but how can we store it?

I told you about context variables, but how do we use them by using the get and the set access methods? If you understood this part, you can imagine and see that every time the flow triggers the variable is initialized to the last stored value and we set it again here. So that is how this works. Understood. Okay. We have stored this value in context variable count, but how do we get to another flow?

If you thought of global context, you are actually Absolutely right. Could we set a new global variable called poll and set the count value to it? Done? Okay, let's check it with let me name my function node. Okay, deploy. See, it works fantastic.

But how do we know that the global variable has taught the value, we can use the inject node to check it like this. Now, like I told you before, the global variable has not been cleared. So when we reinject to store a new value in the context variable, the global variable is again set. Okay, now we'll move on to the next flow. You can create loops in many ways, but here, we're going to create a loop Using the function node and the switch node, switch node, that sounds new. Remember the switch case, branch condition.

Switch node is similar to that. Inside the switch node, we can have a lot of rules, which evaluate against the message. And if the condition is true, then the flow is created over that branch. We can add rules like this, we can change the property to be evaluated against like this. We can even configure the switch node to either evaluate all the rules or we can make it stop after it finds the first one that matches. Now let's come to the rules.

There are four types of rules. The value rules are evaluated against the configured property. The sequence rules can be used on message sequences. A JSON data expression can be provided to evaluate against the whole message. And it lost the otherwise rule, which will be matched if none of the above rules are matched. So that is about this switch node.

But why are we using it here? Well, we'll increment the variable value in the function node, and we'll check if the value is less than the pole variable in the switch node. Okay, let's connect it up function node first, with the payload getting incremented by one and the switch node with two roles. Less than the poll variable and greater than or equal to the poll variable. Good. But we haven't tried out the flow variable yet, right?

So why don't we use it But wherever we use the flow variable, we can find a way to track the change node from the palette. The change node will be used to change the global variable pole to the flow variable count. Let's see how open properties have the change node. Here, you can see that there is already a rule. The change node can be used to modify a messages properties and set context properties. Remember, we had set message dot payload to the poll variable.

So we have to give the message dot payload as one here for it to go around the loop and count five times if the poll variable is five. And remember, we also have planned to use the float count instead of directly using the global poll variable. So we can set them by Hear like this. You can also change, move or delete a property. The change rule will search and replace parts of a message property. The move rule will copy a property and delete the original property.

The delete route will delete a property. To understand the change node clearly, try out the flow file I've included in the resources. Also, note that you can delete the context variables using the change node. At last, to trigger the flow, we need an inject node. Note that in both flows, the inject node is only used to trigger a flow and so it doesn't matter what they load, the inject node is inputting into the flow. Well, in the second flow, you can also set the payload There as one, but to try out the change node also, we are doing it this way.

Next, the debug node to output the value to the console. But why don't we try using the template node before the debug nodes? as the name says, It is used to fill out a template using the messages properties. It generates a normal text. It uses a language called moustached to that, yes, you heard me right mustache. It is again a language which you can go through by checking out the resources.

But for now, understand that to use a message property, you can call it using this syntax. I have included an example flow for template node. You can try that out and come back to this. Okay. Now we're going to use template nodes on both the branches of the switch node to make them output looks nicer. Just add your own text and click Done.

Deploy your flow and check it out. Does it work? Great. We have been talking about this context data for a long time now. Did you remember seeing a tab on the sidebar with the same name? This contains all the context data, node flow and global.

If you refresh, you can see your data getting updated. Cool, isn't it? Okay. One thing to note is that the function node which we use for writing custom code has its own sandbox environment, which runs our code using Node JS VM or virtual machine package. This sandbox environment provides level of isolation from the core node runtime. So every time a flow triggers, the runtime has to switch to the function nodes sandbox context to run the code, and then switch back out to the context where the function node is fully executed.

This incurs a performance penalty. So it's always wise to use the other core nodes wherever possible, instead of using the function node. Okay, we've come to the end of this video. Here, we've learned how to use context variables. We have also learned how to use the other core nodes. In the next video, we'll learn the rest of the function node features and other additional nodes in Node red