Duck typing mental model in TypeScript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is duck typing in TypeScript?

Duck typing means that if an object has all the required properties and methods, it is considered to be of that type, regardless of its actual class or inheritance.

beginner

How does TypeScript check types with duck typing?

TypeScript checks if an object has the necessary shape (properties and methods) to match a type, not if it explicitly declares that type.

beginner

Example: If an object has a 'name' string property and a 'speak()' method, can it be used where a type with those members is expected?

Yes, because the object matches the shape required by the type, TypeScript allows it even if the object does not explicitly implement that type.

intermediate

Why is duck typing useful in TypeScript?

It allows flexible and easy code reuse by focusing on what an object can do rather than its exact type or class.

intermediate

Can duck typing cause errors if an object has extra properties?

No, TypeScript allows extra properties as long as the required ones exist, but excess property checks apply in some cases like object literals.

In TypeScript, what does duck typing check for?

A If an object is explicitly declared with a type

B If an object inherits from a specific class

C If an object has the required properties and methods

D If an object has no extra properties

Duck typing checks if the object has the needed shape, ignoring inheritance or explicit declarations.

Which of these is true about duck typing in TypeScript?

A An object must explicitly implement an interface to be valid

B TypeScript does not allow extra properties in objects

C Duck typing requires inheritance

D An object with matching properties can be used even without explicit implementation

TypeScript allows objects with matching properties to be used without explicit interface implementation.

What happens if an object literal has extra properties not in the expected type?

A TypeScript always allows it

B TypeScript gives an error due to excess property checks

C TypeScript ignores extra properties silently

D The object is automatically cast to the expected type

Excess property checks cause errors when object literals have extra properties not in the target type.

Why is duck typing called that way?

A Because if it looks like a duck and quacks like a duck, it is treated as a duck

B Because it uses ducks in examples

C Because it requires inheritance from a Duck class

D Because it only works with animals

The name comes from the saying: if it looks like a duck and quacks like a duck, it is treated as a duck.

Which TypeScript feature relies on duck typing?

A Structural typing

B Nominal typing

C Class inheritance

D Type casting

TypeScript uses structural typing, which is a form of duck typing based on object shape.

Explain the duck typing mental model in TypeScript and how it affects type checking.

Think about how TypeScript decides if an object fits a type.

Describe a situation where duck typing in TypeScript can cause an error and why.

Consider when you write an object literal with more properties than expected.

Practice

1. What does duck typing mean in TypeScript?

easy

A. Only objects created from the same class are compatible.

B. If an object has the required properties or methods, it is accepted regardless of its explicit type.

C. TypeScript requires explicit class inheritance to match types.

D. TypeScript checks the runtime type of objects strictly.

Solution

1. Step 1: Understand duck typing concept

   Duck typing means an object is accepted if it has the needed properties or methods, regardless of its declared type.

2. Step 2: Compare with other options

   The other options describe strict or class-based typing, which is not how TypeScript works.

3. Final Answer:

   If an object has the required properties or methods, it is accepted regardless of its explicit type. -> Option B

4. Quick Check:

   Duck typing = structural compatibility [OK]

Hint: Focus on properties, not explicit types, for duck typing [OK]

Common Mistakes:

• Thinking TypeScript requires class inheritance
• Confusing runtime type checks with compile-time checks
• Assuming exact type names must match

2. Which of the following is a correct TypeScript syntax to define a type that matches any object with a name string property and a quack() method returning void?

easy

A. type Duck = { name: string; quack: () => void; };

B. interface Duck { name: string; quack: void; }

C. type Duck = { name: string; quack(): string; };

D. interface Duck { name: string; quack: () => string; }

Solution

1. Step 1: Check property and method types

   The name property must be a string, and quack must be a method returning void.

2. Step 2: Validate each option

   type Duck = { name: string; quack: () => void; }; correctly defines quack as a function returning void. The other options have incorrect method signatures or return types.

3. Final Answer:

   type Duck = { name: string; quack: () => void; }; -> Option A

4. Quick Check:

   Correct method signature = type Duck = { name: string; quack: () => void; }; [OK]

Hint: Method type must be a function signature with correct return type [OK]

Common Mistakes:

• Using method return type as property type
• Confusing void and string return types
• Incorrect interface method syntax

3. What will be the output of this TypeScript code?

interface Duck { name: string; quack: () => void; }

function makeItQuack(duck: Duck) {
  duck.quack();
}

const obj = { name: 'Daffy', quack: () => console.log('Quack!'), swim: () => console.log('Swim') };
makeItQuack(obj);

medium

A. No output

B. Swim

C. Error: obj does not match Duck interface

D. Quack!

Solution

1. Step 1: Check if obj matches Duck interface

   obj has name (string) and quack (function returning void), so it matches by duck typing.

2. Step 2: Call makeItQuack with obj

   Calling duck.quack() runs console.log('Quack!'), printing "Quack!".

3. Final Answer:

   Quack! -> Option D

4. Quick Check:

   Duck typing allows extra properties, output = Quack! [OK]

Hint: Extra properties don't block duck typing; focus on required ones [OK]

Common Mistakes:

• Thinking extra properties cause errors
• Expecting 'Swim' output instead of 'Quack!'
• Assuming runtime type errors

4. Identify the error in this TypeScript code using duck typing:

interface Duck { name: string; quack: () => void; }

const notADuck = { name: 'Donald' };

function makeItQuack(duck: Duck) {
  duck.quack();
}

makeItQuack(notADuck);

medium

A. notADuck is missing the quack method required by Duck interface.

B. The name property should be a number, not a string.

C. makeItQuack should accept any object without type restrictions.

D. There is no error; code runs fine.

Solution

1. Step 1: Check properties of notADuck

   notADuck has name but lacks quack method required by Duck interface.

2. Step 2: Understand TypeScript type checking

   TypeScript will report an error because notADuck does not satisfy the Duck type.

3. Final Answer:

   notADuck is missing the quack method required by Duck interface. -> Option A

4. Quick Check:

   Missing required method = Type error [OK]

Hint: Check all required properties/methods exist for the type [OK]

Common Mistakes:

• Ignoring missing methods in objects
• Assuming extra properties cause errors
• Thinking TypeScript allows missing required members

5. Given this code, which object will TypeScript accept as a valid Duck type?

interface Duck { name: string; quack: () => void; }

const a = { name: 'Daisy', quack: () => console.log('Quack!') };
const b = { name: 'Goose', quack: 'loud' };
const c = { name: 'Swan', quack: () => 'quack' };
const d = { name: 'Mallard' };

function testDuck(duck: Duck) { duck.quack(); }

Which call to testDuck will NOT cause a TypeScript error?

hard

A. testDuck(c);

B. testDuck(b);

C. testDuck(a);

D. testDuck(d);

Solution

1. Step 1: Check each object's quack property type

   a.quack is a function returning void (correct). b.quack is a string (wrong). c.quack is a function returning string (wrong return type). d.quack is missing (wrong).

2. Step 2: Determine which matches Duck interface

   Only object a matches the Duck interface exactly.

3. Final Answer:

   testDuck(a); -> Option C

4. Quick Check:

   Correct method signature only in a [OK]

Hint: Method must be function returning void to match Duck [OK]

Common Mistakes:

• Accepting string or wrong return type as method
• Ignoring missing methods
• Confusing method return types