Answer: D

Inside the function, we first declare the name variable through the var keyword. This means that the variable is raised (the memory space is set during creation) and the default value is undefined until the program runs to where the variable is defined. Because the name variable has not been executed to the point where it is defined when we print it, the value of the variable remains undefined.

Variables declared with the let and const keywords are also promoted, but unlike var, they are not initialized. They are not accessible until we declare (initialize) them. This behavior is called a temporary dead zone. JavaScript will throw a ReferenceError when we try to access them before declaring them.

Answer: C

Due to JavaScript’s event loop, the setTimeout callback is executed after the loop is completed. Because the traversal I in the first traversal is declared by the var keyword, this value is globally scoped. During the traversal, we increment the value of I each time by the unary operator ++. When the setTimeout callback executes, the value of I is equal to 3.

In the second traversal, the traversal I is declared by the let keyword: variables declared by the let and const keywords have block-level scope (anything in {}). During each iteration, I has a new value, and each value is in scope within the loop.

Answer: B

Note that the value of diameter is a regular function, but perimeter’s value is an arrow function.

For arrow functions, the this keyword refers to its current scope (simply the normal function that contains the arrow function, or the global object if there are no normal functions), which behaves differently from the normal function. This means that when we call perimeter, this does not point to the Shape object, but rather to its surrounding scope (in our case, window).

Radius does not exist in the window, so return undefined.

Answer: A,

The unary plus operator attempts to convert bool to number. True converts to number to 1 and false to 0.

The string ‘Lydia’ is a truth value, which returns false if reversed.

Answer: A,

In JavaScript, the keys of all objects are strings (unless the object is a Symbol). Although we may not define them as strings, they are always converted to strings underneath.

JavaScript interprets (or unboxes) statements when we use the parenthesis syntax ([]). It sees the first opening parenthesis [and continues until it finds the closing parenthesis]. Only then will it evaluate the value of the statement.

Mouse [bird.size] : Evaluates bird.size first, which gives small. Mouse [“small”] returns true.

And then using dot syntax, none of this would happen. Mouse does not have the bird key, which means that mouse. Bird is undefined. Then when we use the dot syntax mouse.bird.size, since mouse.bird is undefined, this becomes undefined. This behavior is invalid and throws an error like Cannot read property “size” of undefined.

Answer: A,

In JavaScript, when two objects are set equal to each other, they interact by reference.

First, the value of variable C is an object. Next, we assign d a reference to the same object as c.

So when we change one of these objects, we change all of them.

Answer: C

New Number() is a built-in function constructor. Although it looks like a number, it’s not really a number: it has a bunch of extra functions and it’s an object.

When we use the == operator, it simply checks to see if both have the same value. Since they both have a value of 3, they return true.

Then, when we use the === operator, both values and types should be the same. New Number() is an object, not a Number, so returns false.

Answer: D

ColorChange is a static method. Static methods are designed to be used only by the constructor that created them (that is, Chameleon) and cannot be passed to instances. Because Freddie is an instance, static methods cannot be used by the instance, so TypeError is thrown.

Answer: A,

The code prints out an object because we created an empty object on the global object! When we miswrite greeting as greetign, the JS interpreter actually treats it as global.greetign = {} (or window.greetign = {}) in the browser.

To avoid this, we can use ‘use strict’. This ensures that you have to assign values when you declare variables.

Answer: A,

This is fine in JavaScript because functions are objects! (All but basic types are objects)

A function is a special object. The code you wrote is not actually a function. A function is an object that has properties that can also be called.

Answer: A,

You can’t add attributes to a constructor like you would to a regular object. If you want to add features to all instances at once, you should use prototypes. Therefore, in this example, the following method is used:

Person.prototype.getFullName = function () {
  return `The ${this.firstName} The ${this.lastName}`;
}
Copy the code

That’s what makes member.getFullName() work. Why is it good to do that? Suppose we add this method to the constructor itself. This method may not be required for every Person instance. This wastes a lot of memory space because they still have that property, which takes up memory space per instance. Conversely, if we just add it to the prototype, it only exists in one location in memory, but all instances can access it!

Answer: A,

