JS-Dev-101 Exam Preparation Material | Salesforce Certified JavaScript Developer

Explanation:
Comprehensive and Detailed Explanation From Exact Extract JavaScript Knowledge: JavaScript consoles (browsers and Node) provide timing utilities: console.time(label) C starts a timer with the given label. console.timeEnd(label) C stops the timer and logs the total elapsed time. console.timeLog(label) C logs the current elapsed time without stopping the timer.
To measure the time taken by each function separately while still using a single overall timer, you can log intermediate times:
console.time('Performance');
maybeAHeavyFunction();
console.timeLog('Performance', 'after maybeAHeavyFunction');
thisCouldTakeTooLong();
console.timeLog('Performance', 'after thisCouldTakeTooLong');
orMaybeThisOne();
console.timeLog('Performance', 'after orMaybeThisOne');
console.timeEnd('Performance');
Each console.timeLog('Performance') call prints the elapsed time since console.time('Performance') was started, so you can infer how long each function took.
Note: console.endTime in the original snippet is incorrect; the real method is console.timeEnd.
Why other options are incorrect:
B. console.trace()
Prints a stack trace, not timing information.
C. console.timeStamp()
Used with browser performance tools; it does not directly show elapsed times like timeLog or timeEnd.
D. console.getTime()
Not a standard console method.
Thus, the function that can be used to obtain timing between calls is:
Answer A
Study Guide Concepts:
console.time, console.timeLog, console.timeEnd
Measuring performance and intermediate timings
Standard console debugging API methods

Explanation:
Comprehensive and Detailed Explanation From Exact Extract JavaScript Knowledge getAttribute('value')
This returns the initial HTML attribute, not the live, updated value.
Even if the user edits the text, the value attribute remains "Hello" because HTML attributes do not update dynamically.
Input elements have a property value that always reflects the live current text inside the field.
So:
input.value
returns the user-entered value.
Therefore, line 04 must use the property, not the attribute:
console.log(input.value);
This ensures the updated input value is displayed.
JavaScript knowledge references (text-only)
HTML attributes are static and retrieved using getAttribute().
DOM element properties (like value) represent the current live state.
Input value changes update the .value property, not the attribute.

Explanation:
Comprehensive and Detailed Explanation From Exact Extract JavaScript Knowledge objA is created with:
{ value: 10 } objB = objA;
Objects in JavaScript are assigned by reference, not copied. So objA and objB refer to the same object in memory.
The function: changeValue(obj) { obj.value = obj.value / 2;
}
When called as changeValue(objB), it updates the value property of the shared object:
value = 10 / 2 → 5
Therefore:
objA.value === 5
Because objA and objB refer to the same object, the change is reflected in both.
JavaScript Knowledge Reference (text-only)
Objects are stored and passed by reference.
Mutating an object inside a function mutates the original object.

Explanation:
Comprehensive and Detailed Explanation From JavaScript Knowledge:
We must track synchronous code, setTimeout callbacks (macrotasks), and Promise rejection handling (microtasks).
Step-by-step:
Synchronous code first:
Line 01C03: Schedules a timeout at 1100 ms: logs 1 (later).
Line 04: console.log(2); → logs 2.
Lines 05C09: Construct a new Promise.
The executor runs immediately.
Inside it, another setTimeout is set for 1000 ms:
setTimeout(() => {
reject(console.log(3));
}, 1000);
Line 09C11: .catch(() => { console.log(4); }) attached to the promise.
Line 12: console.log(5); → logs 5.
So after all synchronous code, the console has:
2
5
At 1000 ms: inner setTimeout fires
The callback:
()=>{
reject(console.log(3));
}
Inside:
console.log(3) runs first, logging 3.
console.log(3) returns undefined.
Then reject(undefined) is called.
So at about 1000 ms, we log:
3
When the promise is rejected:
The .catch handler is scheduled as a microtask.
After the current macrotask (the timeout callback) completes, the microtask queue runs.
Thus .catch(() => { console.log(4); }) runs shortly after, in the same 1000 ms tick.
So immediately after 3, the catch handler logs:
4
Now the logs in order are:
2
5
3
4
At 1100 ms: outer setTimeout fires
The callback from line 01 runs:
console.log(1);
Logs: 1.
Final log order:
2 (line 4, sync)
5 (line 12, sync)
3 (1000 ms timeout, then inside logs before reject)
4 (promise catch microtask after rejection)
1 (1100 ms timeout)
Concatenated: 25341.
Therefore, the correct option is:
Answer A
Study Guide / Concept Reference (no links):
Event loop: call stack, macrotask queue (timers), microtask queue (promises)
setTimeout scheduling and ordering
Promise rejection, .catch, and microtasks
Evaluation order of function arguments (reject(console.log(3)))