What is duck typing with an example in JavaScript.

Duck typing is a programming concept that refers to the ability to use an object without specifying its type. It’s usually found in Dynamically-type languages like JavaScript.

Another way to think about it is the ability to perform operation on an object, without knowing or caring about the object’s type. As long as the properties exist, it’s good enough and the right object for the job - “if it walks like a duck and it quacks like a duck, then it must be a duck”.

Here is an example of duck typing in JavaScript:

function playMusic(player) {
  // can it play music, pause and stop...
  if (player.play && player.pause && player.stop) { 
    player.play(); // ... yes, then it must be a music player
  } else {
    console.log('This thing cannot play music');
  }
}

let musicPlayer = {
  play: function() { console.log('Playing music'); },
  pause: function() { console.log('Pausing music'); },
  stop: function() { console.log('Stopping music'); }
};

let videoPlayer = {
  play: function() { console.log('Playing video'); }
};

playMusic(musicPlayer);  // Output: "Playing music"
playMusic(videoPlayer);  // Output: "This thing cannot play music"

In this example, the playMusic function takes an object as an argument and checks whether it has the play, pause, and stop methods. If the object has all of these methods, the function calls the play method on the object. Otherwise, it logs an error message.

Benefits and Drawbacks of Duck Typing

Duck typing is commonly used in dynamically-typed languages where type of a variable is determined at runtime. Duck typing gives greater flexibility and allows objects of different types to be used interchangeably as long as they have the necessary properties or methods.

The biggest draw back of duck typing is that it can lead to runtime errors: if the object does not have the necessary properties or methods, the app will throw errors at runtime (because there’s no way to verify these errors at compile time since there are no types) which can be very hard to debug and find especially in large programs.

In short, Duck Typing offers developers great flexibility by allowing any object to be used as long as they have the required properties or methods. However, it leads to code that is more prone to errors and harder to maintain.

Related Questions