For Sarah, we don’t use the new keyword. When using new, this refers to the empty object we created. When new is not used, this refers to a global object.

We say this.firstName equals “Sarah” and this.lastName equals “Smith”. What we’ve actually done is define global.firstName = ‘Sarah’ and global.lastName = ‘Smith’. And Sarah herself is undefined.

Answer: D

In the capture phase, events propagate down from ancestor elements to target elements. The bubbling begins when the event reaches the target element.

Answer: B

All objects except base objects have prototypes. Basic objects have access to some methods and attributes, such as.toString. That’s why you can use built-in JavaScript methods! All of these methods are available on the prototype. Although JavaScript cannot find these methods directly on objects, JavaScript will find them along the prototype chain so that you can use them.

Answer: C

JavaScript is a dynamically typed language: we don’t specify the types of certain variables. Values can be automatically converted to another type without you knowing it. This type is called implicit Type Coercion. Coercion means to convert one type to another.

In this case, JavaScript converts the number 1 to a string so that the function makes sense and returns a value. When the numeric type (1) is added to the string type (‘2’), the number is treated as a string. We can concatenate strings like “Hello” + “World”, what’s happening here is “1” + “2”, it returns “12”.

Answer: C

Increment operator ++ after unary:

1. Return value (Return0)
2. Value increment (number is now1)

Unary increment operator ++ :

1. Value increment (number is now2)
2. Return value (Return2)

It’s 0, 2, 2.

Answer: B

If a tag template literal is used, the value of the first argument always contains an array of strings. The rest of the arguments take the value of the passed expression!

Answer: C

When testing for equality, primitive types are compared by their values, while objects are compared by their references. JavaScript checks if an object has a reference to the same location in memory.

The two objects we are comparing are not the same reference: the memory location of the object reference passed as an argument is not the same as the memory location of the object used to determine equality.

This is why {age: 18} === {age: 18} and {age: 18} == {age: 18} both return false.

Answer: C

Extension operators (… Args) returns an array of arguments. Arrays are objects, so Typeof args returns “object”.

Answer: C

With “Use strict”, you can ensure that you don’t accidentally declare global variables. We never declared the variable age because we used “use strict”, which would throw a reference error. If we don’t use “use strict”, it will work because the age attribute is added to the global object.

Answer: A,

The code is passed in as a string, and eval evaluates it. If it is an expression, as in this case, it evaluates the expression. This expression is 10 times 10 plus 5. This will return the number 105.

Answer: B

Data stored in sessionStorage will be deleted only after the TAB TAB is closed.

If localStorage is used, the data will always be there unless localstorage.clear () is called.

Answer: B

Using the var keyword, you can declare multiple variables with the same name. The variable will then hold the most recent value.

You cannot do this using let or const because they are block-scoped.

Answer: C

All object keys (except Symbol) are strings at the bottom, even if you don’t enter them as strings yourself. This is why obj.hasownProperty (‘1’) also returns true.

For sets, it doesn’t work that way. There is no ‘1’ in our collection: set.has(‘1’) returns false. It has a numeric type of 1 and set.has(1) returns true.

Answer: C

If you have two keys with the same name, the keys will be replaced. It’s still where the first key appeared, but the value is the value of the last key.

Answer: A,

The base execution context is the global execution context: it is something accessible anywhere in your code.

Answer: C

If a condition returns true, the continue statement skips the iteration.

Answer: A,

String is the built-in constructor to which we can add attributes. I just added a method to its prototype. The primitive string is automatically converted to a string object, which is generated by the string prototype function. Therefore, all strings (string objects) can access this method!

Answer: B

The key of the object is automatically converted to a string. We are trying to set an object B to be the key of object A with the corresponding value 123.

However, when you string an object, it becomes “[Object object]”. So it says, a[“[object object]”] = 123. Then, we do the same thing again, c is another object, and there is also implicit stringification, so a[“[object object]”] = 456.

Then, we print a[b], which is a[“[object object]”]. It was just set to 456, so 456 is returned.

Answer: B

We have a setTimeout function and call it first. However, it is the last to print the log.

That’s because in the browser, we have not only a runtime engine, but also something called a WebAPI. WebAPI provides setTimeout functions, as well as others, such as DOM.

