BudiBaduQuiziBadu

JavaScript Console API (log, error, table) Quiz

JavaScript
0 Passed
0% acceptance

Explore 40 questions that cover console.log, console.error, console.table, message formatting, styling, grouping, timing, assertions, debugging workflows, clearing output, and practical logging best practices in JavaScript.

40 Questions
~80 minutes
1

Question 1

What is the console API primarily used for?

A
Inspecting and logging information during development
B
Styling HTML elements directly
C
Serving static assets
D
Declaring CSS variables
2

Question 2

Which statement describes console.log?

A
It prints informational messages to the console
B
It throws errors to halt execution
C
It formats HTML elements
D
It clears localStorage
3

Question 3

Which placeholder inserts a string when using console.log formatting?

A
%s
B
%d
C
%f
D
%o
4

Question 4

Which console method reports error-level logs with stack traces in most browsers?

A
console.error
B
console.info
C
console.count
D
console.clear
5

Question 5

What does this snippet produce?

javascript
const users = [
  { id: 1, name: 'Ana' },
  { id: 2, name: 'Raj' }
]
console.table(users)
A
A table with id and name columns for each user
B
A JSON string
C
An error about console.table
D
Only the first user printed
6

Question 6

Which placeholder highlights numbers in console.log?

A
%d or %i
B
%c
C
%s
D
%O
7

Question 7

How can you style console output with CSS?

A
Use console.log("%cStyled", "color: red")
B
Attach a stylesheet to console
C
Call console.style
D
Use HTML tags directly
8

Question 8

Which technique helps highlight variable names next to their values?

javascript
const total = 42
console.log({ total })
A
It prints { total: 42 } making the label obvious
B
It prints 42 without context
C
It clears the console
D
It throws because objects cannot be logged
9

Question 9

What is a benefit of logging template literals?

A
They make multi-line logs and embed expressions cleanly
B
They persist logs to disk
C
They auto-hide secrets
D
They disable console.error
10

Question 10

Which practice keeps console output organized?

A
Prefix messages with contextual tags like [Auth] or [Cart]
B
Disable logging entirely
C
Console log every variable change
D
Throw errors instead of logging
11

Question 11

Which method prints an object with its properties expanded immediately?

javascript
const user = { id: 7, name: 'Mina', meta: { active: true } }
console.dir(user)
A
console.dir shows the full object tree for inspection
B
console.dir throws because objects must be stringified
C
console.dir clears the console
D
console.dir minifies the object
12

Question 12

What is the advantage of logging a Map with console.table?

A
It displays key/value pairs in rows for quick inspection
B
It sorts keys alphabetically by default
C
It serializes the Map to JSON automatically
D
It hides duplicate entries
13

Question 13

Which method counts how many times a label has been logged?

A
console.count
B
console.time
C
console.assert
D
console.group
14

Question 14

What output results from this code?

javascript
const foo = 'A'
const bar = 3
console.log({ foo, bar })
A
{ foo: "A", bar: 3 }
B
"A3"
C
["A", 3]
D
undefined
15

Question 15

Why should sensitive data be filtered before logging objects?

A
Console histories can persist and expose secrets to others
B
Logging automatically encrypts secrets
C
console.log uploads data to the server
D
Objects cannot be logged otherwise
16

Question 16

What does the following produce?

javascript
console.log('%cWarning', 'color: orange; font-weight: bold')
A
The word Warning styled in orange bold text
B
Plain text "Warning"
C
An error message
D
CSS injected into the page
17

Question 17

What is printed here?

javascript
console.group('Auth')
console.log('Login start')
console.groupEnd()
A
Login start indented under an "Auth" label
B
Only Login start
C
An error about group usage
D
Nothing
18

Question 18

Given the code, what is displayed?

javascript
console.groupCollapsed('Data')
console.log('Fetch users')
console.log('Fetch posts')
console.groupEnd()
A
A collapsed "Data" group containing two logs
B
All logs expanded by default
C
Only the first log
D
SyntaxError
19

Question 19

What happens if console.groupEnd is called without a matching console.group?

