JS

Question 1

Getters

Answer 1

Getters are methods that get and return the internal properties of an object

Question 2

how to use type of

Answer 2

typeof 37 === ‘number’;

Different types: number, undefined, object, boolean, string, symbol, function

Question 3

Setters

Answer 3

methods which reassign values of existing properties within an object. Let’s see an example of a setter method:

Question 4

How to turn an integer to a string?

Answer 4

.toString()

Question 5

How to turn a string into an integer?

Answer 5

Number(x)

Question 6

How to use a getter

Answer 6

from a ‘get’ variable in the object.

console.log(robot.getLevel);

Question 7

How to use a setter

Answer 7

from a ‘set’ variable in the object

robot.getLevel = 100;

Question 8

What is a state?

Answer 8

A program’s state is its current condition in regards to stored memory, variables, etc. It’s state can change over time as new input is added or data is manipulated in some way.

Question 9

What is recursion?

Answer 9

Recursion is when a function calls upon itself until it reaches some sort of base case.

Question 10

What is routing?

Answer 10

SPAs are based on a single document model. This means that web applications’ lifespan happens on a single html page, along with the transitions between the different views. But since links no longer imply the fetching and generation of a new document, how are those transitions modelled? they are achieved by using a router.
What is a Javascript Router?

A Javascript router is a key component in most frontend frameworks. It is the piece of software in charge to organize the states of the application, switching between different views. For example, the router will render the login screen initially, and when the login is successfull it will perform the transition to the user’s welcome screen.

Question 11

What is abstraction?

Answer 11

Abstraction is a method for arranging complexity of systems. Abstraction contains complexity to create building blocks which are easier to expand upon.

Question 12

encapsulation

Answer 12

Encapsulation is the process of restricting direct access to data or objects. Instead, methods are created to access this data or objects.

Question 13

polymorphism

Answer 13

The ability to create a variable function or object that has more than one form. With polymorphism the program responds correctly depending on input type.

Question 14

How to get object keys

Answer 14

Object.keys(obj1)

Question 15

How to get an array of key value pairs of an object

Answer 15

Object.entries(obj1)

Question 16

How to add more key value pairs to an existing object

Answer 16

const newRobot = Object.assign(robot, {laserBlaster: true, voiceRecognition: true});

Question 17

The “for…in” loop

Answer 17

for (key in object) {
  // executes the body for each key among object properties
}

For instance, let’s output all properties of user:

let user = {
  name: "John",
  age: 30,
  isAdmin: true
};