After pushing the callback to WebAPI, the setTimeout function itself (but not the callback!) Will pop from the stack.

Now foo is called, printing “First”.

Foo pops off the stack and baz is called. Print “Third”.

WebAPI cannot add content to the stack at any time. Instead, it pushes the callback function to a place called Queue.

This is where the event loop begins to work. An event loop looks at the stack and task queue. If the stack is empty, it accepts the first element on the queue and pushes it onto the stack.

Bar gets called, prints “Second”, and it gets popped on the stack.

Answer: C

The deepest nested element that causes an event is the target of the event. You can stop bubbling by calling Event.stopPropagation.

Answer: A,

If we click p, we see two logs: p and div. During event propagation, there are three phases: capture, target, and bubble. By default, event handlers are executed in the bubble phase (unless useCapture is set to true). It propagates outward from the deepest nested element.

Answer: D

Using both methods, we can pass objects that we want the this keyword to reference. However,.call is executed immediately.

.bind returns a copy of the function, but with a binding context! It is not executed immediately.

Answer: B

The sayHi method returns the return value of the execute now function (IIFE). This immediate function returns 0 and is of type number

Reference: There are only seven built-in types: NULL, undefined, Boolean, number, String, Object, and symbol. Function is not a type. A function is an object. Its type is Object.

Answer: A,

There are only 6 falsy values:

• undefined
• null
• NaN
• 0
• ' ' (empty string)
• false

Function constructors, such as New Number and New Boolean, are truthy.

Answer: B

Typeof 1 returns “number”. Typeof “number” Returns “string”.

Answer: C

JavaScript creates something called “Empty slots” when you set values for an array that exceed the length of the array. Their values are actually undefined. Here’s what you’ll see:

[1, 2, 3, 7 x empty, 11]

This depends on your running environment (each browser, and node environment, may be different).

Answer: A,

The catch block receives the parameter X. When we pass parameters, this is different from the variable x we defined earlier. This x is in the catch block-level scope.

We then assign a value of 1 to the variable in the block-level scope and also set the value of the variable y. Now, we print the variable x in the block-level scope with a value of 1.

The value of x outside the catch block is undefined and y is 2. When we execute console.log(x) outside of the catch block, undefined is returned and y returns 2.

Answer: A,

JavaScript only has basic types and objects.

Basic types include Boolean, NULL, undefined, bigint, number, string, and symbol.

Answer: C

[1, 2] is the initial value. The initial value will be the value of the first parameter acc when first called. On the first execution, acc has the value [1, 2] and cur has the value [0, 1]. Combine them and the result is [1, 2, 0, 1]. On the second execution, acc has the value [1, 2, 0, 1] and cur has the value [2, 3]. Combine them and the end result is [1, 2, 0, 1, 2, 3]

Answer: B

Null is falsy. ! The value of null is true. ! The value of true is false.

“” is falsy. !” The value of “is true. ! The value of true is false.

1 is truthy. ! The value of 1 is false. ! The value of false is true.

Answer: A,

SetInterval returns a unique ID. This ID can be used by the clearInterval function to cancel timing.

Answer: A,

The string type is iterable. The extension operator maps each character of the iteration to an element.

Answer: C

A normal function cannot be stopped midway through its execution. Generator functions, however, can “stop” midway through and pick up where they left off. When the generator encounters the yield keyword, the value following yield is generated. Note that the generator does not return a value in this case, but rather generates a yield value.

First, we initialize the generator function with 10 as parameter I. The generator is then executed step by step using the next() method. The first time the generator is executed, the value of I is 10, and the first yield keyword is encountered, which generates the value of I. At this point, the generator “pauses” and produces 10.

We then execute the next() method. The generator will pick up where it left off, and I will still be 10. So we get to the second yield keyword, and the value that needs to be generated is I *2, and I is 10, so the value that needs to be generated is 20. So the final answer to this problem is 10,20.

Answer: B

When we pass multiple promises into the promise.race method, priority resolution takes place. In this example, we use setTimeout to set the 500ms and 100ms timers for firstPromise and secondPromise, respectively. This means that secondPromise will parse the string two first. In this case, the res parameter is two and is the output result.

Answer: D