A
Most consoles ignore the call and continue logging
B
A SyntaxError is thrown
C
The console clears automatically
D
The browser crashes
20

Question 20

Which scenario benefits from console.group?

A
Logging related steps (start, success, failure) under one collapsible label
B
Clearing all logs
C
Measuring code execution time
D
Counting function calls
21

Question 21

What is output here?

javascript
console.time('fetch')
// ... async work
console.timeEnd('fetch')
A
fetch: <duration> ms
B
The async result value
C
Nothing
D
An error
22

Question 22

What happens if console.timeEnd is called with a label that was never started?

A
Most browsers warn that the label does not exist
B
It throws a SyntaxError
C
It clears the console
D
It silently starts a timer
23

Question 23

What does the following assert do?

javascript
console.assert(Array.isArray(users), 'Users must be an array')
A
Logs the message only if the condition is false
B
Throws an exception
C
Always logs the message
D
Clears the console
24

Question 24

Why use console.time when profiling specific blocks?

javascript
console.time('task')
expensiveWork()
console.timeEnd('task')
A
It prints how long expensiveWork took without setting breakpoints
B
It throws if the function is slow
C
It replaces the Performance API entirely
D
It cancels expensiveWork
25

Question 25

What is a drawback of leaving console.time in production code?

A
Excessive timers create noise and can reveal implementation details
B
Browsers crash immediately
C
Promises stop working
D
CSS breaks
26

Question 26

What does this snippet produce?

javascript
try {
  throw new Error('Failed to save')
} catch (err) {
  console.error('Save error:', err)
}
A
A red error log with the message and stack trace
B
A browser alert
C
An automatic retry
D
No output
27

Question 27

When should console.error be preferred over console.log?

A
When the message indicates a failure that needs attention
B
When logging feature flags
C
When measuring timing
D
When clearing the console
28

Question 28

How can console.table support debugging API responses?

A
By revealing nested arrays or objects per row, making anomalies obvious
B
By hiding all null values
C
By caching the response
D
By retrying the request
29

Question 29

Why is console.log often replaced with debugger statements during deep investigation?

A
Debugger pauses execution so you can inspect state interactively
B
Debugger speeds up code
C
Debugger writes to disk
D
Debugger blocks console usage
30

Question 30

What is a common best practice after finishing debugging?

A
Remove or guard console statements to avoid cluttering production logs
B
Leave all console logs to help users
C
Convert logs to alerts
D
Wrap logs in eval
31

Question 31

What happens when running this snippet?

javascript
console.log('A')
console.clear()
console.log('B')
A
Only "B" remains visible in most devtools
B
Both logs remain
C
An error occurs
D
The browser reloads
32

Question 32

What is the result of console.count("api") repeated three times?

A
api: 1, api: 2, api: 3
B
1, 2, 3 without labels
C
A table of counts
D
No output
33

Question 33

What does console.countReset("api") do?

A
Resets the counter for label "api" to zero
B
Clears the console
C
Starts a timer
D
Throws an error
34

Question 34

Which method outputs a warning with stack trace but lower severity than console.error?

A
console.warn
B
console.assert
C
console.table
D
console.trace
35

Question 35

What does console.trace do?

A
Prints the current call stack without throwing
B
Clears the console
C
Starts a CPU profile
D
Measures time
36

Question 36

Why avoid leaving verbose console.log statements in production?

A
They can expose sensitive data and hurt performance
B
Browsers ban console.log in production
C
They disable CSS
D
They reduce screen resolution
37

Question 37

Which approach makes console logging configurable?

A
Wrap console methods in a logger that checks environment flags
B
Use eval to toggle logs
C
Replace console with alert
D
Disable devtools
38

Question 38

How can console.assert improve defensive programming?

A
It calls out unexpected states without stopping execution
B
It retries failed requests
C
It encrypts logs
D
It automatically fixes bugs
39

Question 39

What is a best practice when combining console.log with objects?

A
Use shallow clones or structured logging to avoid mutating the logged object later
B
Log the same object repeatedly to ensure accuracy
C
Convert objects to strings manually
D
Use console.clear before each log
40

Question 40

Which guideline keeps console usage sustainable?

