Ad. Javascript.info part 2

Question 1

let name = “John”;

function sayHi() {
  alert("Hi, " + name);
}

name = “Pete”;

sayHi(); // returns

Answer 1

“hi pete”

Question 2

const name = “John”;

function sayHi() {
  alert("Hi, " + name);
}

name = “Pete”;

sayHi(); // returns

Answer 2

error

Question 3

function makeWorker() {
    let name = "Pete";

    return function() {
      alert(name);
    };
  }

let name = “John”;

  // create a function
  let work = makeWorker();

  // call it
  work();

Answer 3

Pete

Question 4

In JavaScript, every running function, code block {…}, and the script as a whole have an internal (hidden) associated object known as the _________

Answer 4

Lexical Environment.

Question 5

The Lexical Environment object consists of two parts:

Answer 5

1. Environment Record – an object that stores all local variables as its properties (and some other information like the value of this).
2. A reference to the outer lexical environment, the one associated with the outer code.

Question 6

First, when a function runs, a new function _____________ Environment is created automatically. That’s a general rule for all functions.

Answer 6

Lexical

Question 7

When the code wants to access a variable – the inner Lexical Environment is searched first or the global one.

Answer 7

inner Lexical Environment

Question 8

Without using _______ , an assignment to an undefined variable creates a new global variable, for backwards compatibility.

Answer 8

strict

Question 9

a new function Lexical Environment is created each time a function runs.

TRUE / FALSE

Answer 9

TRUE

Question 10

“Lexical Environment” is a specification object. We CAN OR CAN’T get this object in our code and manipulate it directly.

Answer 10

can’t

Question 11

A function is called _______ when it is created inside another function.

Answer 11

“nested”

Question 12

a nested function can be returned: either as

Answer 12

a property of a new object or as a result by itself.

Question 13

function User(name) {
    this.sayHi = function() {
      alert(name);
    };
  }

  let user = new User("John");
  user.sayHi();

Answer 13

John

Question 14

IS EACH COUNT OBJECT independent?

function makeCounter() {
    var count = 0;

    return function() {
      return count++; // has access to the outer "count"
    };
  }

let counter = makeCounter();

alert( counter() ); // 0
alert( counter() ); // 1
alert( counter() ); // 2

Answer 14

yes

Question 15

function makeCounter() {
  let count = 0;
  return function() {
    return count++;
  };
}

let counter1 = makeCounter();
let counter2 = makeCounter();

alert( counter1() ); //
alert( counter1() ); //
alert( counter2() ); //

Answer 15

0
1
0 (independent)

Question 16

All functions “on birth” receive a hidden property _________ with a reference to the Lexical Environment of their creation.

Answer 16

[[Environment]]

Question 17

[[Environment]] is hidden

TRUE / FALSE

Answer 17

TRUE

Question 18

All functions get the [[Environment]] property that references the Lexical Environment in which they were made.

TRUE / FALSE

Answer 18

TRUE

Question 19

function sayHi() {
  alert("Hi, " + name);
}
let name = "John";
let name = "Pete"; 

sayHi(); // ——>

Answer 19

Error

let is already declared

Question 20

function sayHi() {
  alert("Hi, " + name);
}
let name = "John";
var name = "Pete"; 

sayHi(); // ——>

Answer 20

Error

let is already declared

Question 21

A closure is _____

Answer 21

a function that remembers its outer variables and can access them. All functions in JavaScript are closures

Question 22

let phrase = “hello”;

if (true) {
  let phrase = "yikes";
  alert (phrase);
}

Answer 22

yikes

Question 23

let phrase = “hello”;

if (true) {
  let user = "33333";
  alert (`${phrase} + ${user}`);
}

Answer 23

hello + 33333

Question 24

let phrase = “hello”;

if (true) {
  let user = "33333";
}

alert(user);

Answer 24

error: user not defined

Question 25

let phrase = "hello"; ``` if (true) { let user = "33333"; } ``` alert(phrase);

Answer 25

hello

Question 26

``` for (let i = 0; i < 10; i++) { // {i: value} } ``` alert(i); //

Answer 26

Error, no such variable

Question 27

``` { let message = "Hello"; } ``` alert(message); //

Answer 27

Error: message is not defined

