Catch errors mid-chain?

tl;dr

Is catching errors in the middle of a promise chain considered bad-practice? Or is there a good reason for it?

Explanation

so I just tried the following chain

doSomething()
  .then(function() {
    throw new Error('contrived');
  })
  .catch(function(err) {
    console.log('caught');
  })
  .then(function() {
    console.log('got here');
  });

And was a little confused that ‘got here’ gets printed. I guess the documentation makes this clear:

Any exception happening in a .then-chain will propagate to nearest .catch handler.

And the fact that catch is an alias for then(null, handler) makes a little more sense of the above behavior. However it still seems far from the conventional way seen in other OO languages that I’ve used so I was wondering whether this was on purpose or just a side-effect that should be avoided from an idiomatic perspective.

[petkaantonov]

Well let’s map it to synchronus code according to the rules I gave and run it:

try {
    try {
        throw new Error()
    } catch(e) { // When you call first catch, the chain before it is just
                 // a single then so that is wrapped in try
        console.log("catch 1");
    }
    console.log("got here");
    throw new Error();
} catch (e) { // When you call second catch, the chain before it is 1 then,
              // 1 catch and 2 thens, which are now above wrapped in the second try
    console.log("catch 2");
}

Logs

fiddle.jshell.net/:26 catch 1
fiddle.jshell.net/:28 got here
fiddle.jshell.net/:31 catch 2

[olsonpm]

Each .catch and .finally create an implicit .try over the full chain

If that were true, then the following chain wouldn’t print ‘got here’:

Promise.resolve()
    .then(function() {
        throw new Error();
    })
    .catch(function() {
        console.log('catch 1');
    })
    .then(function() {
        console.log('got here');
    })
    .then(function() {
        throw new Error();
    })
    .catch(function() {
        console.log('catch 2');
    });

So what functionally happens (haven’t looked into the code, only observed test behavior) is an implicit try between each catch, which I believe allows for some confusing code. I just don’t expect to see catches and finally’s in the middle of a promise chain and I expect other people with more OO backgrounds to feel similarly (though maybe it’s just me).