First we declare an object person with a name attribute.

We then declare a variable members. Assign the first element to the person variable. When two objects are set equal to each other, they interact by reference. But when you assign a reference from one variable to another, you’re just doing a copy. (Note that they are quoted differently!)

Next we make Person equal to null.

Instead of changing the value of the first element of the array, we just changed the value of the variable Person, because the element (copied) has a different reference than Person. The first element of Members retains a reference to the original object. When we print out the Members array, the first element prints out the referenced object.

Answer: B

In a for-in loop, we can iterate over the object’s key, which is name and age here. At the bottom, objects’ keys are strings (if they are not symbols). In each loop, we set item to be the key we are currently traversing. So at first, item is name, and then item outputs age.

Answer: B

When all operators have the same precedence, the evaluation expression needs to determine the order in which the operators are combined, that is, from right to left or from left to right. In this case, we have only one class of operator +, and for addition, the order of incorporation is left to right.

3 + 4 is calculated first to get the number 7.

Due to type casting, 7 + ‘5’ results in “75”. JavaScript converts 7 to a string, see question 15. We can concatenate two strings with a + sign. “7” plus “5” gives me “75”.

Answer: C

Only the first character of the string is returned. After setting the base (the second parameter, which specifies the base of the number to parse: decimal, 16, octal, binary, etc.) ,parseInt checks whether characters in a string are valid. On encountering an invalid character in the specified base, immediately stop parsing and ignore all subsequent characters.

* is an illegal numeric character. So only “7” is parsed, and the decimal value of 7. Num is 7.

Answer: C

When mapping an array,num is the element currently looping through. In this example, all mappings are of type number, so typeof num === “number” in if results in true. The map function creates a new array and inserts the function’s return value into the array.

However, no value is returned. Undefined is returned by default when the function does not return any value. For each element in the array, the function block gets the return value, so each element in the result is undefined.

Answer: A,

Unlike ordinary parameters, which are passed by value, objects are passed by reference. So birthYear is value passed because it is a string rather than an object. When we pass a value to a parameter, a copy of that value is created. (Please refer to Q.46)

The birthYear variable has a reference to “1997” and the passed parameter also has a reference to “1997”, but the references are not the same. When we update the value of year by assigning “1998” to it, we are simply updating year. BirthYear is still “1997” at this point.

And person is an object. The member argument refers to the same object. When we modify the attributes of the object referenced by member, the corresponding attributes of person are also modified because they refer to the same object, and the name attribute of person becomes “Lydia”.

Answer: D

With the throw statement, we can create custom errors. And from that, we can throw an exception. An exception can be a string, a number, a Boolean type, or an object. In this case, our exception is the string ‘Hello world’.

With a catch statement, we can specify what to do when an exception is thrown in a try block. The exception thrown in this case is the string ‘Hello world’. E is the string and is therefore printed. The final result is ‘Oh an error: Hello world’.

Answer: B

When a property is returned, the value of the property is equal to the returned value, not the value specified in the constructor. We return the string “Maserati”, so mycar. make equals “Maserati”.

Answer: A,

let x = y = 10; Is an abbreviation of the following expression:

y = 10;
let x = y;
Copy the code

When we set y to 10, we actually add a property y to the global object (window in the browser, global in Nodejs). In browsers, window.y is equal to 10.

We then declare the variable x equal to y, also 10. However, the variable is declared using let, which only applies to the block-level scope and is only valid in the block in which it is declared; This is the immediate invocation expression (IIFE) in this case. When using the Typeof operator, the operation value x is not defined: we cannot call it because we are outside the x declaration block. That means that x is undefined. Unassigned or undeclared variables of type “undefined”. Console. log(typeof x) returns “undefined”.

Instead, we create the global variable y and set y to 10. This value is accessed everywhere in our code. Y is already defined, and it has a value of type “number”. Console. log(typeof y) returns “number”.

Answer: A,

We can use the delete keyword to delete attributes of objects, which is also true for stereotypes. After the attribute of the stereotype is deleted, it is no longer available on the stereotype chain. In this case, the function bark is not available after the delete dog.prototype. bark is still called by subsequent code.

