All language subtitles for 6. Our First Node.js App

All right, everyone.

It's time to finally build our first node project.

It's going to be something simple and a little silly, but it's going to get us started on our journey

to building some really nice applications later on in the course.

Let's start.

So I have my hello dogs here and my terminal below.

And we're going to start by creating a constant to save our mission.

Which is going to be to learn and we're going to see if our mission.

Is equal to learn.

Then we're going to use our console that log.

To say.

Time to write some note code.

And otherwise, we're going to say console.log is whatever we put for our mission.

So we're going to use the plus operator to concatenate the mission string with our question and we're

going to ask is mission really more fun?

OK, so now we can run our Hello, Douglas.

And we should see.

It's time to write some note code because our mission is to learn.

But we can improve our program slightly by using this Xmas script six feature called Template Strings

and ActionScript is just the latest standard for the JavaScript programming language.

So recent versions of JavaScript have this feature where we can use strings with this Bektic instead

of a quote.

And surround our string with back ticks on both sides.

This allows us to insert variables directly using this dollar sign and brace syntax.

This is a little cleaner than concatenating the strings every time using that plus operator.

And it's possible because note is kept up to date with the latest versions of the V8 JavaScript engine,

which is in turn kept up to date with the latest features in the ActionScript standard.

What this means is that newer versions of Node will contain the latest JavaScript language features.

This is great, but up until now, all of our code here has been just JavaScript.

We could copy and paste it.

And in our browser, in our developer tools.

We could paste our code into the JavaScript console and we get the same output.

But remember, because we're using node, we actually get a few extra benefits because it's a runtime,

it doesn't just run JavaScript, we get a few tools on top of that.

So just like the browser here has the window object, which we can use on the browser, and it contains

things like.

If we scroll through it, it has functions like the alert function to show an alert window to the user.

It has a window that close function.

And if we scroll down to document.

The window object is storing what's called the document object model.

That the browser uses to store things like the URL being browsed and the body of the HTML.

These are all things that are not JavaScript.

They're added by the browser to support the functionality that it needs.

Just like we have browser functionality in the window object here on the browser node comes with its

own API or application programming interface, which is just a set of functions and how you use them.

These node APIs are things that are not pure JavaScript that are included in the node runtime node exclusive

features.

They're things that make sense in node that don't necessarily make sense to have in a browser.

So let's take a look at an example in our node rappel by typing just the node command.

You'll notice that we don't have access to the window object.

Just like we discussed.

It doesn't really make sense to have a node, but we have other features like the process object and

a few others that we'll talk about later.

But we can scroll through here and we see that there's a whole bunch of different information about

the process, which is just the node program that's currently running here.

One of the features in this node object that I want us to take a look at right now is this RV property

that we can see contains an array, and right now it just contains the path to our node executable.

So this will be different on your system, depending on where node has been installed and depending

on which operating system you're running node on.

But it always contains that path to note.

So what's this used for?

What's the purpose of having process thought RV?

Which is how we access this process, that ARG fee.

Well, let's explore this a little bit in our browser if we search for node process.

The first result should be the Node.js documentation, which will default to whatever the latest version

of Node is.

And if that doesn't match the version of node that we're currently using, then we can go to this dropdown

and select your version of Node.

And on the left here, we have a list of all of the modules, all of the APIs that are built into node.

There's quite a few.

So we'll explore this a little bit more later.

But the one we're interested in right now is the process module, and we can see that the process object

is a global that provides information about and control over the current Node.js process.

Now, don't worry, we're going to talk about what global means and explore some of the other globals

in the upcoming videos.

But right now, we want to learn about this RV array that we saw, and the node documentation tells

us which version of node the feature was added in.

So in this case, one of the first versions of Node that was released.

It tells us what the function returns in this case, an array of strings and then some documentation

for it, so we can see that RV returns an array containing the command line arguments past when the

Node.js process was launched.

And then it tells us that the first element will always be the path of the node process, which we already

saw, and that the second element will be the path to the JavaScript file being executed, while the

remaining elements will be any additional command line arguments.

So with this RV array, we get the arguments that were passed into node.

Back in our ED, if I exit out of the chapel and run node, hello, guess?

Using the process module, the Hello script can get access to the arguments that were passed to it.

Let me show you.

So instead of hard coding mission to learn, we're going to say mission is process.

That RV.

And we're going to select the argument at the second index.

Now I can do no.

Hello dogs and pass something afterwards.

Say the word explorer and explorer will be passed as an argument to our script.

It will be passed in as our gravy at zero one two.

It will be at the second index of our array.

And now our program knows that Explore is our mission, which is not equal to learn, so we get is explore

really more fun than learning?

Now I could go back to the way the code was with learned, hard coded and still in explore as an argument.

And the court will still run, Oops, I have to save my file first.

And we can see that the code still runs, but we get our old hardcoded response.

This is because arguments that aren't used are just ignored.

And now, if I add back our RV and pass in, let's say learn our hello a script is telling us that it's

time to write some nerd code RV at the second index is Learn.

Which makes our mission learn.

And Arkansas, that log is the first option here.

For now, we've used the process thought RV feature to build our first little silly node application.

But one through which we've learned a lot.

I now know that I have this node runtime with me, with which I can run code.

And tell my machine what to do.

And no, it has all of these nice things that it adds for us on top of just plain JavaScript and all

of these things that we see in the documentation, here are things that we're going to explore throughout

the course up until we write a real life application.

It's going to be a good one and we're just scratching the surface.

But I hope this gets you excited because this is just the beginning.

I'll see you in the next video.