NodeJS Basics.txt

Node + React = Front End (Web/App)
Node + Express = Back End (Web Service)
Node + React Native = Mobile App

Package Management
------------------------------

{root_of_project_folder}$ npm init -y // answers yes with all defaults and
generates baseline package.json file 

npm config set prefix <user-home-dir> // this ensures that modules installed with -g flag will not require sudo to install as they will be installed in the dir you desire

npm install // install all modules listed in package.json
npm i <package> // installs a specific package locally to the project
npm i <package> -g // installs package globally
npm i <package> --save-dev // saves module under the "devDependecies" section

npm i -g yarn 

yarn --version
yarn global bin
yarn add <package_name>
yarn global add <package_name>
Yarn add <package> --dev

npm root -g
npm list -g --depth=0 // get list of all globally installed packages
yarn global list

**It is best to avoid global modules as much as possible. Define everything at the project level so that if I am collaborating with someone on a project they will find everything they need in package.json. Items that are installed globally do not show up in package.json therefore it can be problematic. Also defining things at the project level allows me to use specific versions of things based on my application needs. Global modules force me to use one version for multiple projects

Debug
---------

Insert "debugger" anywhere in your code (this will act as a breakpoint in the debug session)
$ node inspect app.js // inspect command spawns a debug session and sends it to the Chrome Browser
Open up Chrome > hit URL chrome://inspect
Inspect the current session that you spawned in step 1

Web Servers
------------------

[Live-Server]
yarn global add live-server
npm i -g live-server

{root_of_project_folder}$  live-server [folder to serve up]
{root_of_project_folder}$  live-server public/

[Express]


Classes
--------

class Person {
    constructor(name = 'Anonymous', age = 0) {
        this.name = name
        this.age = age
    }

    getGreeting() {
        return `Hello my name is ${this.name}!`
    }

    getDescription() {
        return `Hello my name is ${this.name} and I am ${this.age} years old!`
    }
}

class Student extends Person {
    constructor(name, age, major) {
      super(name, age) // call superclass constructor for name and age property
      this.major = major
    }

    hasMajor() {
        return this.major
    }

    getDescription() {
        let description = super.getDescription() // call superclass getDescription method

        if(this.hasMajor()) {
            description = description + ` My major is ${this.major}!`
        }

        return description
    }
}

const low = new Person("Low", 29)
console.log(low.getGreeting())


const other = new Person()
console.log(other.getGreeting())





Functions
---------

[Standard]

[Arrow]


Callback Functions
-------------------------

const geocode = (address, callback) => {
  setTimeout(() => {
    data = {
      latitude: 0,
      longitude: 0
    }
    callback(data) // define the data I want to return to the function
  }, 2000)
}

geocode('TempleHills',(data) => { // data is the variable I want to access when I call the function geocode
  console.log(data)
})

- A callback function is a function that we provide as an "argument" to another function with the expectation that the original function is going to call that function sometime in the future
- When a function is doing a synchronous operation, we can use the keyword "return" to have the data returned to the function that is being called. 
- When a function is doing an asynchronous operation, the "return" keyword is not an option. I must use the "callback" method in order to access that data (when it becomes available)



Promises
--------



Async/Await
------------



Statement Format
-------------------

var square = (argument) => {
  var result = x * x;
  return result;
  };

console.log(square(9));


Expression Format
--------------------------

var square = (x) => x * x; 
// Simplifies our code and makes it easier to scan
// I also don't need to specify "return" keyword; it is already implied

var square = x => x * x;
// When I am accepting only 'one' argument then I don't have to wrap the variable in ()


var user = {
  name: 'Andrew',
  sayHi: () => {
   console.log(`Hi`);
  }
}

// How to use arrow function and reference an object literal (this.property)
var user = {
  name: 'Andrew',
  sayHi: () => {
  console.log(`Hi ${this.name`); // this will not work with arrow functions
  },
  sayHiAlt () { // this is the correct way
    console.log(`Hi ${this.name}`); 
  }
}

user.sayHiAlt()