Duck Typing in JavaScript

Duck typing is a concept in programming that is often used in dynamic programming languages such as JavaScript, Python, and Ruby. It is a method of determining the type of an object based on its behavior or the methods and properties it possesses, rather than its explicit type or class.

The term “duck typing” comes from the saying, “If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck.” In programming, this means that if an object behaves like a certain type, then it can be treated as that type, regardless of its actual class or type.

For example, in JavaScript, you can use duck typing to check whether an object is iterable by checking whether it has a Symbol.iterator method. This method is used to define the iteration behavior of an object, and if an object has this method, it can be treated as iterable, even if it doesn’t explicitly implement the Iterable interface.

Here’s an example of how duck typing might be used in JavaScript:

function printItems(iterable) {
  for (let item of iterable) {

const myObject = {
  items: ['foo', 'bar', 'baz'],
  [Symbol.iterator]() {
    let index = 0;
    const items = this.items;
    return {
      next() {
        if (index < items.length) {
          return { value: items[index++], done: false };
        } else {
          return { done: true };

printItems(myObject); // Output: foo bar baz

In this example, we define an object myObject that has an items array and a Symbol.iterator method that defines how to iterate over the items. We can then pass this object to the printItems function, which uses duck typing to treat the object as iterable, even though it doesn’t explicitly implement the Iterable interface.

Duck typing can be a powerful and flexible way of working with objects in dynamic programming languages, but it can also lead to unexpected behavior if not used carefully. It’s important to understand the implications of duck typing and use it judiciously.