Extending prototype of given instance from factory method I created a rubber ball by extending instance of b2Body prototype of Box2D.js. I get the instance from factory method b2World#CreateBody.

var ball = world.CreateBody(bodyDef);


I extended the instance in the constructor of my RubberBall prototype. In result, I made the constructor very long. 

function RubberBall(position) {
  var ball = world.CreateBody(bodyDef);
  :
  :
  very long implementation to extend `ball` to make it a rubber ball
}


How can I extract the extending ball part and make the constructor simple?

http://jsfiddle.net/suzuki/XXmeR/
Prototypal Inheritance
Now, the very first problem you'll face in your implementation is memory usage. Each RubberBall instance will be creating an internal function - that's a bad thing:
function RubberBall(){
  this.someFn = function(){...}
}

In this sample code above, each RubberBall instance will create its own someFn. Functions are also objects in JS and will take up memory.
The proper way to do it in JS is to place those methods in the prototype, so that they are shared in all instances of RubberBall. This is what we call prototypal inheritance Do note that we are only placing/sharing the methods. Instance data remains in the instance:
function RubberBall(){
  // ballData gets created *per instance*
  this.ballData = 'I am bouncy';
}

// Assign a prototype object, shared accross all instances of RubberBall
RubberBall.prototype = {
  getData : function(){
    // If called as `[instance].getData()`, `this` is the instance.
    return this.ballData;
  }
}

As far as I've read (but I may be wrong), the V8 engine optimizes objects via hidden classes, and are more optimized if you declare all instance properties in advance. That way, it does not do some &quot;run-time rebuilding&quot;. So have your rubber ball properties declared in advance.
Now, you wanted to extend Box2D's b2Body (I'm not well versed in Box2D so pardon my vocabulary). The previous example does not yet inherit it. So [we use the more proper Object.create][2] to create an object that has b2Body in its prototype. Let's modify the previous example:
function RubberBall(){
  // Attach to this instance all properties of b2Body
  b2Body.call(this);

  this.ballData = 'I am bouncy';
}

// Now create our prototype object, with its prototype pointing to b2Body's prototype
RubberBall.prototype = Object.create(b2Body.prototype);

// Then attach methods to it
RubberBall.prototype.getData = function(){...}    
RubberBall.prototype.anotherSharedMethod = function(){...}

Private members
JS wasn't designed to have private members, but there are a lot of ways to emulate it (and I think ES6 has something more formal for it). You can create closures, which are fast, but if not handled properly, might eat memory.
So let's stick to prototypal inheritance and public members. If you need to indicate that it's private, by convention you can prefix the property or method with a _.
requestAnimationFrame
Modern browsers are now equipped with requestAnimationFrame which is a special timer that executes a given function as fast as possible, aiming 60fps. It's also optimized to throttle it's speed in different situations, like slowing down when the tab is not focused to save battery.
There are polyfills that automatically fill in the gap, especially for older browsers that don't have it.
Standard Reminders

Don't use globals
Place everything you do in a namespace or an enclosed scope
Keep your code short and readable
Use proper indentation