= Node.js =

Node.js is an Asynchronus, event driven javascript runtime. On line the command
is `node`.

== Hello World ==

1) Create a file called `index.js`. This is always the entry point (similar to
   a main()).
2) Place code. It is interpreted the same as if it were in the browser. For
   example, 
   {{{
       console.log("hello world")
    }}}
   
== Modules Available ==

All modules are included by using the `require('MODULE')` syntax

| Module | Use |
----------------
| HTTP         | classes, methods, etc to make Node.js server |
| uitl         | utility functions for developers             |
| fs           | filesystem                                   |
| url          | parse urls                                   |
| query string | work with the query string                   |
| stream       | handling streaming data                      |
| zlib         | compression                                  |

== Events ==

Events are times when certain things happen. We can do things on those events
by using a callback. This is accessed via the process object. For example,

{{{
    process.on('exit', function() {
        Console.log("Goodbye!");
            });
  }}}
  
Will print goodbye to the console when the program terminates. process.on takes
two paramaters, the event name '`exit`', and the function (or lambda).

To create an event, we can use the Event Emitter, a node.js builtin. The
following example is an annotated example of exactly that.

{{{
//pull in the event emitter dependency
const { EventEmitter } = require('events');

//create the event emitter
const eventEmitter = new EventEmitter();

//create the callback 'lunch'
eventEmitter.on('lunch', function() {
    console.log("Lunch time");
        });
        
//trigger the callback function
eventEmitter.emit('lunch');
  }}}
  
As you can see, this is a similar concept to something like function pointers,
where a pointer is assigned then later called through the pointer.

== File system ==

The file system can be read in two modes, either in a block or non blocking
mode (similar to async calls in C#)

Below is an example of exactly that. The 'Sync' calls are ones that are done in
a blocking manner

{{{
//import read file 
const { readFile, readFileSync } = require('fs');

//read the file, blocking
const txt = readFileSync('./sample.txt', 'utf8');
console.log(txt);

//or read the file on a seperate thread
//the third argument is the file name, encoding, then the function (which gets
//passed both the error object, and the contents of the file)
readFile('./sample.txt', 'utf8', (err, txt) => {
    //stuff to do after we get the file
    console.log(txt)
});

console.log('this is called after the fact');
  }}}
  
== URL ==

Node.js can help you parse URLs and resolve where they lead. The module is
build into node.js. The following example code would print the hostname,
filepath, and search string (as an object)

{{{
//import express and url
const express = require('express');
const url_lib = require('url');

//create objects
const app = express();
const url = 'http://www.clortox.com/posts/';
const parsed_url = url_lib.parse(url, true);

//express listener
app.get('/', async (request, response) =>{
    response.send(parsed_url.path);
});

//listen
app.listen(process.env.PORT || 3000, () => console.log('Available on localhost:3000'));
  }}}
  
== Packages ==

Node.js's package manager is npm. It can download packages for you to use in
your project. To start using npm in a project, run `npm init -y` to setup a
package.json file, which is how npm keeps track of files it needs. Now to
install a framework (for example, express), run `npm install express`, and
thats all that is needed

To include a package (which includes the several built in packages), use the
`require()` syntax, and pass it a string argument of the name of the module.
This system is how you can use several files on one project. To include a
module called 'my-module', you first create a my-module.js file, the add this
to the top of your code

{{{
const myModule = require('./my-module');

console.log(myModule);
  }}}
  
Then in the module file you must export code from it. In the module file, add
the following

{{{
    module.exports = {
        myvar : 'some value'
    }
  }}}
  
Now myModule.myvar will return 'some value'. You can use functions and the like
here to make easy to import functionality.