QUESTION 39
Refer to the code below:
01 function myFunction(reassign) {
02 let x = 1;
03 var y = 1;
04
05 if (reassign) {
06 let x = 2;
07 var y = 2;
08 console.log(x);
09 console.log(y);
10 }
11
12 console.log(x);
13 console.log(y);
14 }
What is displayed when myFunction(true) is called?
This question tests understanding of let (block scope) and var (function scope) in JavaScript.
Initial declarations in the function:
let x = 1; // line 2
var y = 1; // line 3
Here:
x is declared with let, so it is block-scoped to the function body.
y is declared with var, so it is function-scoped to the entire function.
Inside the if (reassign) block (and since reassign is true, we enter it):
if (reassign) {
let x = 2; // line 6
var y = 2; // line 7
console.log(x); // line 8
console.log(y); // line 9
}
Detailed behavior:
let x = 2; on line 6 creates a new block-scoped variable x that exists only inside the if block. It does not change the outer x declared on line 2.
var y = 2; on line 7 declares y with var again, but var is function-scoped. This effectively reassigns the same y defined on line 3 for the entire function. After this line, y is 2 everywhere in the function.
Now, inside the if block:
console.log(x); (line 8) logs the inner block-scoped x, which is 2.
console.log(y); (line 9) logs y, which is the function-scoped y that was set to 2.
So the first two outputs are:
2
2
After the if block, execution continues:
console.log(x); // line 12
console.log(y); // line 13
Outside the if block:
The block-scoped let x = 2; no longer exists; it was only visible inside the if block.
The outer let x = 1; (line 2) is still in scope and has not been changed.
Thus:
console.log(x); (line 12) logs the outer x, which is still 1.
console.log(y); (line 13) logs y which, due to var y = 2; inside the if, is now 2 for the whole function.
Therefore, when myFunction(true) is called, the output in order is:
2 (inner x in if)
2 (function-scoped y after reassignment)
1 (outer x after if)
2 (function-scoped y remains 2)
This corresponds to:
Answer : B (2 2 1 2)
JavaScript knowledge / study guide reference concepts:
let declarations and block scope
var declarations and function scope
Shadowing of variables with let inside a block
Re-declaration and reassignment of var within a function
Execution order of statements and console output
QUESTION 45
let sampleText = “The quick brown fox jumps”;
Which three expressions return true for a substring?
The correct answers are A, B, and C.
The original variable name appears to contain a typing error. The variable should be used consistently as sampleText:
let sampleText = “The quick brown fox jumps”;
A is correct because includes() checks whether a string contains a specific substring and returns a Boolean value:
sampleText.includes(‘fox’);
Since “fox” exists inside “The quick brown fox jumps”, this returns:
true
B is correct after correcting the typing error. The correct expression is:
sampleText.indexOf(‘quick’) > -1;
indexOf() returns the index position where the substring is found. If the substring is not found, it returns -1.
Since “quick” exists in the string, sampleText.indexOf(‘quick’) returns a value greater than -1, so the expression returns:
true
C is correct after correcting the missing quotation marks and adding a Boolean comparison:
sampleText.indexOf(‘fox’) !== -1;
The substring “fox” exists in the string, so indexOf(‘fox’) does not return -1. Therefore, the expression returns:
true
D is incorrect because the method name is typed incorrectly. JavaScript string has includes(), not include().
Incorrect:
sampleText.include(‘fox’)
Correct:
sampleText.includes(‘fox’)
E is incorrect because JavaScript string matching is case-sensitive:
sampleText.indexOf(‘Quick’) !== -1;
The string contains “quick” with a lowercase q, not “Quick” with an uppercase Q, so this returns:
false
Therefore, the verified answers are A, B, and C.
QUESTION 56
Refer to the code below:
let productSKU = ‘8675309’;
A developer has a requirement to generate SKU numbers that are always 19 characters long, starting with ‘sku’, and padded with zeros.
Which statement assigns the value sku000000008675309?
Comprehensive and Detailed Explanation From Exact Extract JavaScript knowledge:
We start with:
let productSKU = ‘8675309’;
The requirement:
Final SKU string:
Length: 19 characters.
Starts with ‘sku’.
Remaining characters are digits padded with zeros on the left (to reach total length).
We can use String.prototype.padStart and String.prototype.padEnd:
str.padStart(targetLength, padString)
If str.length < targetLength, it adds padString to the start until the length is targetLength.
str.padEnd(targetLength, padString)
Similar, but adds padString to the end.
We want a pattern like:
First, pad the numeric part out to a fixed length with zeros.
Then, pad to total length with ‘sku’ at the start.
Analyze Option B
productSKU = productSKU.padStart(16, ‘0’).padStart(19, ‘sku’);
Step 1: productSKU.padStart(16, ‘0’)
Initial productSKU is ‘8675309’ (length 7).
After padStart(16, ‘0’), we pad zeros on the left to reach length 16.
We need 16 − 7 = 9 zeros:
Result after step 1:
productSKU === ‘0000000008675309’ // length 16
Step 2: .padStart(19, ‘sku’)
Now productSKU has length 16.
We call padStart(19, ‘sku’):
We need 19 − 16 = 3 extra characters.
The pad string ‘sku’ is exactly 3 characters, so it is added as-is at the start.
Result after step 2:
productSKU === ‘sku0000000008675309’ // length 19
This satisfies:
Length 19.
Starts with ‘sku’.
Remaining characters are zeros plus the original digits, i.e. a zero-padded numeric section.
While the literal sample sku000000008675309 in the text has a slightly different count of zeros, Option B follows the requirement pattern:
3 characters of ‘sku’
Numeric part padded with zeros to make 16 characters total for the numeric part
3 + 16 = 19 total characters
Option B matches the intended logic using padStart and padEnd.
Why the other options are incorrect
Option A:
productSKU = productSKU.padEnd(16, ‘0’).padStart(‘sku’);
padEnd(16, ‘0’) produces ‘8675309000000000’ (original number followed by zeros).
padStart(‘sku’) is invalid usage:
padStart takes a numeric target length as the first argument, not a string.
Passing ‘sku’ as the first argument leads to type coercion that does not achieve the intended behavior.
This will not reliably produce the desired SKU.
Option C:
productSKU = productSKU.padEnd(16, ‘0’).padStart(19, ‘sku’);
First padEnd(16, ‘0’) from ‘8675309’ gives ‘8675309000000000’ (length 16, zeros at the end).
Then padStart(19, ‘sku’) adds 3 chars ‘sku’ at the front:
Result: ‘sku8675309000000000’.
This string starts with ‘sku’, but the zeros are at the end of the digits, not padding the numeric part on the left as desired.
Option D:
productSKU = productSKU.padStart(19, ‘0’).padStart(‘sku’);
First padStart(19, ‘0’) pads zeros at the left to make the length 19.
Then padStart(‘sku’) again incorrectly uses a string where a numeric targetLength is required.
This will not produce the correct SKU format.
Therefore, the only option that correctly uses padStart to create a 16-character zero-padded numeric portion and then a 19-character string starting with ‘sku’ is:
Reference / Study Guide concepts (no links):
String.prototype.padStart(targetLength, padString)
String.prototype.padEnd(targetLength, padString)
String length calculations
Left-padding numeric strings with zeros
Building prefixed identifiers with fixed total length
