NODE.JS CHEATSHEET

-

Node.js REPL

Node.js comes with REPL, an abbreviation for read–eval–print loop. REPL contains three different states:

*a read state where it reads the input from a user, *the eval state where it evaluates the user’s input *the print state where it prints out the evaluation to the console.

After these states are finished REPL loops through these states repeatedly. REPL is useful as it gives back immediate feedback which can be used to perform calculations and develop code.

//node is typed in the console to access REPL $ node //the > indicates that REPL is running // anything written after > will be evaluated > console.log("HI") // REPL has evaluated the line and has printed out HI HI

Node.js Global Object

The Node.js environment has a global object that contains every Node-specific global property. The global object can be accessed by either typing in console.log(global) or global in the terminal after RPL is running. In order to see just the keys Object.keys(global) can be used. Since global is an object, new properties can be assigned to it via global.name_of_property = 'value_of_property'.

//Two ways to access global > console.log(global) //or > global //Adding new property to global > global.car = 'delorean'

Node.js Process Object

A process is the instance of a computer program that is being executed. Node has a global process object with useful properties. One of these properties is NODE_ENV which can be used in an if/else statement to perform different tasks depending on if the application is in the production or development phase.

if (process.env.NODE_ENV === 'development'){ console.log('Do not deploy!! Do not deploy!!'); }

Node.js process.argv

process.argv is a property that holds an array of command-line values provided when the current process was initiated. The first element in the array is the absolute path to the Node, followed by the path to the file that’s running and finally any command-line arguments provided when the process was initiated.

node web.js testing several features console.log(process.argv[2])// 'features' will be printed

Node.js process.memoryUsage()

process.memoryUsage() is a method that can be used to return information on the CPU demands of the current process. Heap can refer to a specific data structure or to the computer memory.

//using process.memoryUsage() will return an object in a format like this: { rss: 26247168, heapTotal: 5767168, heapUsed: 3573032, external: 8772 }

Node.js Modules

In Node.js files are called modules. Modularity is a technique where one program has distinct parts each providing a single piece of the overall functionality - like pieces of a puzzle coming together to complete a picture. require() is a function used to bring one module into another.

let baseball = require(./babeRuth.js)

Node.js Core Modules

Node has several modules included within the environment to efficiently perform common tasks. These are known as the core modules. The core modules are defined within Node.js’s source and are located in the lib/ folder. A core module can be accessed by passing a string with the name of the module into the require() function.

let http = require('http');

Node.js Local Modules

In Node.js files are considered modules. Modules that are created locally are called local modules. These local modules are held in an object called module. This object has a property called export which allows a module to be accessed in a different module.

// type.js // by using the export property we can use this module in another file module.exports = class key { constructor(car) { this.car = car; } }; // qwerty.js // by requiring the type.js file we can we use the module in the type.js file let Dog = require('./type.js');

Node Package Manager

NPM stands for node-package-manager. An NPM is essentially a collection of code from other developers that we can use. When Node is installed the npm command-line tool is downloaded as well. This command-line tool enables us to interact with the registry via our terminal.

EventEmitter Class

Node.js has an EventEmitter class which can be accessed by requiring the events core module. Each event emitter instance has an .on() method which assigns a listener callback function to a named event. EventEmitter also has an .emit() method which announces a named event that has occurred.

// Require in the 'events' core module let events = require('events'); // Create an instance of the EventEmitter class let myEmitter = new events.EventEmitter(); let version = (data) => { console.log(`participant: ${data}.`); }; // Assign the version function as the listener callback for 'new user' events myEmitter.on('new user', version) // Emit a 'new user' event myEmitter.emit('new user', 'Lily Pad') // 'Lily Pad'

Asynchronous Node.js

Node.js is a non-blocking, asynchronous environment. The event loop in Node.js enables asynchronous actions to be handled in a non-blocking way. Node.js provides APIs which allow operations to be put in a queue, waiting to be executed after the previous operation finishes. If synchronous tasks never end, operations waiting in the event-queue will never execute.

let endgame = () => { console.log('I am inevitable') }; // endgame will run after 1000ms setTimeout(endgame, 1000);

Asynchronous Error Handling

The Node environment has all the standard JavaScript errors as well as the JavaScript Error class for creating new error instances. Many asynchronous Node APIs use error-first callback functions: callback functions which have an error as the first expected argument and the data as the second argument. If the asynchronous task results in an error, it will be passed in as the first argument to the callback function. If no error was thrown, the first argument will be undefined.

Node.js Input/Output