TypeError is thrown when we try to call a function that does not exist. In this case, TypeError: pet.bark is not a function, because pet.bark is undefined.

Answer: D

A Set object is a collection of unique values: that is, the same value occurs only once in it.

We pass in the array [1, 1, 2, 3, 4], which has a duplicate value of 1. Because you can’t have two duplicate values in a set, one of them is removed. So the result is {1, 2, 3, 4}.

Answer: C

Imported modules are read-only: you cannot modify imported modules. Their values can only be modified by exporting their modules.

When we add a value to myCounter we throw an exception: myCounter is read-only and cannot be modified.

Answer: A,

The delete operator returns a Boolean value: true for successful deletion, false otherwise. However, variables declared by the var, const, or let keywords cannot be deleted using the DELETE operator.

The name variable is declared by the const keyword, so deletion failed: return false. And when we set age to 21, we’re actually adding a property called age to the global object. Properties in objects can be deleted, as can global objects, so delete Age returns true.

Answer: C

We can parse the value of an array or property from an object by deconstructing assignment, for example:

[a, b] = [1.2];
Copy the code

The value of A is now 1, and the value of b is now 2. And here’s what we did:

[y] = [1.2.3.4.5];
Copy the code

That is, y equals the first value of the array is the number 1. We print y and return 1.

Answer: B

Extended operators… Provides the possibility of composing objects. You can copy key-value pairs from an object and add them to another object. In this case, we copy the user object key-value pairs and add them to the Admin object. The admin object has these key-value pairs, so the result is {admin: true, name: “Lydia”, age: 21}.

Answer: B

With the defineProperty method, we can add a new attribute to an object or modify an existing attribute. After we add a property to the Object using defineProperty, the property defaults to not Enumerable. The object.keys method only returns an enumerable property in the Object, so it’s just “name”.

Attributes added using the defineProperty method are immutable by default. You can change this behavior with the Writable, 64x and Enumerable properties. In this way, the attributes added by the defineProperty method have more control than those you add yourself.

Answer: A,

The second argument to json.stringify is replacer. A replacer can be a function or an array that controls which values are converted to a string.

If the replacer is an array, then only the properties contained in the array will be converted to a string. In this case, only properties named “level” and “health” are included, and “username” is excluded. Data equals “{“level”:19, “health”:90}”.

If the replacer is a function, it will be called once for every property of the object. The value returned by the function becomes the value of this property, which is reflected in the converted JSON string. In Chrome, if there is an exception when all attributes return the same value, the return value will be directly output as the result of the JSON string), and if the return value is undefined, the attribute will be excluded.

Answer: A,

The unary operator ++ returns and then accumulates the operands. Num1 is 10, since the increaseNumber function first returns the value of num, which is 10, and then accumulates num.

Num2 is 10 since we pass num1 increasePassedNumber. Number is equal to 10 (the value of num1). In the same way, ++ returns the operand and then accumulates the operand. Number is 10, so num2 is 10.

Answer: C

In ES6, we can initialize parameters with default values. If no parameter is passed to the function, or if the parameter value is “undefined”, the parameter value will be the default value. In the example above, we deconstructed the value object and passed it to a new object, so the default value for x is {number: 10}.

Default arguments are evaluated only when called, and a new object is created each time the function is called. The multiply function is called the first two times without passing a value, so x defaults to {number: 10} each time, so the printed product of the number is 20.

On the third call to Multiply, we pass one argument, the object value. The *= operator is actually short for x.number = x.number * 2, and we changed the value of x.number and printed out the value 20.

The fourth time, we pass the value object again. X. number * = 2 is printed as 40 because it was changed to 20.

Answer: D

The reducer function receives four parameters:

1. Accumulator (ACC)
2. Current Value (CUR)
3. Current Index (IDX)
4. Source Array (SRC)

The return value from the Reducer function is assigned to the accumulator and is remembered in each iteration of the array and becomes the final single result value.

The Reducer function also has an optional parameter, initialValue, which will be the value of the first parameter when the callback function is first called. If no initialValue is provided, the first element in the array is used.

In the above example, the first parameter (Accumulator) received by the Reduce method is X and the second Current Value (Current Value) is Y.

On the first call, the accumulator x is 1 and the current value “y” is 2, printing out the accumulator and the current value: 1 and 2.

