General

Question 1

Compiler

Answer 1

• Converts code from one language to another
• Generally converts from a higher level language to a lower level language

Question 2

Linker

Answer 2

• combines the various files produced by compiler
• generates executable code that computer actually interacts with

Question 3

statement vs expression

Answer 3

• expression is a unit of code that returns a value
  
  • a = 1 (returns a)
  • a == True
• statement is a unit of code that just does work
  
  • doesn’t return a value
  • if statement, for loop

Question 4

Lexical Environment

Answer 4

• The location of code within a program
• For example, a variable might sit lexically inside a function

Question 5

Object

(in Javascript)

Answer 5

• A collection of key/value pairs

Question 6

Execution Context

Answer 6

• The environment/state of a function that is created by involking a function
• A new execution context is created every time a function is invoked
• Includes
  
  1. the variables in scope
  2. function arguments
  3. the this variable (the context)

Question 7

Lexical Scoping

Answer 7

• Also called compile-time scoping
• The scope of all variables is determined at compile time, by the location of the variables
• Basically normal scoping
• Most languages (including JS) have lexical scoping

Question 8

Hoisting

Answer 8

• Process of allocating memory for variables and functions during the compilation phase
• Or, the process of “moving declarations” to the top of the current scope

Three scenarios during compilation phase:

1. Variable Names
   
   • Are put into memory
   • Declarations are hoisted, but variables are set to undefined
   • Naked variables (variables without a keyword) are not hoisted
2. Functions Declarations
   
   • Are put into memory
   • They are hoisted, and can be used before being explictly defined
3. Function Expressions
   
   • Names are put into memory, set to undefined
   • Using function expressions before defining them throws a TypeError

Question 9

undefined

Answer 9

• a primative type
• a special value that is automatically assigned to variables upon declaration
• Indicates that a variable has not been given a value yet

Question 10

single threaded

Answer 10

• One command is being executed at a time

Question 11

synchronous

Answer 11

• Tasks are completed in order
• JavaScript itself is synchronous, but it can make callback requests and create asynchronous behavior

Question 12

asynchronous

Answer 12

• asynchronous code allows you to start something now and finish it later
• does not have to complete tasks in order

Question 13

let

Answer 13

• Variable keyword
• New to EC6
• Allows you to create variables whose scope is just a block
  
  • things with curly braces
  • if statements, for loops, etc.
• let variables are hoised, but…
  
  • are hoisted: replace any reference to variables in outer scope
  • but, using let variable before initialization throws a reference error, as opposed to undefined with var
• Syntax

Example (in an if statement):

console.log(c)

let c = 100

*Throws a reference error, even if c was already defined outside of block

Question 14

const

Answer 14

• variable keyword
• new to ES6
• like let, they create block-scoped variables
• however, variables cannot be reassigned
  
  • primative variables cannot be changed
  • variables set to objects can be changes, but not reassigned

Question 15

Event Handling

in JavaScript

Answer 15

• JS only processes events when execution stack is empty

Question 16

dynamic typing

Answer 16

• type of variable is determined at runtime (versus compile time)

Question 17

Primative Types

(JavaScript)

Answer 17

• a built in data type
• data that is not an object and has no methods
• all primitives are immutable
• all primatives (except null and undefined) have object wrappers

6 Primative Types

1. undefined
2. null
3. boolean
4. number
   
   • only one ‘number’ type in JS
   • it’s a floating point number
5. string
6. symbol
   
   • New to ES6

Question 18

operators

Answer 18

• operators are basically normal functions with special syntax

Question 19

infix notation

Answer 19

• notation that places operators between operands
• ex: +, -, <, >

Question 20

associativity

Answer 20

• order in which functions (operators) are invoked when functions have same precedence
• either left-to-right or right-to-left
• ex: + is left-to-right, but = is right-to-left

Question 21

coersion

Answer 21

• when JS implicity converts a variable from one data type to another

Question 22

== vs ===

Answer 22

• double equals
  
  • tests for loose equality (abstract equality)
  • uses type coersion
• triple equals
  
  • tests for strict equaliy
  • does not use type coersion
  • should always default to triple equals

Question 23

giving default value to parameters

Answer 23

• syntactic trick to give parameter default values in functions
• Logical Or the variable with another value
• This will initialize a variable if it is undefined
• ex: name = name || ‘Greer’

Question 24

JSON vs JS

Answer 24

• All JSON is valid JS
• But not all JS is valid JSON
• JSON requires double quotes around keys and values
• And doesn’t allow functions as values

Question 25

first class citizens

(first class functions)

Answer 25

• first class citizens are types/objects that support all the operations that other types support
• first class functions are functions that are first class citizens
• functions that can do everything that other types can
  
  • assign them to variables
  • pass them as arguments
  • create them on the fly

Question 26

pass by value

pass by reference

Answer 26

2 situations

• b is set to a (b = a)
• a is passed to a function b

pass by value

• b makes its own copy of the data and places it somewhere else in memory
• primitives are passed by value in JS

pass by reference

• b simply points to the same location in memory that a does
• causes one object to have two names
• objects passed as parameters can be changed by function they were passed to
• objects (including functions) are passed by reference in JS

Question 27

arguments object

Answer 27

• special variable created in each function automatically during compilation phase
• a list of all parameters that were passed to a function
• list is array-like (an object with array like properties)

