Node Package Manager

• package.json is the file we use to provide npm details about our project/package: dependencies, scripts, etc.
• node_modules is a directory created by npm where our dependencies' code is stored.
  • It should not be checked into version control, as it is easily rebuilt from the npm registry using npm install.

• package.json stores vague package versions - but not specific versions
• package.json can be modified by hand
• package.json can be created by npm init
• package.json stores a range of acceptable dependency versions
• package.lock.json contains the exact package versions that are installed.
• package.lock.json typically is generated.
• package-lock.json stores an exact version
• package-lock.json is installed by npm-install; (and updates package.json)

npm -v or npm --version

npm install -g npm

• npm init //to create a new npm package
• npm install <packageName> //to install the package as a dependency
• let <varName> = require('<moduleName>');

> 1.0.0 indicates "any version above the major version 1" //could be 2.0.0, 4.0.0, 5.1.12

^1.0.0 indicates "any version in the 1.x.x range."

~1.0.0 indicates "any patch version in the 1.0.x range"

1.0.0 indicates "exactly version 1.0.0"

• A dependency is needed for your application to run
• Dev dependencies, such as mocha or chai, are needed for local development and testing

• git clone <RepoURL>
• cd <newDirectory>
• npm install // to install dependencies from package.json and package-lock.json

npm uninstall <moduleName>

• go to npmjs.com and search for a string that closely matches your modules function
• Review the popularity and quality stats to determine the best match

Use npm audit --fix. If the fix requires you to step up to the next major build, you may need to use npm audit --fix --force but be prepared to have to fix other parts of your program.

1. In package.json, under the scripts: key, create a new subkey, naming it.
2. The value of this new key will be your script: "wc -l *.js"
3. Execute the script from the npm cli using npm run <newKeyName>

In JavaScript, a prototype is an object that is delegated to when a reference to an object property or method can't be resolved.

For example, if a property or method isn't available on an object, JavaScript will delegate to the object's prototype to see if that object has the requested property or method. If the property or method is found on the prototype, then the action is carried out on the prototype object. The delegation to the prototype happens automatically, so from the caller's perspective it looks as if the original object had the request property or method.

In JavaScript, you can make an object the prototype of another object. When an object is a prototype of another object, it's properties and methods are made available to the other object.

In ES5 creating a class uses a constructor function

The constructor function is ONLY a constructor. Use Object.setPrototype to create a method for that class.

function Book(title, series, author) {
	if (!(this instanceof Book)) {
		//Throws a custom error when `Book` is called without the `new` keyword
		throw new Error('Book needs to be called with the `new` keyword');
	}
	this.title = title;
	this.series = series;
	this.author = author;
}

Referencing the "new instance" returns undefined.