Our callback function in this example does not return any value, but simply prints the accumulator’s value and the current value. If the function returns no value, undefined is returned by default. On the next call, the accumulator is undefined and the current value is “3”, so undefined and 3 are printed.

On the fourth call, the callback function still returns no value. The accumulator is undefined again and the current value is “4”. Undefined and 4 are printed.

Answer: B

In subclasses, the this keyword cannot be accessed until super is called. If it does, it will throw a ReferenceError: 1 and 4 will raise a ReferenceError.

With the super keyword, the constructor of the parent class needs to be called with the given arguments. The constructor of the parent class takes the name argument, so we need to pass name to super.

The Labrador class receives two arguments, name because it inherits Dog and size as additional attributes of the Labrador class, both of which need to be passed to the Labrador constructor, so constructor 2 is used to do this correctly.

Answer: B

The import command is executed at compile time, before the code runs. So this means that the imported module will run first, and the imported module’s file will run after.

This is the difference between require () and import in CommonJS. With require(), you can load dependencies as needed at run time. If we use require instead of import, running index.js, running sum.js, 3 will be printed in sequence.

Answer: A,

Each Symbol is completely unique. The parameter passed to Symbol is just a description given to Symbol. The value of Symbol does not depend on the parameter passed. When we test for equality, we create two brand new symbols: the first Symbol (‘foo’) and the second Symbol (‘foo’). These two values are unique and not equal to each other, so return false.

Answer: C

Using the padStart method, we can add padding at the beginning of the string. The argument passed to this method is the total length of the string, including padding. The string Lydia Hallie is 12 in length, so name.padstart (13) inserts only 1 (13-12 = 1) space at the beginning of the string.

If the parameter passed to the padStart method is less than the length of the string, no padding is added.

Answer: A,

Using the + operator, you can concatenate strings. In the above case, we concatenate the string “🥑” with the string “💻” to produce “🥑💻”.

Answer: C

Generator functions “pause” their execution when they encounter the yield keyword. First, we need to make the function produce a string Do you love JavaScript? This can be done by calling game.next().value. The first line of the above function has a yield keyword, so the operation stops immediately. The yield expression itself returns no value, or always returns undefined, which means that the variable answer is undefined at this point

The next method can take an argument that is treated as the return value of the previous yield expression. When we call game.next(“Yes”).value, the return value of the previous yield will be replaced with the argument “Yes” passed to the next() function. At this point the variable answer is assigned to “Yes” and the if statement returns false, so JavaScript loves you back ❤️ is printed.

Answer: C

The string. raw function is used to get the raw String of a template String. It returns a String in which the escape characters (\n, \v, \t, etc.) are ignored. Backslashes can cause problems, however, because you might encounter something like the following:

const path = `C:\Documents\Projects\table.html`
String.raw`${path}`
Copy the code

This will result in:

"C:DocumentsProjects able.html"

Use string.raw directly

String.raw`C:\Documents\Projects\table.html`
Copy the code

It ignores the escape character and prints: C:\Documents\Projects\table.html

In the above case, the string Hello\nworld is printed out.

Answer: C

Asynchronous functions always return a promise. Await the promise: When we call getData() and assign it to data, data is a pending promise returned by the getData method, and the promise is not resolved.

If we want to access the resolved value “I made it!” The.then() method is used on data:

data.then(res => console.log(res))

This will print “I made it!”

Answer: B

The push() method returns the length of the new array. Initially, the array contains one element (the string “banana”) of length 1. After adding the string “apple” to the array, the length becomes 2 and is returned from the addToList function.

The push method modifies the original array. If you want to return the array from a function instead of its length, you should return the list after the push item.

Answer: B

Object.freeze makes it impossible to add, delete, or modify attributes of an Object (unless the value of the attribute is another Object).

When we create the variable shape and set it to be equal to the frozen object box, shape also refers to the frozen object. You can use object. isFrozen to check if an Object isFrozen, in which case object. isFrozen (shape) returns true.

Since shape is frozen and the value of x is not an object, we cannot modify property X. X is still equal to 10 and {x: 10, y: 20} is printed.

