Functions

Question 1

What does a regular function definition look like?

Answer 1

Question 2

What does line 6 do?

Answer 2

the code say() is described as a function call to the say function. When JavaScript runs this program, it creates a function named say whose body causes JavaScript to print the text Output from say() when the function executes.

Note that the parentheses on line 6 – () – make this code a function call. Without the parentheses, say doesn’t do anything useful. It’s just the function’s name; it is a variable whose value is a “function object.”

Question 3

Is console.log also a function call?

Answer 3

It is, in fact, a function call, though we typically call it a method call instead. The . in console.log distinguishes it as a method call instead of a function call.

Question 4

What do arguments do?

Answer 4

Arguments let you pass data from outside the function’s scope into the function so it can access the data. You don’t need arguments if the function definition doesn’t need access to outside data.

Question 5

What are parameters?

Answer 5

In the definition of a function, the names between parentheses are called parameters. You can think of parameters as placeholders, while arguments refer to the values assigned to those placeholders.

In say.js the code within the function definition then executes with the text local variable assigned to “hello”.

Question 6

What are function names and parameters considered in JS?

Answer 6

Function names and parameters are both considered variable names in JavaScript. Parameters, in particular, are local variables (the scope of the variable defined by the parameter is the function definition; you can’t use it outside the function’s body). They are defined locally within the function’s body. Function names are either global or local, depending on whether the function is at the program’s top level or nested inside a class, object, or another function.

Question 7

Difference between arguments and parameters?

Answer 7

Arguments are objects or primitive values being passed to the function; parameters are declarations for the local variables used inside the function to access the arguments.

Question 8

What happens if you provide too many or too few arguments?

Answer 8

The additional arguments will be ignored if you provide too many arguments when calling a function. If you provide too few arguments, the parameters and variables that correspond to the missing arguments will receive a value of undefined:

Question 9

What is the implicit return value of most JS functions?

Answer 9

Undefined

Question 10

What is an explicit return value?

Answer 10

When you use a return statement, you can return a specific value from a function.

Question 11

What happens when JS encounters the ‘return’ statement?

Answer 11

It evaluates the expression, terminates the function, and returns the expression’s value to the location where we called it.

Question 12

What is the calling function sometimes referred as?

Answer 12

The caller

Question 13

What are functions that return a boolean value called?

Answer 13

Predicates

Question 14

How does a function with default parameters look like?

Answer 14

When you define a function, you sometimes want to structure it so you can call it without an argument

Question 15

Nested functions

Answer 15

You can create functions anywhere, even nested inside other functions.

Nested functions get created and destroyed every time the outer function runs. (This usually has a negligible effect on performance.)

Question 16

Quick review: difference between global variables vs local variables.

Answer 16

Global variables are available throughout a program, while local variables are confined to a function or a block.

Question 17

Can we reassign global variables from within a function?

Answer 17

Yes!

Line 11 invokes the function, passing in the ‘Good Evening’ string, which becomes the new value for the global greetingMessage.

Question 18

Local variables

Answer 18

The greetPeople function declares greetingMessage internally. It’s accessible within the function, but a ReferenceError occurs if you try to use it elsewhere.

Question 19

How can we ask greetPeople to output a different greeting message if we’ve hard-coded our greeting message on line 2?

Answer 19

With function arguments:

Question 20

Are parameters a local variable?

Answer 20

It is, in fact, a local variable. The chief difference is that we initialize it from the argument passed to the function. Parameters have local scope within a function.

Question 21

What is a very important property of local variables?

Answer 21

Local variables are short-lived; they go away when the function corresponding to their scope stops running. When we invoke the function, we start a new scope. If the code within that scope declares a new variable, that variable belongs to the scope. When the last bit of code in that scope finishes running, the locally scoped variables disappear. JavaScript repeats this process each time we invoke a function.

Question 22

How do you also confine a variable locally?

Answer 22

Through block-scoping.

Block scoping occurs when you use let or const inside a block and confines the variable’s scope to that block.

Question 23

What are function methods?

Answer 23

Method invocation occurs when you prepend a variable name or value followed by a period (.) to a function invocation, e.g., ‘xyzzy’.toUpperCase().

Question 24

What is reassignment?

Answer 24

It changes what value is assigned (or bound) to a variable.

Reassignment simply makes that name (variable) refer to a completely different place in memory and, hence, a different value.