May be better to add a if (!(this instanceof Book)) { throw new Error('new error' } in the constructor, or if you're uncertain of the object use instanceOf() to make sure before calling the class methods.

A static method is a method that is performed on the class, not the instance of the class. To call a static method you need the class name (not the object) to call it. For instance:

    class MMS {
        constructor (recipient, sender, text, mimeType) {
            this.recipient = recipient;
            this.sender = sender;
            this.text = text;
            this.mimeType = mimeType;
        }
        static getMessagesByMIMEType(messages, mimeType) {
            return messages.filter(m => m.mimeType === mimeType);
        }
    }

    const instance1 = new MMS('555-111-1111', '555-222-2222', 'This is a test message.', 'image/gif');
    const instance2 = new MMS('555-111-1111', '555-222-2222', 'This is a test message.', 'image/gif');
    const instance3 = new MMS('555-111-1111', '555-222-2222', 'This is a test message.', 'image/jpeg');
    const instance4 = new MMS('555-111-1111', '555-222-2222', 'This is a test message.', 'image/gif');

    const messages = [instance1, instance2, instance3, instance4];

    const filteredMessages = MMS.getMessagesByMIMEType(messages, 'image/gif');

    console.log(filteredMessages);

In your child class, you define a static var with the same name as in the parent class, then assign it the value you want.

1. module.exports = { Cat, Dog }
2. module.exports = { specialCat: Cat, specialDog: Dog }

Although you can also export using the exports.specialCat = Cat; or exports.Animal; it's best not to use this syntax as it's easily confused with another Exports

1. module.exports = { Cat, Dog }
const { Cat, Dog } = require('./animals');
2. module.exports = { specialCat: Cat, specialDog: Dog }
const { specialCat, specialDog } = require('./animals');
3. exports.specialCat = Cat; exports.specialDog = Dog;
const { specialCat, specialDog } = require('./animals');
4. exports.Animals
const { Animals } = require('Animals')
   but then you need to reference the other classes as Animal.Cat and Animal.Dog;

#color = "red"; above your constructor. Then when referencing it in your class methods, use this.#color

1. Encapsulation : Combining the behavior (the methods) and the data it works on (ie instance variables).
2. Inheritance: Javascript, in particular, supports implementation inheritance through a mechanism known as prototypal inheritance.
1. Implementation inheritance: The data and methods defined on a parent class are available on objects created from classes that interit from those parent classes.
2. Prototypal inheritance: JavaScript uses prototype objects to make its implementation inheritance actually work
3. Polymorphism: You can treat a variable as if it were one of its parent types, meaning that you can use the methods of a parent class on an object of a child class.
4. Abstraction: Until ES6, JavaScript did not support abstraction. Now, through the use of #<var> you can abstract variables by hiding them from the outside. These vars are only accessible from within the function. Please note: If asked on a quiz - likely abstraction will NOT be one of the pillars of OOP.

The mechanism that puts behavior and data together behind methods that hide the specific implementation of a class.

The mechanism that passes traits of a parent class to its descendants.

The data and methods defined on a parent class are available on objects created from classes that inherit from those parent classes

A method of realizing implementation inheritance through process of finding missing properties on an object by delegating the resolution to a prototype object.

The keyword in JavaScript that allows one class to inherit from another.

The special method of a class that is called to initialize an object when code uses the new keyword to instantiate an object from that class.

Any one of the following:

• A class should do one thing and do it well.
• A class should have only one reason to change.

You can substitute child class objects for parent class objects and not cause errors.

A class is open for extension and closed for modification.

Method names should be grouped together into granular collections called "interfaces"

Functionality that your class depends on should be provided as parameters to methods rather than using new in the class to create a new instance of a dependency.

Don't use more than one dot (not counting the one after "this").

• Methods on the object itself
• Any of the objects passed in as parameters to the method
• An object created in the method
• Any values stored in the instance variables of the object
• Any values stored in global variables.

Through the use of the module.exports property.

Through the use of export

Through the use of the require function.

Through the use of the import-from syntax that looks like this: import SymbolName from './relative-path.js';

Inheritance

The keyword in JavaScript that allows one class to inherit from another.

The special method of a class that is called to initialize an object when code uses the new keyword to instantiate an object from that class.

Implementation inheritance

Prototypal inheritance

The Dependency Inversion Principle

Don't use more than one dot (not counting the one after "this")

The Law of Demeter

Encapsulation

The extends keyword

The constructor method.

The Single-Responsibility Principle

The Liskov Substitution Principle

The Open-Close Principle

The Interface Segregation Principle

The Law Of Demeter

How do CommonJS Modules allow other modules to access exported symbols?

How do ES6 Modules export functionality so other modules can use them?

How can a CommonJS Module import functionality from another module?

How can an ES6 module import functionality from another module?

#4. You can treat an object as an instance of its own class and all of its parent classes (prototypes).

EXPLANATION: Polymorphism allows you to treat the object as its own class or any of its parent classes (prototypes). This allows code that uses the object to take advantage of the behavior that it inherits from its parent classes (prototypes).

#2: A constructor is a method used to initialize the state of an object at the time of object creation.

EXPLANATION: The special method known as a "constructor" provides the object-oriented system a way to initialize the state of an object and ensure all of its information dependencies are met.

#1, #2, #4

EXPLANATION: The representation of the object is like a blueprint for the behavior (methods) and data (fields) that will be associated with and available on the object constructed from the class.

#1 EXPLANATION: JavaScript has implementation inheritance which means that an object will inherit the implementation of the methods and data from its parent classes (prototypes) unless otherwise overridden.

#2: EXPLANATION: Inheritance is a way to write code in methods and share those between other classes to reduce the maintenance cost and promote easy-to-understand code.

#3 EXPLANATION: In JavaScript, the special method named constructor is the method run at the time the object is created.

#3

#4 EXPLANATION: The object-oriented principle of "encapsulation" is the method by which a programmer can provide a simple way to interact with the potentially complex implementation of a concept. Code that uses the simple way needs not know the data types that make up the state of the object nor the implementation of each of the behavioral methods on the class.

#4 EXPLANATION: The ES6 syntax for declaring classes provides the super keyword with which to access methods on a parent class (prototype)

#2 EXPLANATION: The Liskov Substitution Principle has a very mathematically-based definition, but can be interpreted to mean that any method that a class overrides from its parent class must have similar behavior with respect to the original method.

#3 EXPLANATION: The "D" in SOLID is the Dependency Inversion Principle. This is the principle that says a high-level module should not depend on low-level modules but on abstractions, instead. Detailed implementations should rely only on abstractions. This is primarily useful to follow in languages like C++ and Java.

#3 EXPLANATION: The "O" in SOLID is the Open-Close Principle. This is the principle that says a class should be open for extension but closed for modification. This is primarily useful to follow in languages like C++ and Java.

#2 EXPLANATION: The Single-Responsibility Principle means that a class should have only one reason to change. This means that the methods and data in a class reflect one idea and one idea only. This prevents classes from doing too much which drastically lowers the maintainability of the code base.

#2 EXPLANATION: The "I" in SOLID is the Interface Segregation Principle. This is the principle that says a class should implement many cohesive interfaces rather than one combined interface. This is primarily useful to follow in languages like C++ and Java.

The Law of Demeter:
The Law of Demeter requires that an object have the least knowledge about other types. Therefore, it can only call methods on the following kinds of objects:

1. Its own methods (through the this keyword)
2. Methods of objects passed through a parameter
3. An objects created in the method
4. Objects stored in its own data fields
5. Any values stored in global variables

NPM stands for the Node Package Manager, and it is used to refer to a number of different things:

• The npm command line tool, that we use to install and maintain npm dependencies, and projects.
• The npm registry - npmjs.com - the public registry of node js packages that we can search, and explore looking for dependencies.
• The NPM corporation, which writes the npm tool, hosts the registry, etc.

• package.json is the file we use to provide npm details about our project/package: dependencies, scripts, etc.
• node_modules is a directory created by npm where our dependencies' code is stored. It should not be checked into version control, as it is easily rebuilt from the npm registry using npm install.

1. package.json stores vague package versions - but not specific versions, while package-lock.json contains the exact package versions that are installed.
2. package.json can be modified by hand, but package - lock.json typically is generated.
3. package.json can be created by npm init
4. package.json stores a range of acceptable dependency versions, package-lock.json stores an exact version

npm --version [checks what version is currently installed]. Use npm update to update itself to the latest version. Use npm use <version> to use a different version you have installed

1. Use npm init --yes [To create a new package]
2. Use npm install lodash [To install the lodash package.]
3. Use const lodash = require('lodash'); to include this in your JavaScript file
4. Use console.log(loadash.VERSION) to print out the version of loadash
5. Use node index.js to run your index.js file

1. * means literally the newest version
2. 14.16.1 means exactly the version 14.16.1
3. ~14.16.1 will match any package with a matching minor version and a larger patch version
4. ^14.16.1 will match any package with a larger minor and patch version.

16

1

A dependency is required by your app at runtime - it may or may not be needed when doing testing, or during development.

A development dependency is only required by your app at development time. Common development dependencies are testing libries like chai.

1. git clone <some_repo>
2. npm install

npm uninstall <dependency package name>

npm lodash@latest

Go to npmjs.com; Search for packages. Consider the following:

1. Does the API handle the task you need to accomplish?
2. Does the project have a significant number of downloads?
3. In version control, are there recent commits, issues, pull requests?
4. When was the last version released?

use npm audit --fix. If you have to update to a different build, beware that this could impact other portions of your code. However, if you're certain this is what needs to be done, use npm audit --force and be ready for warning messages.

1. In package.json, under the scripts: key, create a new key with your script name
2. The value of this new key will be your script.
3. To run the script, use npm run <scriptKeyName>

function Apartment(address, bedrooms, baths) {
    this.address = address;
    this.bedroom = bedrooms;
    this.baths = baths;
}
                        

    Apartment.prototype.printListing = function() {
        console.log(`This fabulous ${this.bedrooms} bedroom apartment,
             located at ${this.address} has ${this.baths} luxuriant
             bathrooms for all your evacuating needs.`);
    }
                        

    const apt = new Apartment('1987 Squirtle Ave', 2, 2);

    apt.printListing();
                        

class Apartment {
    constructor(address, bedrooms, baths) {
        this.address = address;
        this.bedrooms = bedrooms;
        this.baths = baths;
    }
}
                        

class Apartment {
    constructor(address, bedrooms, baths) {
        this.address = address;
        this.bedrooms = bedrooms;
        this.baths = baths;
    }

    printListing() {
        console.log(`This fabulous ${this.bedrooms} bedroom apartment,
        located at ${this.address} has ${this.baths} luxuriant
        bathrooms for all your evacuating needs.`);
    }
}
                                                

class Apartment {
    //Somewhere in the class

    static compareTwo(apartment1, apartment2) {
        if (apartment1.bedrooms - apartment2.bedrooms > 0{
            return apartment1;
        } else if (apartment1.bedrooms - apartment2.bedrooms < 0) {
            return apartment2;
        } else {
            return apartment1;
        }
    }
}

apartment1 = new Apartment('1987 Squirtle Ave', 2, 2);
apartment2 = new Apartment('2000 Wilougby Way', 3, 2);
                        

Apartment.compareTwo(apartment1, apartment2);

class BuildingUnit {
    //stuff here ..
}

class Apartment extends BuildingUnit{
    // Stuff here ..
}                                            

The first call in your constructor MUST be to the parent, before you use your "this" operator.

super(<Variable1, Variable2, ...>)

JavaScript has an implicit constructor. IF your child class has a constructor, BUT your parent class has no constructor, you still MUST call super() with no arguments before using the "this" operator.

CHECK THIS OUT ... I'm not sure of this answer because of the "this" operator.

You overwrite the global exports. You need to use your exports as follows: exports.Apartment = Apartment

This form is not recommended to use, as it is easily confused with the ES6 "export" keyword. So by using module.exports it's planly clear your module is a commonJS module.

This locks us into only ever being able to export a single thing. Better to use: module.exports = { Apartment: Apartment}. Now you're setting the exports keyword as an object, rather than a literal value.

    module.exports.Apartment = Apartment;
    module.exports.littleApartment = Apartment
    module.exports = {
        littleApartment : Apartment
    }
    module.exports = {
        Apartment
    }

                        

Note: You can export many classes, functions from a file when using the object notation module.exports = { }