Question 28

In the past, there were no block-level lexical environment in JavaScript. So programmers had to invent something. And what they did is called _________

Answer 28

“immediately-invoked function expressions” (abbreviated as IIFE).

Question 29

THIS IS AN EXAMPLE OF ____ ``` (function() { let message = "Hello"; alert(message); // Hello })(); ```

Answer 29

immediately-invoked function expressions” (abbreviated as IIFE).

Question 30

WHAT IS THIS CALLED? AND WHAT IS HAPPENING AT RUNTIME? ``` (function() { let message = "Hello"; alert(message); // Hello })(); ```

Answer 30

Here a Function Expression is created and immediately called. So the code executes right away and has its own private variables

Question 31

``` (function() { ( let message = "Hello"; alert(message); })(); ``` //returns?

Answer 31

Hello

Question 32

``` function() {( let message = "Hello"; alert(message); }(); ```

Answer 32

ERROR

Question 33

4 WAYS TO MAKE IIFE ``` function() { let message = "Hello"; alert(message); }() ```

Answer 33

1. "Parentheses around the function" 2. "Parentheses around the whole thing" 3. "Bitwise NOT operator starts the expression") 4. "Unary plus starts the expression"

Question 34

three ways of variable declaration:

Answer 34

Let, var, const

Question 35

the variables _______ and______ behave exactly the same way in terms of Lexical Environments.

Answer 35

let | const

Question 36

the variable ______ has no block scope

Answer 36

var

Question 37

``` function sayHi() { var phrase = "Hello"; alert(phrase); } ``` sayHi(); // returns

Answer 37

Hello

Question 38

______ variables are either function-wide or global, they are visible through blocks.

Answer 38

var

Question 39

``` if (true) { var test = true; } alert(test); // returns? ```

Answer 39

true

Question 40

``` if (true) { let test = true; } alert(test); // returns? ```

Answer 40

error

Question 41

``` for (var i = 0; i < 10; i++) { // ... } alert(i); ```

Answer 41

10, "i" is visible after loop, it's a global variable

Question 42

``` for (let i = 0; i < 10; i++) { // ... } ``` alert(i);

Answer 42

error

Question 43

``` function sayHi() { if (true) { var phrase = "Hello"; } alert(phrase); // works or not? } sayHi(); alert(phrase); // works or not? ```

Answer 43

works Error: phrase is not defined

Question 44

If a code block is inside a function, then var becomes a function-level variable TRUE / FALSE

Answer 44

TRUE

Question 45

``` function sayHi() { if (true) { let phrase = "Hello"; } alert(phrase); // works } ``` sayHi();

Answer 45

error uses let

Question 46

“var” are processed at the function start TRUE / FALSE

Answer 46

TRUE

Question 47

TRUE / FALSE : both give same result and why or why not? ``` function sayHi() { phrase = "Hello"; alert(phrase); var phrase; } ``` ``` function sayHi() { var phrase; phrase = "Hello"; alert(phrase); } ```

Answer 47

var variables are defined from the beginning of the function, no matter where the definition is (assuming that the definition is not in the nested function).

Question 48

TRUE / FALSE : both give same result and why or why not? ``` function sayHi() { phrase = "Hello"; alert(phrase); var phrase; } ``` ``` function sayHi() { phrase = "Hello"; if (false) { var phrase; } alert(phrase); } ```

Answer 48

var and code blocks are ignored var are “hoisted” (raised) to the top of the function.

Question 49

``` function sayHi() { alert(phrase); var phrase = "Hello"; } sayHi(); // returns ```

Answer 49

undefined The declaration is processed at the start of function execution (“hoisted”), but the assignment always works at the place where it appears.

Question 50

Because all var declarations are processed at the function start, we can reference them at any place. But variables are __________ until the assignments

Answer 50

undefined

Question 51

``` if (true) { let user = "33333"; alert (`${phrase} + ${user}`); } ``` let phrase = "hello";

Answer 51

error not intialized

Question 52

``` function makeCounter() { let count = 0; return function() { return ++count; }; } ``` ``` let counter1 = makeCounter(); let counter2 = makeCounter(); ``` alert( counter1() ); // alert( counter1() ); // alert( counter2() ); //

Answer 52

1 2 1