A
Define logging levels and remove noisy logs before shipping
B
Never log errors
C
Log every function entry and exit in production
D
Rely solely on console.error

Other Quiz Categories

Rust
30 quizzes
Cargo and Project Setup
Variables and Mutability
Data Types
Python
29 quizzes
Introduction & Core Fundamentals
Data Types Overview
Type Casting
Golang
29 quizzes
Basics & Syntax
Data Types & Zero Values
Operators & Expressions
C++
26 quizzes
Basics
Variables & Data Types
Operators & Expression
Java
22 quizzes
Java Basics & JVM Fundamentals
Variables, Data Types & Type Casting
Operators & Expressions
Matlab
21 quizzes
Basics & Environment
Variables and Data Type
Arrays and Matric
TypeScript
19 quizzes
Introduction and Overview
Installation and Configuration
Basic Types and Type Annotations
SQL Database
15 quizzes
Foundations and Basics
Basic Query Selection
Filter, Sort, and Alias Essentials
PHP
15 quizzes
Syntax Building Blocks
Variable Naming
Data Types Overview
Linked List
11 quizzes
Introduction
Node Structure and Pointer Fundamentals
Singly Linked List

QUIZZES IN JavaScript

1

Basics

40

A beginner-friendly quiz to evaluate your understanding of core JavaScript fundamentals including variables, data types, operators, and foundational syntax. This quiz builds the base for mastering more advanced JavaScript concepts.

2

Variables & Data Types

50

A focused JavaScript quiz dedicated to variables, scope, primitive values, reference types, and type conversion. Use this set to check how well you understand declarations, assignments, comparison rules, and everyday runtime behaviour.

3

Operators & Expressions

50

A detailed JavaScript quiz exploring arithmetic, comparison, logical, bitwise, and assignment operators through practical expressions and tricky evaluation scenarios.

4

Strings & String Methods

75

Tackle 75 JavaScript string challenges that cover formatting, slicing, searching, pattern matching, and Unicode-safe manipulation to solidify everyday text-processing skills.

5

Numbers & Math Operations

75

Master 75 JavaScript questions that cover numeric literals, parsing, formatting, math utilities, and the edge cases every engineer hits when working with numbers.

6

Arrays & Basic Array Methods

100

Tackle 100 JavaScript array questions that range from everyday indexing to tricky splice mutations and iteration strategies. Forty questions supply runnable code so you can reason through exact behaviour before answering.

7

Objects & Key/Value Manipulation

75

Explore 75 JavaScript object questions that cover construction, property access, mutation, introspection, cloning, and immutability. Thirty questions include runnable snippets so you can reason through exact behaviour before answering.

8

Control Flow (if, else, switch)

50

Explore 50 JavaScript control-flow questions covering branching, truthiness, equality pitfalls, nested decisions, switch mechanics, fallthrough, and short-circuit expressions. Twenty questions include runnable snippets so you can reason about exact evaluation before answering.

9

Functions & Parameters

50

Explore 50 JavaScript function questions covering declarations, expressions, arrow functions, scopes, parameters, defaults, rest arguments, return values, closures, and execution flow.

10

Boolean Logic & Truthy/Falsy

50

Explore 50 JavaScript questions covering boolean values, logical operators, comparison pitfalls, truthy/falsy coercion, short-circuit flow, optional chaining, nullish coalescing, ternaries, and real-world conditional patterns.

11

Type Conversion & Coercion

50

Explore 50 JavaScript questions that test implicit coercion, explicit casts, string and number conversions, truthy/falsy evaluations, equality quirks, arithmetic side effects, ToPrimitive algorithms, JSON behavior, and the most common pitfalls developers hit when the engine reshapes data types.

12

Basic Error Types (SyntaxError, TypeError)

40

Explore 40 JavaScript questions covering SyntaxError definitions, parsing mistakes, prevention strategies, TypeError causes, undefined versus null access issues, strict mode implications, debugging stacks, try/catch usage, and best practices for runtime resilience.

13

Console API (log, error, table)

40

Explore 40 questions that cover console.log, console.error, console.table, message formatting, styling, grouping, timing, assertions, debugging workflows, clearing output, and practical logging best practices in JavaScript.

