Scope and Closures

Question 1

What does nested scope look like?

Answer 1

function foo(a) {
	console.log( a + b );
}
var b = 2;
foo( 2 ); // 4

The RHS reference for b cannot be resolved inside the function foo, but it can be resolved in the Scope surrounding it (in this case, the global).

Question 2

What does a += 2 represent?

Answer 2

a = a +2

Question 3

How are variable constraints written?

Answer 3

EX: TAX_RATE

Question 4

What is Lexical Scope

Answer 4

lexical scope is based on where variables and blocks of scope are authored, by you, at write time, and thus is (mostly) set in stone by the time the lexer processes your code.

Question 5

Operator that displays the type of something

Answer 5

typeof

ex: a = ‘the’
typeof a // string

Question 6

What is an array?

Answer 6

an object w/o properties/keys but indexed positions

Question 7

Name all of the falsy values

Answer 7

" " empty string
0, -0 NaN (invalid numbers)
Null
Undefined
False

Question 8

What is the difference? == and ===

Answer 8

== checks for value equality w/ coercion allowed
and
=== checks for value equality w/o allowing coercion

Question 9

method to specify the number of decimal places and what does it return?

Answer 9

toFixed()
ex:
amount = 10.97777
amount.toFixed(2)
// '10.97'

Question 10

When to use a switch statement?

Answer 10

Can be used instead of many if, else if statements

Question 11

How to execute a function immediately

Answer 11

place function in ():

ex: (function (){
do something})();

Question 12

What is closure

Answer 12

Closure is when a function is able to remember and access its lexical scope even when that function is executing outside its lexical scope.
ex:
function foo() {
	var a = 2;
	function bar() {
		console.log( a );
	}
	return bar;
}

var baz = foo();
baz(); // 2 -- Whoa, closure was just observed, man.

Question 13

Example of closure

Answer 13

function wait(message) {
	setTimeout( function timer(){
		console.log( message );
	}, 1000 );
}
wait( "Hello, closure!" );

We take an inner function (named timer) and pass it to setTimeout(..). But timer has a scope closure over the scope of wait(..), indeed keeping and using a reference to the variable message.

A thousand milliseconds after we have executed wait(..), and its inner scope should otherwise be long gone, that inner function timer still has closure over that scope.

Question 14

What are modules

Answer 14

Most common used of closure. Modules let you define private variables/functions that are hidden from the outside world

Question 15

What is Polyfilling

Answer 15

Taking the definition of a newer feature and producing a piece of code that equivalent to behavior but is able to run in an older js environment

Question 16

What is Transpiling

Answer 16

A tool that converts newer code into older code equivalents

Question 17

What is state

Answer 17

ability to store values in variables and later retrieve or modify these values

Question 18

What is the difference between Reference error vs Type error

Answer 18

Ref is an error in scope

Type error is an error with the wrong value: null, undefied, etc.

Question 19

LHS/RHS

Answer 19

Left handed side lookup: the target of the assignment

Right handed side lookup: the source of the assignment

Question 20

Hoisting

Answer 20

Variable and function declarations are moved via the compiler from where they appear in code to the top.

assignments and executibles are left in place

Question 21

Two mechanisms that cheat lexical scope and why not to use them

Answer 21

eval(..)
with
The downside is that they defeat the enigne’s ability to perform compile-time optimizations regarding scope look-up. Code will run slower a result

Question 22

Anonymous functions vs named functions

Answer 22

function (){
do something}
anonymous func are quick/easy to type

difficult to debug
recursion is difficult
not as readable