Question 28

Immediately Invoked Function Expressions

(IIFE)

Answer 28

• also known as self-invoking anonymous functions
• programming idiom that allows functions to invoke themselves
• IIFE’s have their own scope and execution context

2 situations

• function expressions
  
  1. Simply add invokation parens after writing expression
  2. Arguments can go in invokation parens
  3. But you can also wrap function in parens if you want, a la function declarations
  4. Function can be named or anonymous
• function declarations
  
  1. Wrap function in paratheses to turn it into expression
  2. And then place invokation parens at end of new expression
     
     • Can place parens inside or outside of wrapper
     • (function() { … })(); ⇔
       (function() { … }());
  3. Arguments go in parens
  4. Function can be named or anonymous

Question 29

closures

Answer 29

• The ability of a function to remember and access its lexical scope even when invoked in a different lexical environment
• All functions have this ability automatically
• Often used when an outer function returns an inner function
• That inner function can continue to use varaibles local to the outer function even after the outer function as been run and completed
• It can even change variables in the bygone lexical scope and access these changes

Question 30

callback function

Answer 30

• a function that gets passed to another function and triggered by an event

Question 31

this keyword

Answer 31

• this binding is automatically defined in an execution context

4 situations

1. Default Binding
   
   • By default, this is always bound to the global object (even when function is defined within another object)
   • Or bound to undefined in “strict mode”
2. Invoked with an object
   
   • The this value becomes the object that involked a function
   • ex: obj1.func() –> the this inside func’s execution context is now obj1
3. If new keyword is used
   
   • this binding is new, empty object
   • even true even after using bind, call or apply
4. arrow functions
   
   • this bindng equals whatever this was in lexical scope
   • even if function is involked with an object
   • even after using bind, call or apply

Question 32

bind

Answer 32

• Method automatically avalable to every function
• Duplicates a function with permanent parameters
• Used to recreate function with a new, fixed value of this, as well as fixed values for other args
• Syntax

var myFuncTwo = myFunc.bind(newthis, arg1, arg2)

Question 33

call, apply

Answer 33

• Automatically built in to every function
• Allow you to manually set value of this when invoking a function
• Both can be used on IIFEs
• Sytax of each differs slightly

call Syntax

myFunc.call(ctx, var1, var2)

• separate arguments with commas [call ⇒ commas]

apply Syntax

myFunc.apply(ctx, [var1, var2])

• include additional parameters in an array [apply ⇒ array]

Question 34

strict mode

Answer 34

• Tells engine to implement extra, stricter rules when processing code
• Not all engines implement strict mode the same way
• Must go at top of execution context (top of file, top of function)
• Rules include:
  
  • does not allow global object to be bound to this
  • does not allow naked variables
  • cannot name a variable “arguments”

Sytanx

• “use strict”;

Question 35

inheritance

Answer 35

• one object gets access to the properties and methods of another object

Question 36

For Loops in JavaScript

Answer 36

4 Ways

1. for loop (normal)
2. for…in
   
   • loops through all the immediate keys in an object
   • not ideal for arrays; will return any arbitrary properties added to array object
   • for (key in obj) { }
   • for inoperative objects
3. for…of
   
   • for loop designed specifically for iterables (Arrays, Strings, Maps, Sets)
   • Loops over elements, but skips arbitrary key/value properties
   • for (val of arr) { }
   • for affirmative arrays
4. Array.prototype.forEach
   
   • part of array prototype
   • runs some function using elements in array in input
   • arr.forEach(callback(current, index, array), theThis)
     
     • passing the this binding is optional

Question 37

Removing elements from an array

Answer 37

3 Approaches

1. Array.prototype.pop()
   
   1. Removes the last element in the array
   2. Changes array
2. Array.prototype.shift()
   
   • Removes the first element of the array
   • Changes array
3. Array.prototype.splice(start, delNum, item1, item2)
   
   • Removes delNum # of elements starting from index ‘start’
   • If delNum is ommitted, removes all elements from (and including) start to end
   • Will insert additional arguments after delNum if included

Question 38

hasOwnProperty

Answer 38

• part of the Object prototype
• returns true if a property is defined on the object itself (rather than prototype chain)
• myObj.hasOwnProperty(prop)

Question 39

typeof

instanceof

Answer 39

• typeof
  
  • tells you what type something is
  • NOTE: typeof null is object, widely considered to be a bug
• instanceof
  
  • tells you if an object is an instance of a constructor
  • myObj instanceof myFunc
  • returns True if myObj’s __proto__ (or any of its parents __proto__’s) points to myFunc.prototype

Question 40

[[]]

double square brackets

Answer 40

• double square brackets denotes that an “internal property”
• property is hidden or read-only
• cannot be accessed/edited by the user
• however, may be exposed through another method/property
• ex:
  
  • [[Prototype]] and __proto__

Question 41

Transpile

Answer 41

• A specific version of compilation
• To transform code from one language to another language with a similar level of abstraction

Question 42

TypeScript

Answer 42

• a version of JavaScript that is class-based and statically typed

Question 43

web workers

Answer 43

• a javascript process that has been delegated ot the background
• does not interfere with performance of the webpage
• doesn’t have access to document, cannot do DOM manipulation
• workers can spawn other workers