BudiBaduQuiziBadu

JavaScript Basic Date Handling (Date object) Quiz

JavaScript
0 Passed
0% acceptance

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.

50 Questions
~100 minutes
1

Question 1

What does new Date() with no arguments represent?

A
The current date and time in the local timezone
B
The epoch date (Jan 1 1970 UTC)
C
Undefined
D
Throws an error
2

Question 2

Which constructor call creates a Date from milliseconds since the epoch?

A
new Date(1660000000000)
B
new Date("1660000000000ms")
C
new Date().milliseconds
D
Date.parse(1660000000000)
3

Question 3

What is the result of Date.parse("2023-01-15T00:00:00Z")?

A
A millisecond timestamp for that UTC instant
B
A Date object
C
The local date string
D
NaN always
4

Question 4

How do you create a Date for March 5 2024 at noon local time?

A
new Date(2024, 2, 5, 12, 0, 0)
B
new Date(2024, 3, 5, 12, 0, 0)
C
new Date("2024,2,5,12")
D
Date.march(2024,5,12)
5

Question 5

Which method returns the number of milliseconds since Jan 1 1970 UTC for a Date instance?

A
date.getTime()
B
date.valueOfSeconds()
C
date.timestamp()
D
Date.epoch()
6

Question 6

What does Date.now() return?

A
Current timestamp in milliseconds as a number
B
A Date object
C
Seconds since epoch
D
The ISO string
7

Question 7

How do you create a Date from an ISO string?

A
new Date("2024-02-01T10:30:00Z")
B
Date.iso("2024-02-01")
C
Date.formatISO(...)
D
new DateISO(...)
8

Question 8

What is returned by new Date().toString()?

A
A human-readable local time string with timezone information
B
An ISO string
C
Milliseconds since epoch
D
UTC timestamp only
9

Question 9

Which Date constructor takes year, month, day, hours, minutes, seconds, milliseconds?

A
new Date(year, monthIndex, day, hours, minutes, seconds, ms)
B
new Date(day, month, year...)
C
Date.utc(...)
D
Date.parseComponents(...)
10

Question 10

Which Date creation method avoids implicit string parsing pitfalls?

A
Pass explicit numeric arguments or ISO strings to new Date
B
Pass custom formatted strings like "02/30/2024"
C
Use Date.parse on locale strings
D
Rely on Date("March 5th")
11

Question 11

Which method retrieves the month (0-11) from a Date?

A
date.getMonth()
B
date.getUTCMonthIndex()
C
date.month
D
date.getMonthIndex()
12

Question 12

How do you get the day of the week?

A
date.getDay()
B
date.day
C
date.dayOfWeek()
D
date.getWeekday()
13

Question 13

Which method returns the full year?

A
date.getFullYear()
B
date.getYear()
C
date.fullYear
D
date.year
14

Question 14

How do you retrieve the hours portion in local time?

A
date.getHours()
B
date.hours
C
date.getUTCHours()
D
date.getHourLocal()
15

Question 15

Which method changes the minutes field?

A
date.setMinutes(value)
B
date.minutes = value
C
date.setMinuteField(value)
D
Date.setMinutes(date, value)
16

Question 16

What does date.setDate(date.getDate() + 1) accomplish?

A
Adds one day while handling overflow to the next month if needed
B
Only changes the day field without adjusting the month
C
Throws an error if day exceeds month length
D
Always sets date to 1
17

Question 17

How do you extract milliseconds?

A
date.getMilliseconds()
B
date.milliseconds
C
date.getMS()
D
Date.milliseconds(date)
18

Question 18

What does date.toDateString() output?

A
A human-readable date portion without time
B
The ISO string
C
Milliseconds since epoch
D
UTC timestamp
19

Question 19

Which method returns the timezone offset in minutes from UTC?

A
date.getTimezoneOffset()
B
date.timezone
C
date.getUTCOffset()
D
date.offsetMinutes
20

