Function Borrowing in JavaScript: Realizing Functions Don’t Belong to Objects

There’s a moment in JavaScript where something subtle clicks.

You write a method inside an object, call it, and everything behaves as expected. Then someone shows you that same method being used on a completely different object — and it still works.

At first, it feels like a trick.

But it’s not a trick.

It’s a consequence of how JavaScript actually thinks about functions.

The Illusion of Methods

When we write this:

const person = {
  name: "Rishi",
  greet() {
    return "Hello " + this.name
  }
}

It looks like greet belongs to person.

Like the function lives inside the object.

But that’s not really what’s happening.

A more accurate way to see it is:

the function exists independently
the object just provides context through `this`

That distinction is easy to miss — but it changes everything.

Using a Function on Another Object

Now consider:

const anotherPerson = {
  name: "Alex"
}

person.greet.call(anotherPerson)

This works.

The same function now returns:

"Hello Alex"

Nothing was copied.

Nothing was rewritten.

The function didn’t change.

Only the value of this changed.

This is what function borrowing really is:

reusing behavior by changing context

this Is the Real Connector

The key to understanding function borrowing is understanding this.

greet() {
  return "Hello " + this.name
}

The function doesn’t care which object it works on.

It only cares that:

this.name exists

So when you switch this, you switch the meaning of the function.

The behavior stays the same.

The data changes.

Borrowing Through call, apply, and bind

JavaScript gives you explicit tools to control this.

With call:

greet.call(obj)

You’re saying:

run this function now, using obj as this

With apply, the idea is the same, just with arguments passed as an array.

But bind is different.

const fn = greet.bind(obj)

This doesn’t run the function.

It creates a new function where this is permanently set to obj.

That difference is easy to overlook, but it leads to an important realization:

call/apply control execution
bind changes the function itself

When Binding Becomes Permanent

This is where things get interesting.

function show() {
  console.log(this.name)
}

const a = { name: "A" }
const b = { name: "B" }

const fn = show.bind(a)

fn.call(b)

You might expect "B".

But the result is:

"A"

Because once bind has fixed this, it cannot be overridden.

Even call can’t change it anymore.

This reveals a deeper structure:

bind operates at creation time
call/apply operate at execution time

And in JavaScript, creation-time decisions win.

Behavior Without Ownership

Function borrowing exposes something fundamental about JavaScript’s design.

In many languages, methods belong to classes or objects.

In JavaScript:

functions are independent
objects provide context

That means behavior is not tightly coupled to structure.

A function can operate on any object, as long as that object satisfies its expectations.

This is why something like this works:

const obj = {
  0: "a",
  1: "b",
  length: 2
}

Array.prototype.forEach.call(obj, console.log)

The function doesn’t care that obj isn’t an array.

It only cares that it behaves like one.

A Shift in Perspective

At first, it’s natural to think:

“objects have methods”

But a more accurate way to think is:

objects provide data
functions provide behavior
`this` connects the two

Function borrowing is simply the act of reusing that behavior with different data.

Why This Matters

This flexibility is part of what makes JavaScript powerful.

It allows:

• reusable logic across different data shapes
• dynamic behavior without rigid structure
• patterns like composition instead of inheritance

But it also introduces complexity.

Because now, understanding a function means understanding:

what it does
and what `this` refers to

And those are not always obvious.

What Function Borrowing Really Teaches

Function borrowing is not just about call, apply, or bind.

It’s about realizing something deeper:

Functions in JavaScript are not owned.

They are applied.

And once you see that, many confusing behaviors around this start to make sense.

Because the function was never tied to the object in the first place.

It was only ever using it.