All language subtitles for 4. The Node.js REPL

So what happens when I run the node program inside of the terminal?

I'm now running note and everything I type.

So Hello is treated as JavaScript code in this case, as a variable that hasn't been defined yet, which

causes Node to give us this reference error when we run node and don't type anything after it.

Not passing in any arguments.

We're running node in a mode that's called the Rappel.

That's our EPL, which stands for read a Val Print and Loop.

Before we dig into that, let's think about what would happen if we typed in some code here, so say

we added Woohoo!

Plus who?

Well, in JavaScript, this would concatenate the string Woohoo!

With the string who?

And we get woo-hoo.

And if we take this same code and assign it to a variable, say, a constant called cheer, that variable

is now assigned the value of this computation.

So now if we type cheer.

Cheer has been assigned to who.

So what exactly is going on here when we run node and we're in our rappel, we can type in JavaScript

code like our cheer and the rep all responds to this input in some way.

It responds to it by reading the input.

That's the are in rappel.

Evaluating it, printing the results of running that computation, of running that JavaScript code and

then loops all over again.

So first we perform all of these actions in sequence and then we loop back to the start where our rappel

environments will be ready to read in the next line of JavaScript.

And this will continue until we exit the program with our Control C key combination or we Typekit exit

and press enter.

So what exactly does the read step here do?

It includes reading in our code that we type with the keyboard, but also parsing that code.

Parsing means that the V8 JavaScript engine will break down our line of code and understand the role

of all the different parts of it.

So, for example, it will understand that we have WUE here as a string and who as another string.

We have this plus sign where they're being concatenated.

We have an equal sign where the result of this, whatever that is and it hasn't been evaluated yet.

But the parser will now know that this equal sign means that the left side here is being assigned whatever

is on the right side.

This past code will then be run and evaluated by Veidt, which will give us the results of this line,

so it will add these two strings and assign them to the cheers constant.

And finally, the results will be printed to the console in our terminal.

So when we concatenated are strings, we added them together and the result of that expression was printed

in our people.

Now, when we defined our constant, we got back undefined because when we assign a constant, nothing

is returned in JavaScript.

It's only once we print our variable that we get the value of our string.

Woo hoo.

All right.

So it's worth noting that when we're typing code into our rappel, the code that we wrote earlier sticks

around so we could now type cheer and we would always get back.

Woo-Hoo.

I could create another constant greeting equals hello, and I could call that.

But if I try to read a clear cheer, say, by creating another variable.

And setting it to Yappy.

I get a syntax error, which is JavaScript telling me that cheer was already declared so we could continue

building up larger programs using the building blocks that we've already created.

But if we close our apple and then reopen it.

We lose track of what we were doing.

Rebels tend to be good for quick testing of little bits of code in isolation and experimenting with

how node behaves.

For example, if we're curious what happens when we try to add a number to a string?

We could test that out in our Apple, but nobody would use a rappel to write a large application.

It's just not the right tool for the job.

It doesn't provide a way for us to save our code or separate it into different files.

It doesn't allow us to edit the code that we wrote previously usually will be writing our code for node

applications in JavaScript files in code editor.

Let's keep building up our knowledge and find out all about how to set up our node development environment

in the next couple of videos.

I'll see you then.