Quiz

Question 1

What is an object in JavaScript, most precisely?

• AA collection of named properties, where a property is a key paired with a value
• BA blueprint that other values are made from
• CA special kind of array with string indexes
• DAn instance of a class

WhyA class is one way to make objects, and an object is not a blueprint; the blueprint is the class. Arrays are themselves objects, not the other way round.

Question 2

What does bus.owner evaluate to when the object has no owner property?

• Aundefined
• Bnull
• CIt throws a ReferenceError
• DAn empty string

WhyA missing property is undefined, and reading it is not an error. The error comes one step later, if you then read a property of that undefined.

Question 3

Which of these does const prevent?

• APointing the variable at a different object
• BChanging a property of the object
• CAdding a property to the object
• DDeleting a property from the object

Whyconst constrains the binding, not the value. Freezing the contents is Object.freeze.

Question 4

After const b = a where a is an object, what is true?

• ABoth names refer to the same object, so a change through either is visible through both
• Bb is an independent copy of a
• Cb is a shallow copy of a
• Db is frozen

WhyAssignment copies the reference. { ...a } gives a shallow copy; structuredClone(a) gives a deep one.

Question 5

What makes a function a "method"?

• ANothing except that it is stored as a property of an object
• BThe method keyword
• CBeing defined inside a class
• DTaking this as its first parameter

WhyThere is no distinction in the function itself. Where it is stored is the only difference.

Question 6

Given const f = obj.method; f(); in strict mode, what is this inside the call?

1
2
3
4
5
6
7
8const obj = {
  name: 'Jibowu park',
  method() { return this; },
};

const f = obj.method;
console.log(obj.method());
console.log(f());

• Aundefined
• Bobj
• CThe global object
• DThe function itself

WhyThere is no object before a dot at the call site, so there is no owner. Sloppy mode would have substituted the global object, which is the behaviour strict mode removed.

Question 7

Why should you never write an object literal method as an arrow function?

• AAn arrow has no this of its own, so it borrows the surrounding scope rather than the object
• BArrows cannot take parameters
• CArrows cannot be stored as properties
• DArrows are slower

WhyThe borrowing that makes arrows perfect as callbacks inside a method makes them useless as the method itself.

Question 8

Which fix keeps this correct when passing a method as a callback, using the exact same function object each time?

• AStore the result of .bind() once and reuse that reference
• BWrap the call in a new arrow each time
• CCall .bind() again at each use site
• DUse .call() instead

WhyEach .bind() returns a new function, so removeEventListener would not match one created inline. Store the bound version.

Question 9

What is the main advantage of a factory function over a class?

• AClosure variables give privacy, and it can return different shapes of object
• BIt is faster
• CIt supports inheritance
• Dinstanceof works on its results

Whyinstanceof is a class advantage, not a factory one. Factories win on closure privacy and on deciding what to return.

Question 10

What is the cost of a factory function that defines its methods inline?

• AEvery object gets its own copy of every method
• BThe methods cannot use this
• CThe objects cannot be passed to functions
• DIt cannot validate its arguments

WhyThis is exactly the problem prototypes solve, which is why class exists.

Question 11

Which is NOT one of the four things new does?

• ACopies the constructor function onto the new object
• BCreates a fresh empty object
• CLinks the object’s prototype to Ctor.prototype
• DCalls the constructor with this set to the new object

WhyNothing is copied. The link to Ctor.prototype is what gives the object access to the methods.

Question 12

What happens when you call a class without new?

• AA TypeError, always
• BIt works, and this is undefined
• CIt works, and this is the global object
• DIt returns undefined silently

WhyClasses have that check built in. Old constructor functions had to test new.target themselves.

Question 13

What does property lookup do when a property is not on the object?

• AWalks up the prototype chain until it finds it or reaches null
• BThrows immediately
• CChecks the class definition
• DSearches the global scope

WhyThis one mechanism is the whole of JavaScript inheritance.

Question 14

What is the difference between 'x' in obj and Object.hasOwn(obj, 'x')?

• Ain searches the prototype chain; hasOwn checks only the object itself
• BThey are identical
• Cin only works on arrays
• DhasOwn searches the chain; in does not

WhyWhen you are filtering out inherited members, Object.hasOwn is the one you want.

Question 15

What will this print, and why?

1
2
3
4
5
6
7
8
9function Bus(plate) { this.plate = plate; }
Bus.prototype.faults = [];

const a = new Bus('LAG-441-XA');
const b = new Bus('ABJ-772-KM');
a.faults.push('cracked windscreen');

console.log(a.faults);
console.log(b.faults);

• A["cracked windscreen"] for both, because the array lives on the prototype and is shared
• B["cracked windscreen"] then []
• C[] for both
• DIt throws