Input is data that is given to the computer, while output is any data or feedback that a computer provides. In Node, we can get input from a user by using the stdin.on() method on the process object. We are able to use this because .on() is an instance of EventEmitter. To give an output we can use the .stdout.write() method on the process object as well. This is because console.log() is a thin wrapper on .stdout.write().

// Recieves an input process.stdin.on(); // Gives an output process.stdout.write();

Filesystem

A filesystem is how you access and organize all data on a computer. The Node.js fs core module is an API for interacting with the file system. Each method available through the fs module has a synchronous version and an asynchronous version. One of the methods in the fs core module is the .readfile() method which allows us to read data from a file.

// First argument is the file path // The second argument is the file’s character encoding // The third argument is the invoked function fs.readFile('./file.txt', 'utf-8', CallbackFunction);

Web Server

Node was designed with back end development needs as a top priority. One of these needs is the ability to create web servers. A web server is a computer process that listens for requests from clients and returns responses. A Node core module designed to meet these needs is the http module. This module has functions that simplify receiving and responding to requests.

const http = require('http');

Creating A Server

http.createServer() is a method that returns an instance of an http.server. The method .listen() in http.server tells the server to “listen” for incoming connections. We give http.createServer() a callback function also known as the requestListener, which will be triggered once the server is listening and receives a request. The requestlistener requests a request object and a response object.

// required in the http core module. const http = require('http'); let requestListener = (request, response) => { // code to be filled in depending on server }; // assigning return value const server = http.createServer(requestListener); // assigning server port server.listen(3000);

Readable/Writable Streams

In most cases, data isn’t processed all at once but rather piece by piece. This is what we call streams. Streaming data is preferred as it doesn’t require tons of RAM and doesn’t need to have all the data on hand to begin processing it. To read files line-by-line, we can use the .createInterface() method from the readline core module. We can write to streams by using the .createWriteStream() method.

// Readable stream readline.createInterface(); // Writtable Stream fs.createWriteStream();

Comments

Post a Comment

Popular posts from this blog

Insertion Sort - Part 2 | C | HACKERRANK

-
In  Insertion Sort Part 1 , you inserted one element into an array at its correct sorted position. Using the same approach repeatedly, can you sort an entire array? Guideline:  You already can place an element into a sorted array. How can you use that code to build up a sorted array, one element at a time? Note that in the first step, when you consider an array with just the first element, it is already sorted since there's nothing to compare it to. In this challenge, print the array after each iteration of the insertion sort, i.e., whenever the next element has been inserted at its correct position. Since the array composed of just the first element is already sorted, begin printing after placing the second element. For example, there are   elements in  . Working from left to right, we get the following output: 3 4 7 5 6 2 1 3 4 7 5 6 2 1 3 4 5 7 6 2 1 3 4 5 6 7 2 1 2 3 4 5 6 7 1 1 2 3 4 5 6 7 Function Description Complete the  insertionSort2  function in the editor below. At ea
Read more

Array Reversal problem solution | C | HackerRank

-
Input Format The first line contains an integer,  , denoting the size of the array. The next line contains   space-separated integers denoting the elements of the array. Constraints , where   is the   element of the array. Output Format The output is handled by the code given in the editor, which would print the array. #include <stdio.h> #include <stdlib.h> int main () { int num , * arr , i ; scanf ( "%d" , & num ); arr = ( int * ) malloc ( num * sizeof ( int )); for ( i = 0 ; i < num ; i ++ ) { scanf ( "%d" , arr + i ); } /* Write the logic to reverse the array. */ int * left_ptr = arr ; int * right_ptr ; int temp ; for ( i = 0 ; i < num ; i ++ ) { if ( i == num - 1 ) { right_ptr = ( arr + i ); } } while ( left_ptr < right_ptr ) { temp = * right_ptr ; * right_ptr = * l
Read more

Insertion Sort - Part 1 | C | HackerRank |

-
Sorting One common task for computers is to sort data. For example, people might want to see all their files on a computer sorted by size. Since sorting is a simple problem with many different possible solutions, it is often used to introduce the study of algorithms. Insertion Sort These challenges will cover  Insertion Sort , a simple and intuitive sorting algorithm. We will first start with a nearly sorted list. Insert element into sorted list Given a sorted list with an unsorted number   in the rightmost cell, can you write some simple code to insert   into the array so that it remains sorted? Since this is a learning exercise, it won't be the most efficient way of performing the insertion. It will instead demonstrate the brute-force method in detail. Assume you are given the array   indexed  . Store the value of  . Now test lower index values successively from   to   until you reach a value that is lower than  ,   in this case. Each time your test fails, copy the value at the
Read more