* console.log( ' Start ' ) runs immediately (synchronous).
* Promise.resolve().then(...) places the callback in the microtask queue. The .then handler does not run immediately.
* console.log( ' End ' ) runs next (still synchronous).
* After the synchronous script finishes, the microtask queue runs, logging " Success " .
Execution order:
Start
End
Success
This matches option B .
JavaScript Knowledge References (text-only)
* Promise .then() callbacks execute after the current call stack finishes (microtask queue).
* Synchronous logs run immediately, before promise callbacks.

We have an array of plain objects:
[
{ name: ' John ' , email: ' [email protected] ' },
{ name: ' Jane ' , email: ' [email protected] ' },
{ name: ' Emily ' , email: ' [email protected] ' }
]
We want:
* A "visual representation" of the list.
* Ability to sort by name or email in DevTools.
console.table:
* console.table(data) renders data as a table in most browser devtools and Node consoles that support it.
* Each object becomes a row; properties (name, email) become columns.
* Many DevTools UIs allow:
* Clicking column headers to sort by that column.
* Filtering / viewing in a structured way.
So:
console.table(usersList);
Displays a sortable table of users by name or email. This matches the requirement exactly.
Other options:
* console.group(usersList);
* Starts a console group. The argument is just logged as a line label.
* It does not create a table or sortable view; it just groups subsequent logs.
* console.groupCollapsed(usersList);
* Same grouping behavior, but collapsed by default.
* Again, no table or sortable columns.
* console.info(usersList);
* Logs the array in the console, but as a standard log/info.
* You can expand objects, but there is no table view or built-in column sorting.
Therefore, the correct method is:
The answer: A
Study Guide / Concept References (no links):
* console.table for tabular logging
* console.group and console.groupCollapsed for grouped logs
* console.log / console.info standard logging behavior
* DevTools UI support for sorting columns in console.table

We already know NaN is special: it is not equal to itself.
Check each:
* A. value === Number.NaN
* Number.NaN is NaN.
* NaN === NaN is always false.
* This will never be true; cannot reliably detect NaN.
* B. value == NaN
* NaN == NaN is also always false.
* Again, this never detects NaN.
* C. isNaN(value)
* Global isNaN converts its argument to a number and then checks if the result is NaN.
* This can detect NaN, but it may also return true for non-number values that coerce to NaN, such as isNaN( ' foo ' ).
* Regardless, it is a standard way to detect if a value is "NaN-like" in JavaScript.
* D. Object.is(value, NaN)
* Object.is(NaN, NaN) returns true.
* This is a strict way to detect a value that is exactly NaN (no coercion).
Therefore, among the given choices, the two viable ways to detect NaN are:
* isNaN(value)
* Object.is(value, NaN)

Node.js includes a built-in command-line (CLI) debugger . To use it directly in the terminal, the standard command is:
node inspect server.js
This:
* Starts server.js under the Node.js inspector.
* Opens the CLI debugger right in the terminal window where you ran the command.
* Lets you interactively:
* Step through code
* Set breakpoints
* Inspect variables
* Continue execution, etc.
Why B is correct:
Option B (corrected to node inspect server.js) is exactly the standard Node.js command to run a script under the CLI debugger in the current terminal.
* It does not rely on any external GUI tools.
* You stay entirely in the terminal to debug.
Why the other options are incorrect:
* A. node start inspect server.js
* There is no start subcommand like this in standard Node.js CLI.
* This is not a valid Node.js debugging command.
* C. node server.js --inspect
* This starts Node.js with the Inspector protocol enabled and is typically used to connect external tools like Chrome DevTools or VS Code.
* It does not open the CLI debugger in the current terminal. Instead, it opens a debugging port that other tools attach to.
* The question specifically says "only using the terminal" and "open the CLI debugger in their current terminal window", which points to node inspect, not --inspect.
* D. node -i server.js
* -i starts Node in interactive REPL mode , optionally after running a script.
* This is for an interactive shell, not the Node debugger.
* It does not provide breakpoint/step/next/continue debugging features like the CLI debugger.
Therefore, the only option that opens the Node.js CLI debugger in the current terminal is:
The answer: B
JavaScript / Node.js knowledge / Study Guide references (concept names only, no links):
* Node.js CLI debugger: node inspect < script >
* Node.js inspector protocol: node --inspect
* Difference between CLI debugger and DevTools-based debugging
* Node.js command-line options and subcommands

* fullName is defined as a getter :
get fullName() { ... }
Getters are accessed like properties , not like functions.
So:
cat.fullName; // " Fancy Whiskers "
No parentheses.
Why others are wrong:
* A: cat.fullName() tries to call the returned string as a function.
* B and C: These properties (get, function) do not exist; they are misinterpretations of syntax.