Note that in the example above we made changes to attribute X that might cause TypeError exceptions to be thrown (most commonly but not exclusively in strict mode).

Answer: D

When we deconstruct the attribute name from the object on the right, we assign its value Lydia to a variable named myName.

With {name: myName}, we are telling JavaScript that we want to create a new variable named myName whose value is the value of the name property of the object on the right.

ReferenceError is raised when we try to print name, an undefined variable.

Answer: A,

Pure function A function that always yields the same output if the input parameters are the same.

The sum function always returns the same result. If we pass 1 and 2, it will always return 3 with no side effects. If we pass 5 and 10, it will always return 15, and so on, which is the definition of a pure function.

Answer: C

The add function is a memory function. By mnemonizing, we can cache the results of a function to speed up its execution. In this case, we create a cache object to store the previously returned value.

If we call the addFunction function multiple times with the same argument, it first checks to see if the value is already in the cache, and if so, returns the cached value, which saves execution time. If not, it calculates the value and stores it in the cache.

We call the addFunction function three times with the same value:

On the first call, the value of the function is not cached when num equals 10. The if statement num in cache returns false, and the code for the else block is executed: Calculated! 20, and the result is added to the cache object, cache now looks like {10:20}.

The second time, the cache object contains the return value of 10. If num in cache returns true, From cache! 20 is printed.

The third time, we pass 5 * 2(value 10) to the function. The cache object contains the return value of 10. If num in cache returns true, From cache! 20 is printed.

Answer: B

In JavaScript, we don’t have to explicitly write semicolons (;) , but the JavaScript engine still automatically adds semicolons after statements. This is called automatic semicolon insertion. For example, a statement can be a variable, or a keyword like throw, return, or break.

Here, we write a return statement and another value a + b on a new line. However, since it’s a new line, the engine doesn’t know that it’s actually the value we want to return. Instead, it automatically adds a semicolon after the return. You can look at it this way:

  return;
  a + b
Copy the code

This means that it never reaches a + B because the function stops running after the return keyword. If there is no return value, as here, the function returns undefined. Note that there is no automatic insertion after the if/else statement!

Answer: B

We can set the class to be equal to other class/function constructors. In this case, we set Person to AnotherPerson. The constructor name is Sarah, so the name attribute on the new Person instance member is Sarah.

Answer: D

The Symbol type is not enumerable. The object.keys method returns all the enumerable key properties on an Object. The Symbol type is invisible and returns an empty array. When recording the entire object, all properties are visible, even non-enumerable properties.

This is one of Symbol’s many features: in addition to representing completely unique values (preventing accidental object name conflicts, such as when using two libraries that want to add attributes to the same object), you can also hide the attributes of objects in this way (although not completely). You can still use the Object. GetOwnPropertySymbols visit Symbol () method.

Answer: A,

The getList function takes an array as its argument. Between the parentheses of the getList function, we immediately deconstruct the array. You can think of it as:

[x, ...y] = [1, 2, 3, 4]

Using the remaining parameters… Y, we put all the remaining arguments in an array. In this case, the remaining parameters are 2,3 and 4. The value of y is an array containing all the remaining parameters. In this case, the value of x is 1, so when we print [x, y], we print [1, [2,3,4]].

The getUser function receives an object. For arrow functions, if only one value is returned, we do not need to write curly braces. However, if you want to return an object from an arrow function, you must write it between parentheses or nothing will be returned! The following function returns an object:

const getUser = user => ({ name: user.name, age: user.age })

Since no value is returned in this case, the function returns undefined.

Answer: C

The variable name holds the value of the string, which is not a function and therefore cannot be called.

TypeErrors is thrown when the value is not of the expected type. JavaScript expects name to be a function because we’re trying to call it. But it is a string, so TypeError is raised: Name is not a function

Syntax errors are thrown when you write JavaScript that is not valid, such as when you write the word return as retrun. Throws ReferenceErrors when JavaScript cannot find a reference to the value you are trying to access.

Answer: B

[] is a true value. Use the && operator to return the right-hand value if the left-hand value is true. In this case, the left-hand value [] is a true value, so Im is returned.

“Is a false value. If the left-hand value is false, nothing is returned. N’t will not be returned.