Question 20

How do you produce a locale-aware short date string?

A
date.toLocaleDateString()
B
date.toISODateString()
C
Date.localeDate(date)
D
date.localeString("short")
21

Question 21

What does this code log?

javascript
const ts = Date.now()
console.log(typeof ts)
A
"number"
B
"string"
C
"object"
D
"date"
22

Question 22

What is the output?

javascript
const date = new Date('2024-01-01T00:00:00Z')
console.log(date.toISOString())
A
2024-01-01T00:00:00.000Z
B
A locale string
C
Milliseconds since epoch
D
Throws TypeError
23

Question 23

How do you add 2 days to a Date?

javascript
const date = new Date('2024-03-10T12:00:00Z')
date.setDate(date.getDate() + 2)
A
date now represents March 12 2024
B
date remains unchanged
C
A new Date is returned
D
Throws due to DST
24

Question 24

What does Date.parse("invalid") return?

javascript
console.log(Date.parse('invalid'))
A
NaN
B
0
C
Throws SyntaxError
D
A Date object
25

Question 25

How do you get the difference in milliseconds between two dates?

javascript
const start = new Date('2024-01-01')
const end = new Date('2024-01-10')
const diff = end - start
A
diff equals milliseconds between dates because Date objects coerce to timestamps
B
diff is NaN
C
diff is a Date object
D
diff is a string
26

Question 26

What does date.getUTCFullYear() return compared to getFullYear()?

javascript
const date = new Date('2023-12-31T23:00:00-02:00')
console.log(date.getFullYear(), date.getUTCFullYear())
A
Local year may differ from UTC year near midnight boundaries
B
Both always match
C
UTC method throws
D
getUTCFullYear returns timezone offset
27

Question 27

Which snippet clones a Date?

javascript
const copy = new Date(original.getTime())
A
Creates an independent Date with the same timestamp
B
Creates a reference to the same object
C
Throws because Date cannot be cloned
D
copy is undefined
28

Question 28

What is logged here?

javascript
const date = new Date('2024-01-01T00:00:00Z')
console.log(date.toUTCString())
A
A human-readable UTC date string (e.g., Mon, 01 Jan 2024 00:00:00 GMT)
B
Locale string
C
ISO string
D
Milliseconds
29

Question 29

What does date.toISOString().slice(0, 10) provide?

javascript
const date = new Date('2024-04-25T10:15:00Z')
console.log(date.toISOString().slice(0, 10))
A
The YYYY-MM-DD portion of the ISO string (2024-04-25)
B
The local date
C
Timezone offset
D
Milliseconds
30

Question 30

What happens when you pass a Date to JSON.stringify?

javascript
const obj = { createdAt: new Date('2024-02-01T12:00:00Z') }
console.log(JSON.stringify(obj))
A
Dates are serialized as ISO strings by default
B
Dates are removed
C
Dates become timestamps
D
Serialization throws
31

Question 31

How do you convert a timestamp to seconds?

javascript
const seconds = Math.floor(Date.now() / 1000)
A
Divide milliseconds by 1000 and floor to get integer seconds
B
Use Date.seconds()
C
Call getSeconds on Date.now
D
Use date.toSeconds()
32

Question 32

What does Date.UTC(y, m, d, h, min, s) return?

javascript
const ts = Date.UTC(2024, 0, 1, 0, 0, 0)
console.log(ts)
A
Milliseconds timestamp representing the UTC date
B
A Date object
C
A locale string
D
NaN
33

Question 33

What is the result?

javascript
const date = new Date('2024-03-10T02:30:00')
date.setHours(date.getHours() + 1)
console.log(date.toString())
A
Adds an hour even across DST boundaries; local time adjusts accordingly
B
Throws due to DST
C
SetHours is unavailable
D
Time stays identical
34

Question 34

How do you format a Date with Intl.DateTimeFormat?