14

Basic Debugging in Browser DevTools

30

Understand 30 questions covering how to open DevTools, inspect the DOM, use the console, set and manage breakpoints, step through code, inspect the call stack, monitor network calls, leverage overrides, analyze performance and memory, debug event listeners, and work in responsive design mode.

15

Math Object & Random Numbers

50

Explore 50 JavaScript questions covering Math constants, rounding methods, min/max, exponentiation, roots, absolute values, sign detection, trig/log functions, random generation, range helpers, conceptual seeding, randomization patterns, and performance tips for numerical code.

16

Array Iteration Essentials (forEach)

40

Cover 40 questions on how Array.forEach works, callback parameters, side effects, mutation patterns, differences versus loops and map/filter, thisArg usage, arrow callbacks, early-exit limitations, nested iterations, object handling, common patterns, debugging techniques, and best practices.

17

Basic Date Handling (Date object)

50

Answer 50 questions on JavaScript Date basics: creating instances, timestamps, extracting components, setting values, parsing strings, basic formatting, Date.now, arithmetic, time zones, UTC helpers, comparisons, ISO conversion, and common pitfalls.

18

Intro to DOM (querySelector & textContent)

40

Answer 40 questions covering DOM fundamentals, document structure, element selection with querySelector/querySelectorAll, CSS selector usage, reading and updating textContent, handling null results, safe DOM manipulation, and best practices.

19

Prototype & Inheritance

75

Tackle 75 questions covering prototype chain fundamentals, __proto__ vs prototype, constructor functions, adding and overriding prototype methods, Object.create patterns, class syntax with extends/super, distinguishing instance vs prototype data, checking inheritance relationships, understanding this, performance considerations, pitfalls, and best practices.

20

Classes & OOP

50

Work through 50 questions on class syntax, constructors, instance and static members, getters/setters, inheritance with extends/super, private fields, composition vs inheritance, using this, creating multiple instances, basic design patterns, and best practices.

21

Modules (import/export)

50

Answer 50 questions on ES modules: named vs default exports, import syntax variations, renaming, exporting functions/classes/constants, re-exporting, module scope, namespace imports, dynamic import(), browser/module loading, resolution rules, Node.js ESM/CommonJS, bundling basics, and best practices.

22

Error Handling (try, catch, finally)

40

Tackle 40 questions on why try/catch exists, how to structure catch/finally blocks, inspecting error objects, throwing custom errors, handling specific cases, nesting handlers, and modern best practices.

23

Asynchronous JS (Callbacks)

75

Answer 75 questions on asynchronous JavaScript callbacks: fundamentals, error-first patterns, execution order, callback hell, timers, DOM and I/O callbacks, higher-order functions, data passing, chaining, and modern replacements like Promises.

24

Promises & Promise Chaining

40

Tackle 40 questions about JavaScript Promises: states, creating promises, then/catch/finally, value chaining, error propagation, avoiding callback hell, Promise.all, Promise.race, and coordinating multiple async operations.

25

Async/Await Deep Understanding

40

Answer 40 questions on async/await internals: how async functions work, await behavior, try/catch error handling, sequential vs parallel flows, awaiting multiple promises, mixing with raw promises, event loop interaction, return values, pitfalls, and best practices.

26

Execution Context

40

Dive into 40 questions covering how JavaScript builds global and function execution contexts, creation and execution phases, lexical and variable environments, scope chains, hoisting, this binding, and call stack behavior.

27

Hoisting & Temporal Dead Zone

40

Tackle 40 questions covering hoisting concepts, var behavior, function declaration hoisting, function expressions, let/const characteristics, temporal dead zone pitfalls, runtime errors, and best practices.

28

Closures & Lexical Environment

40

Study 40 JavaScript questions on lexical scoping, scope chains, closure creation, accessing outer variables, state preservation, memory considerations, and avoiding accidental closures.

29

Scope Types (Global, Block, Function)

30

Learn 30 questions that analyze JavaScript global scope, function scope, block scope, var quirks, visibility rules, shadowing, scope chains, and best practices for managing identifiers.