We sometimes describe reassignment as changing the binding of a variable

Question 25

What is mutation?

Answer 25

It changes the value of the thing that is bound to the variable.

It changes the value that is actually stored in the memory that the name refers to. After mutating the value assigned to a variable, the variable continues to refer to the same place in memory.

Question 26

If the variable refers to an array or an object, would reassigning an element reassign the variable?

Answer 26

No!

It mutates that array or object referenced by that variable.

Question 27

Are primitive values mutable?

Answer 27

No! They are immutable.

Primitive values are immutable. That means their values never change; operations on immutable values always return new values.

Question 28

What values are mutable?

Answer 28

Operations on mutable values (arrays and objects) may or may not return a new value and may or may not mutate data.

There’s no way to tell whether a function mutates an array or object. You have to use the documentation or memorize it through repetition.

Question 29

Is JS a pass-by-value or pass-by-reference language?

Answer 29

JavaScript is both! It uses pass-by-value when dealing with primitive values and pass-by-reference with objects and arrays.

Question 30

What is function composition?

Answer 30

JavaScript lets us use a function call as an argument to another function.

Life gets more interesting when you pass function call results to a function that does something more complicated:

Question 31

Function declaration

Answer 31

In JavaScript, we call a function definition that looks like that a function declaration. A notable property of function declarations is that you can call the function before you declare it.

Question 32

Function expressions

Answer 32

Most of it seems like a standard function declaration. However, since we’re saving it to a variable, it’s a function expression instead. Function expressions have one key difference from a function declaration: you cannot invoke a function expression before it appears in your program.

Our example declares a variable named greetPeople and assigns it to the function expression after the = sign. We can do that since JavaScript functions are first-class functions.

Question 33

What is the critical feature of first-class-functions?

Answer 33

You can treat them like any other value. In fact, all JavaScript functions are objects. Thus, you can assign them to variables, pass them as arguments to other functions, and return them from a function call.

Question 34

Why a function declaration must start with the word ‘function’?

Answer 34

Any function definition that doesn’t have the word function at the very beginning of a statement is a function expression. Even wrapping what looks like a function declaration in parentheses creates a function expression:

Question 35

Another common example of function expressions in higher order functions

Answer 35

That is not a function declaration – it’s a function expression.

Question 36

Arrow function syntax

Answer 36

Question 37

What are implicit returns in arrow functions?

Answer 37

We can omit it in arrow functions when and only when the function body contains a single expression that is not itself surrounded by curly braces (the expression may have subexpressions, but the entire expression must evaluate to a single value). Suppose it contains two or more expressions or statements. In that case, you must explicitly return a value if you need it, and you must also use curly braces

Question 38

What is the call stack?

Answer 38

The call stack helps JavaScript keep track of what function is executing as well as where execution should resume when the function returns

Question 39

What is the stack frame?

Answer 39

When this program starts running, the call stack initially has one item – called a stack frame – that represents the global (top-level) portion of the program. The initial stack frame is sometimes called the main function. JavaScript uses this frame to keep track of what part of the main program it is currently working on.

Question 40

What happens when the program execution reaches line 10?

Answer 40

When program execution reaches the function invocation on line 10, it first updates the main stack frame with the current program location. JavaScript will use this location later to determine where execution should resume when second finishes running.

Question 41

What happens after setting the location in the current stack frame for the function call second()

Answer 41

JavaScript creates a new stack frame for the second function and places it on the top of the call stack: we say that the new frame is pushed onto the stack. Our call stack now looks like this:

Note that the frame for the second function is now stacked on top of the main frame. While the second frame is still on the stack, main remains stuck beneath it, inaccessible. At the same time, the main function becomes dormant and the second function becomes active.

Question 42

What happens in the stack when a value is returned?

Answer 42

When a value is returned, JavaScript removes – pops – the top frame from the call stack. That’s the frame for console.log in this example. That leaves the previous stack frame exposed. JavaScript uses this frame to determine where execution should resume. In this case, execution resumes immediately after line 2.

Question 43

What happens when the main function has no more code to run?

Answer 43

The main frame gets popped from the stack, and the program ends.

Question 44

Does the stack have limited size?

Answer 44

The call stack has a limited size that varies based on the JavaScript implementation. That size is usually sufficient for more than 10000 stack entries. If the stack runs out of room, you will see a RangeError exception together with a message that mentions the stack.