> For the complete documentation index, see [llms.txt](https://choubey.gitbook.io/javascript-interview-questions/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://choubey.gitbook.io/javascript-interview-questions/question-72.md).

# Question 72

### Question

Explain the difference between function composition and method chaining.

### Answer

Function composition and method chaining are both powerful concepts in JavaScript that involve combining functions, but they work in slightly different ways.

**Function Composition:**

* **Core Idea:** Taking the output of one function and using it as input for another function. Think of it like building a pipeline where each stage processes data from the previous stage.
* **Example:**

```javascript
function square(x) { return x * x; }
function addOne(x) { return x + 1; }

const composedFunction = compose(square, addOne);  // 'composedFunction' is now our pipeline
console.log(composedFunction(2)); // Output: 9 (because: 2 + 1 = 3, then 3 * 3 = 9)
```

* **`compose` Function:** This helper function takes two functions as arguments and returns a new function that performs the composition. You'd often define this helper function yourself or use existing libraries for composing functions more elegantly.

**Method Chaining:**

* **Core Idea:** Calling multiple methods sequentially on an object, with each method returning the modified object itself. This creates a fluent and readable way to build up operations on an object.
* **Example:** (Let's assume `document` has a 'getElementById' method)

```javascript
const myElement = document.getElementById('myDiv'); 
myElement
  .style.color = 'red' // Changes the text color to red
  .style.fontSize = '20px' // Sets the font size
  .classList.add('important'); // Adds a CSS class named "important"

```

**Key Differences:**

* **Focus:** Function composition focuses on combining standalone functions, while method chaining is about creating a fluent flow of operations within an object's context.
* **Structure:** Composition often involves using helper functions to combine functions, while method chaining uses the `.` operator to chain methods directly.
* **Flexibility:** Function composition is generally more flexible because you can compose any function pair, whereas method chaining is tied to a specific object and its methods.