30

Event Loop & Microtasks Introduction

50

Answer 50 questions about the JavaScript event loop, call stack, macrotasks, microtasks, promise timing, rendering, async APIs, starvation risks, and debugging workflows.

31

Advanced Array Methods (map, filter, reduce)

35

Answer 35 questions that dive into map transformations, filter logic, reduce accumulations, callback signatures, immutability, chaining, patterns, performance trade-offs, and behavior comparisons.

32

Spread & Rest Operator Deep Usage

35

Answer 35 questions exploring spread on arrays and objects, cloning behavior, combining collections, rest parameters, destructuring techniques, pitfalls, performance trade-offs, and modern practical patterns.

33

6 Destructuring Use Cases (Nested, Default)

30

Tackle 30 questions on nested object/array destructuring, defaults, renaming bindings, destructuring parameters, and skipping positions.

34

Template Literals Advanced (Tagged Templates)

35

Answer 35 questions digging into template literal basics, tagged function mechanics, string/value processing, security sanitization, custom formatting, localization, DSL construction, and performance trade-offs.

35

Regular Expressions Basics

35

Answer 35 questions covering regex literal vs constructor syntax, metacharacters, character classes, quantifiers, anchors, grouping, escaping, and JS testing/matching methods.

36

Shallow vs Deep Copying Objects

30

Answer 30 questions comparing shallow copy techniques, deep copy strategies, spread/Object.assign behavior, JSON and structuredClone approaches, reference vs value semantics, and common pitfalls like cyclic structures.

37

JSON Handling (stringify, parse pitfalls)

40

Answer 40 questions covering JSON.stringify basics, JSON.parse behavior, handling undefined and functions, circular structure errors, Date serialization, number precision, reviver/replacer usage, and safe parsing practices.

38

DOM Events Bubbling & Capturing

30

Answer 30 questions on event propagation phases, capturing basics, target behavior, bubbling mechanics, addEventListener options, stopping propagation, preventing default actions, and event delegation techniques.

39

Performance Optimization Techniques

35

Answer 35 questions on minimizing reflows, debouncing/throttling, faster loops, efficient structures, avoiding leaks, web workers, lazy loading, caching, cutting re-renders, and profiling with DevTools.

40

Iterators & Generators (yield, next, custom iterators)

35

Answer 35 questions covering iterator protocol basics, next() behavior, iterable objects, generator syntax, yield mechanics, execution control, passing values, custom iterators, lazy generator use cases, and async-iterator differences.

41

Async Iteration & for-await-of

35

Answer 35 questions covering the async iterator protocol, Symbol.asyncIterator, async generator syntax, yield vs yield*, promise handling, for-await-of mechanics, error management, streaming data scenarios, and using async generators with fetch.

42

Debounce & Throttle Patterns

35

Answer 35 questions covering debounce timing, throttle intervals, leading/trailing triggers, preventing noisy events, scroll/input use cases, manual implementations, pitfalls, and UI performance gains.

43

Shadow DOM & Web Components Basics

35

Answer 35 questions on custom element fundamentals, shadow DOM encapsulation, open vs closed roots, templates and slots, style isolation, lifecycle callbacks, reusable component design, and light/shadow DOM interaction.

44

Intersection Observer

35

Answer 35 questions covering observers and targets, threshold/rootMargin tuning, lazy-loading patterns, visibility detection, cleanup best practices, entry properties, performance wins vs scroll events, and common use cases like infinite scroll, animations, and analytics.

45

MutationObserver: Watching DOM Changes

35

Test your knowledge with 35 questions on MutationObserver—covering DOM observation, configuration options, attribute and child tracking, subtree monitoring, mutation records, cleanup, performance, and real-world use cases.

46

Browser Rendering Pipeline

35

Test your understanding of how browsers render web pages with 35 questions covering HTML/CSS/JS parsing, the Critical Rendering Path, layout, painting, compositing, and performance optimizations.

47

Security Basics

40

Test your knowledge with 40 questions on web security fundamentals—covering XSS types, prevention strategies, CSRF mechanics, and defense techniques like tokens, SameSite cookies, and Content Security Policy.