javascript
const formatter = new Intl.DateTimeFormat('en-US', { dateStyle: 'medium', timeStyle: 'short' })
console.log(formatter.format(new Date('2024-05-01T15:45:00Z')))
A
Outputs a localized string such as "May 1, 2024, 11:45 AM" depending on timezone
B
Always outputs ISO string
C
Throws due to options
D
Returns milliseconds
35

Question 35

What does this comparison log?

javascript
const a = new Date('2024-01-01T00:00:00Z')
const b = new Date('2024-01-01T12:00:00Z')
console.log(a < b)
A
true because date objects compare by numeric timestamp
B
false because objects cannot be compared
C
Throws TypeError
D
Compares string representations
36

Question 36

What does date.toLocaleString("en-GB", { timeZone: "UTC" }) do?

A
Formats the date/time in the specified locale while forcing UTC timezone
B
Converts the Date object to UTC permanently
C
Throws if timezone is provided
D
Ignores the locale
37

Question 37

Which method returns the UTC date (day of month)?

A
date.getUTCDate()
B
date.getUTCDayOfMonth()
C
date.getUTCDay()
D
date.utcDate
38

Question 38

What is a common pitfall of Date parsing in JavaScript?

A
Locale-dependent strings may parse differently across browsers
B
ISO strings are unsupported
C
Date.parse always throws
D
Date cannot parse numbers
39

Question 39

Why should you avoid mutating Date objects shared across code?

A
Dates are mutable; accidental set operations can ripple through shared references
B
Dates throw on mutation
C
Dates auto-clone when passed
D
Dates cannot be mutated at all
40

Question 40

What is a safe way to compare only the date portion of two Date objects?

A
Compare date.toDateString() values or zero out time components before comparing timestamps
B
Compare getTime directly without adjustments
C
Compare getMilliseconds only
D
Use Date.equals method
41

Question 41

What challenge does daylight saving time introduce?

A
Adding hours across DST boundaries can skip or repeat local times
B
UTC methods stop working
C
Date.now breaks
D
ISO strings become invalid
42

Question 42

What is returned by new Date("2024-01-01").getTimezoneOffset()?

A
Minutes difference between local timezone and UTC on that date
B
Always 0
C
Hours difference as a float
D
Milliseconds difference
43

Question 43

Why can new Date("02/03/2024") be ambiguous?

A
Different locales interpret month/day order differently
B
Date cannot parse numeric strings
C
ISO requires hyphens
D
JavaScript disallows slashes
44

Question 44

How do you convert a Date to a timestamp in seconds?

A
Math.floor(date.getTime() / 1000)
B
date.toSeconds()
C
date.seconds
D
Date.seconds(date)
45

Question 45

Which method yields a JSON-friendly string?

A
date.toJSON()
B
date.toLocaleString()
C
date.customFormat()
D
date.stringify()
46

Question 46

What does Date.prototype.valueOf return?

A
The numeric timestamp (same as getTime)
B
Locale string
C
Date object
D
UTC string
47

Question 47

Why is storing Date objects in JSON problematic?

A
Dates serialize to strings; you must parse them back when reading
B
JSON cannot store strings
C
JSON automatically stores timestamps
D
Dates mutate JSON
48

Question 48

Which practice avoids implicit timezone conversions when comparing two dates?

A
Compare their timestamps via getTime or valueOf
B
Compare toLocaleString outputs
C
Compare Date.toString values
D
Compare month names
49

Question 49

How do you get a UTC ISO string without milliseconds?

A
date.toISOString().replace(/\.\d{3}Z$/, "Z")
B
date.toUTCString()
C
date.toJSONNoMs()
D
date.toISOString().milliseconds(false)
50

Question 50

What is a best practice when performing Date arithmetic?

A
Work with timestamps (milliseconds) and create new Date objects as needed
B
Mutate shared Date instances everywhere
C
Rely on implicit string parsing for math
D
Avoid UTC methods entirely

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.