JavaScript Basics

Question 1

What is JS comment syntax?

Answer 1

// for inline, /* */ for multiline

Question 2

How do we declare a function as a variable?

Answer 2

var addTwoNumbers = function(a, b) {
  return a + b;
};

Question 3

How do we declare a function?

Answer 3

function addTwoNumbers(a, b) {
  return a + b;
}

Question 4

What does a variable declared without the ‘var’ keyword become?

Answer 4

Global in scope.

Question 5

What are the JS primitives (i.e. only things which aren’t objects)?

Answer 5

strings, booleans, numbers, ‘undefined’, and ‘null’

Question 6

What is object literal syntax?

Answer 6

var person = {
firstName : ‘Boaz’,
lastName : ‘Sender’
};

Question 7

When using bracket notation with an object to retrieve the value of a key, what must the key be?

Answer 7

It must be given as a string (with quotes).

Question 8

What is the syntax to declare an object method?

Answer 8

var person = {
  firstName : 'Boaz',
  lastName : 'Sender',
  greet : function(name) {
    log( 'Hi, ' + name );
  }
};

Question 9

What does ‘this’ refer to?

Answer 9

The object that is the context in which the function was called. Note that this is NOT necessarily the context in which the function was defined.

Question 10

What is the JS equivalent of Ruby’s send, and how can it be used to remove ambiguity for ‘this’?

Answer 10

‘.call’ can be used to ensure that ‘this’ is in the context of the original object definition:

var person = {
firstName : ‘Boaz’,
lastName : ‘Sender’,
greet : function(greeting, punctuation) {
log( greeting + ‘, ‘ + this.firstName + punctuation );
}
};

var sayIt = person.greet;

sayIt.call( person, ‘Hello’, ‘!!1!!1’ );

Question 11

What is JS for loop syntax?

Answer 11

for (var loopVar = initialVal; end_condition; increment/decrement){code block per iteration}

Question 12

What are the JS falsy values?

Answer 12

undefined, null, NaN, 0, ‘’ (this last one is an empty string)

Question 13

What will the following code return:

log(‘4’ + 3)

Answer 13

JS is a loosely typed language, meaning mathematical operations with non-number values will NOT throw an error. This means the code will return:

‘43’

Question 14

How can we call a method on each element of an array?

Answer 14

forEach([1, 2, 3], logIfEven);

Question 15

How can we pass an anonymous function?

Answer 15

// **Notice the formatting!**
[1, 2, 3].forEach(function (num) {
  if ((num % 2) == 0) {
    console.log(num);
  }
});

Question 16

Say our cat object has a function as a value for the ‘purr’ key. Can we store this in a variable?

Answer 16

Yes, JS can treat functions/methods like objects:

// extract the function from the object
var catPurrFunction = cat['purr'];
// call the function
catPurrFunction();

Question 17

Why is ‘this’ necessary in the following code:

var cat = {
  purr: function () {
    console.log("meow");
  },

  purr_more: function () {
    for (var i = 0; i

Answer 17

Without this, the method will look for a variable named ‘purr’, which is undefined.

Question 18

What is the JS constructor syntax, and how can we define ivars and methods in the constructor scope?

Answer 18

function Kitten(name, age) {

this. name = name;
this. age = age;

this.meow = function () {
console.log(this.name + ‘ says “meow!”’);
};
}

var kitten = new Kitten(“Earl”, 2);

Question 19

What is the naming convention for constructors?

Answer 19

They should be CamelCased.

Question 20

How do we call a constructor?

Answer 20

With the (required) ‘new’ keyword:

new ClassName(params);

Question 21

What does ‘prototype’ do, and why is it important?

Answer 21

This ensures that all instances that the constructor creates will share the same variable/method instance. This saves a LOT of memory by removing redundancy:

function Kitten(name, age) {
  this.name = name;
  this.age = age;
}

Kitten.prototype.meow = function () {
console.log(this.name + ‘ says “meow!”’);
};

k1 = new Kitten("Earl", 2);
k2 = new Kitten("Houdini", 1);

Question 22

Where are prototype properties stored, and what is the preferred way to access them?

Answer 22

In the .__proto__ property, best accessed through:

Object.getPrototypeOf(instanceName);

Question 23

Why do ivars/methods declared on an instance appear to overwrite the __proto__ property of the same name?

Answer 23

It does not overwrite it; JS checks first to see if the instance has a matching key, and only checks __proto__ if it does NOT find it as a key of the instance:

// error, purr is not defined!
k1.purr();

Kitten.prototype.purr = function () {
console.log(“Purr on, kitten!”);
};

// all of a sudden it works! Because `Kitten.prototype` now has a
// `purr` property, `k1` can purr via its `k1.\_\_proto\_\_` reference to
// `Kitten.prototype`.
k1.purr();

Question 24

What is the difference between the following two method calls:

‘javascript string’.toUpperCase

‘javascript string’.toUpperCase()

Answer 24

Without parentheses we are retrieving the property that belongs to the ‘toUpperCase’ key in the String class, but we are NOT invoking it; we are merely retrieving it, presumable to store it, perhaps as a callback. With parentheses, we retrieve the value in the same manner except we ALSO invoke it:

// retrieving a property that is a function:
'javascript string'.toUpperCase // => function toUpperCase() { [native code] }

// invoking the retrieved function:
'javascript string'.toUpperCase() // => "JAVASCRIPT STRING"

Question 25

Explain scope in JS

Answer 25

Scopes are nested. A new, inner scope is created each time a function is called. The function can refer to this new, current scope, or anything from the enclosing scope.

Question 26

What is a closure?

Answer 26

A function that uses (captures) a variable from an outer scope (a free variable)

Question 27

How can closures be used to pass arguments to a function?

Answer 27

function greetTenTimes(name) {
  _.times(10, function () {
    // captures `name` from outside.
    console.log("Hello, " + name + "!");
  });
}

Question 28

What is JS convention for naming private variables?

Answer 28

Use a leading underscore

Question 29

How can a closure be used to create a private state?

Answer 29

Closing over (capturing) a variable ensures that it cannot be accessed via a key:

function makeCounter() {
  var count = 1;

  return function () {
    return count++;
  };
}

var counterFn = makeCounter();

console. log(counterFn()); // => 1
console. log(counterFn()); // => 2

Question 30

What does placing “use strict”; at the top of a file do?

Answer 30

Throws an error if you forget the ‘var’ keyword (prevents inadvertent creation of global vars).

Question 31

Where are global variables stored?

Answer 31

As keys in a special object (‘global’ in Node.js, ‘window’ in browser)

Question 32

How do we require a module?

Answer 32

You must store it in a variable:

var http = require("http");
OR, for a non-library file include the path:
var myLib = require("./lib");

Question 33

What must we do to have ‘require’ include a function in a file?

Answer 33

Add the following to put the function into a special “module” object which can export:

module.exports.functionName = functionName;