Function borrowing is used when you already have a method defined for an object (either directly or via the prototype chain), and you want to be able to use it with a similar object that doesn't have that method defined.

This is the case in your code #1 -- rather than use prototypical inheritance or classes, the getSpeed() method was defined directly in car1. Rather than duplicate the code in car2, you can borrow from car1.

You wouldn't normally design things this way from scratch. Either you would use an ordinary function as in code #2, or you would make car1 and car2 inherit from the same prototype.

Function borrowing is usually just a workaround for poor initial design. You see it in code like

nodes = document.getElementsByClassName("foo");
result = [].prototype.map.call(nodes, someFunction);

because the NodeList prototype doesn't have its own map() function.

As an addendum to Barmar's answer the third option you might consider is using a class to create object instances which share the same methods.

class Car {

  constructor(speed) {
    this.speed = speed;
  }

  getSpeed() {
    return this.speed;
  }

}

console.log(new Car(80).getSpeed());
console.log(new Car(60).getSpeed());

Benefits of using Code #1 (Function borrowing) vs Code #2 is, it lets you skip inheritance. In your example you are granting access of car1.getSpeed() to car2.

Benefits are:

1. Skipping a need for class inheritance
2. Reduce bugs with having 1 copy of the function vs copies floating around.

It is mostly used with native methods like slice() from Array.prototype

So if you have array like (but not exactly) structures, borrowing slice() from Array.prototype gives you access to the .map/.filter etc.

Practical example:

function findS() {
  return Array.prototype.slice.call(arguments).filter( arg => arg.includes('s'))
}

console.log(findS("Tesla", "Mitsubishi", "Ford"))