for (let key in user) {
  // keys
  alert( key );  // name, age, isAdmin
  // values for the keys
  alert( user[key] ); // John, 30, true

Question 18

Classes

Answer 18

Classes are a tool that developers use to quickly produce similar objects. Serves as a template for creating new objects.

Question 19

Difference between class and object syntax?

Answer 19

there is one important method that sets them apart. It’s called the constructor method. JavaScript calls the constructor() method every time it creates a new instance of a class.

class Dog {
  constructor(name) {
    this.name = name;
    this.behavior = 0;
  }
}

Question 20

create new object from class

Answer 20

const halley = new Dog(‘Halley’);

Question 21

What is inheritance

Answer 21

With inheritance, you can create a parent class (also known as a superclass) with properties and methods that multiple child classes (also known as subclasses) share. The child classes inherit the properties and methods from their parent class.

Question 22

What is a constructor?

Answer 22

The constructor method is a special method for creating and initializing an object created within a class.

Question 23

How do you make a class?

Answer 23

class Cat { }

Question 24

How do you make a constructor in a class?

Answer 24

class Cat {
  constructor(name, usesLitter) {
    this._name = name;
    this._usesLitter = usesLitter;
    this._behavior = 0;
  }
}

Question 25

Why use inheritance?

Answer 25

Because children can inherent properties from their parents it is a way of reducing code. One benefit is that when you need to change a method or property that multiple classes share, you can change the parent class, instead of each subclass.

Question 26

What are methods?

Answer 26

Methods are properties of an object that hold function values

Question 27

How to create a child class?

Answer 27

class Cat extends Animal {
  constructor(name, usesLitter) {
    super(name);
    this._usesLitter = usesLitter;
  }
}

Question 28

When making a child class where does super go?

Answer 28

In a constructor(), you must always call the super method before you can use the this keyword — if you do not, JavaScript will throw a reference error. To avoid reference errors, it is best practice to call super on the first line of subclass constructors.

Question 29

What is a static method?

Answer 29

methods that aren’t available in individual instances, but that you can call directly from the class.

Take the Date class, for example — you can both create Date instances to represent whatever date you want, and call static methods, like Date.now() which returns the current date, directly from the class. The .now() method is static, so you can call it directly from the class, but not from an instance of the class.

Question 30

What is the static method syntax?

Answer 30

static generateName() {
    const names = ['Angel', 'Spike', 'Buffy', 'Willow', 'Tara'];
    const randomNumber = Math.floor(Math.random()*5);
    return names[randomNumber];
  }

Question 31

return a random number between 0 and 10000

Answer 31

return Math.floor(Math.random() * 10001;

Question 32

What is package.json?

Answer 32

A package.json file contains information about the current JavaScript project. Some of this information includes:

Metadata — This includes a project title, description, authors, and more.
A list of node packages required for the project — If another developer wants to run your project, npm looks inside package.json and downloads the packages in this list.
Key-value pairs for command line scripts — You can use npm to run these shorthand scripts to perform some process. In a later exercise, we will add a script that runs Babel and transpiles ES6 to ES5.

If you have Node installed on your computer, you can create a package.json file by typing npm init into the terminal.

Question 33

What does the -D do? In npm install babel-cli -D

Answer 33

The -D flag instructs npm to add each package to a property called devDependencies in package.json. Once the project’s dependencies are listed in devDependencies, other developers can run your project without installing each package separately. Instead, they can simply run

Question 34

What does npm install do?

Answer 34

it instructs npm to look inside package.json and download all of the packages listed in devDependencies.

Question 35

How to create a package.json file?

Answer 35

From the terminal, run npm init and type the above values

Question 36

What are JavaScript modules?

Answer 36

JavaScript modules are reusable pieces of code that can be exported from one program and imported for use in another program.

Question 37

What are the pros of modules?

Answer 37

Modules are particularly useful for a number of reasons. By separating code with similar logic into files called modules, we can:

find, fix, and debug code more easily;
reuse and recycle defined logic in different parts of our application;
keep information private and protected from other modules;
and, importantly, prevent pollution of the global namespace and potential naming collisions, by cautiously selecting variables and behavior we load into a program.

Question 38

How do you export a module?

Answer 38

module.exports = Menu;

Question 39

How to import a module in ES5?

Answer 39

const Menu = require(‘./menu.js’);

Question 40

What is an anonymous function?

Answer 40

Anonymous functions are functions that are dynamically declared at runtime. They’re called anonymous functions because they aren’t given a name in the same way as normal functions.

Anonymous functions are declared using the function operator instead of the function declaration. You can use the function operator to create a new function wherever it’s valid to put an expression. For example you could declare a new function as a parameter to a function call or to assign a property of another object.

Here’s a typical example of a named function:

    function flyToTheMoon()
    {
      alert("Zoom! Zoom! Zoom!");
    }
    flyToTheMoon();

Here’s the same example created as an anonymous function:

    var flyToTheMoon = function()
    {
      alert("Zoom! Zoom! Zoom!");
    }
    flyToTheMoon();

Question 41

In ES6 what are the two new ways for exporting modules?

Answer 41

default export and named exports.

We’ll begin with the first syntax, default export. The default export syntax works similarly to the module.exports syntax, allowing us to export one module per file.

Let’s look at an example in menu.js.

let Menu = {};

export default Menu;

named exports allow us to export data through the use of variables.

Let’s see how this works. In menu.js we would be sure to give each piece of data a distinct variable name:

let specialty = '';
function isVegetarian() {
}; 
function isLowSodium() {
}; 

export { specialty, isVegetarian };

Question 42

How do you import in ES6?

Answer 42

import Menu from ‘./menu’;

Question 43

How can you change the name of modules as you export or import them?

Answer 43

Named exports also conveniently offer a way to change the name of variables when we export or import them. We can do this with the as keyword.

Let’s see how this works. In our menu.js example

let specialty = '';
let isVegetarian = function() {
}; 
let isLowSodium = function() {
}; 

export { specialty as chefsSpecial, isVegetarian as isVeg, isLowSodium };

Question 44

How to throw an error

Answer 44

throw new Error(‘Request failed!’);