WhyAssignment writes to the instance, but push mutates the one shared array on the prototype. Per-instance state belongs in the constructor.

Question 16

In a class body, where do fields and methods end up?

• AFields on the instance, methods on the prototype
• BBoth on the instance
• CBoth on the prototype
• DFields on the prototype, methods on the instance

WhyData per object, behaviour shared. It is exactly the constructor-plus-prototype pattern from lesson 05.

Question 17

What separates members inside a class body?

• ANothing
• BCommas
• CSemicolons after every member
• DBlank lines

WhyA class body is not an object literal. A trailing comma after a method is a syntax error, and it is the most common typo when moving from literals to classes.

Question 18

What does JSON.stringify do with a #private field?

• AOmits it entirely
• BIncludes it under the name with the hash
• CIncludes it without the hash
• DThrows

WhyPrivate fields are invisible to Object.keys, spread and JSON.stringify alike. Use toJSON() when you need a specific serialised shape.

Question 19

What happens if you write obj.#field outside the class that declares it?

• AA SyntaxError, so the file will not even run
• BA TypeError at runtime
• CIt returns undefined
• DIt works

WhyThe restriction is enforced at parse time, which is stricter than most languages and why you cannot poke at private fields from the console.

Question 20

What does a leading underscore, as in this._balance, actually enforce?

• ANothing at all; it is a convention
• BRead-only access
• CPrivacy within the module
• DPrivacy within the class

WhyIt communicates intent to humans and nothing to the language. Use # in new code.

Question 21

When should a computed value be a getter rather than a method?

• AWhen it reads like a fact about the object and is cheap and side-effect free
• BAlways, getters are strictly better
• COnly when it takes no arguments and returns a string
• DNever, methods are clearer

WhyCallers assume reading a property is cheap and harmless. If it is slow or changes something, make it a method so the cost is visible.

Question 22

Why does this throw a RangeError about the call stack?

1
2
3
4
5
6
7
8class Broken {
  set label(value) {
    this.label = value.trim();
  }
}

try { new Broken().label = ' x '; }
catch (err) { console.log(err.name); }

• AAssigning to this.label inside the label setter calls the setter again, forever
• BSetters cannot take parameters
• CThe getter is missing
• Dtrim() is not a function

WhyStore in a differently named field, usually a private one, so the setter has somewhere to put the value.

Question 23

What should a getter do when it would otherwise return a private array?

• AReturn a copy, so callers cannot mutate internal state
• BReturn the array, since it is convenient
• CReturn its length instead
• DFreeze the array in place

WhyHanding out the real array undoes the encapsulation you built with the private field.

Question 24

Where does a static member live?

• AOn the class itself, reachable through the class name
• BOn every instance
• COn the prototype
• DOn the global object

WhyThat is why instance.staticThing is undefined: the instance chain leads to the prototype, not to the class.

Question 25

Inside a static method, what is this?

• AThe class the method was called on
• BThe instance
• Cundefined
• DThe prototype

WhyThis is why static make() { return new this(...) } keeps working in subclasses, where hard-coding the parent class name would not.

Question 26

What must a subclass constructor do before touching this?

• ACall super()
• BCall Object.create
• CAssign this.constructor
• DNothing in particular

Whythis does not exist until super() has run, and omitting the call entirely is also an error.

Question 27

What does super.method() do?

• ACalls the parent class’s version of the method, skipping your override
• BCalls the parent constructor
• CCreates a new parent instance
• DReturns the parent prototype

WhyIt is what lets an override extend the parent’s behaviour rather than replace it, as in [...super.checklist(), 'extra'].

Question 28

Which is the clearest sign that inheritance was the wrong tool?

• AA subclass has to throw from, or ignore, a method it inherited
• BThe subclass adds new methods
• CThe subclass overrides a method
• DThe parent has a constructor

WhyThat is a substitutability failure. Either the parent promised too much, or the relationship is "has a" rather than "is a".

Question 29

You have buses that may have air conditioning, may have a roof rack, or may have both. What does a class hierarchy force?

• ADuplicated code or a class per combination, because a chain classifies on one axis only
• BNothing; JavaScript supports multiple inheritance
• CUse of Object.assign in the constructor
• DA deeper chain, which solves it

WhyTwo independent axes of variation are the textbook signal for composition. Each capability becomes a part the object holds.

Question 30

Which SOLID principle does a growing switch (thing.type) in shared code violate first?

• AOpen/closed: adding a case means editing working code
• BSingle responsibility
• CLiskov substitution
• DInterface segregation

WhyThe fix is polymorphism: let each type answer for itself, so a new type is new code rather than an edit to old code.