Hacker News Reader

Comment by mattdesl | Hacker News Reader

I wouldn't say constructors are the problem -- the problem is with the "new" keyword.

I tend to use constructors like this: https://github.com/mattdesl/module-best-practices/blob/maste...

Which leads to clear debugging (named constructors and their prototypes showing in console) and also works well in the off chance that you need to use "inherits" (eg on node EventEmitter).

Regarding case; it comes down to preference. I tend to name my factories CamelCase or createCamelCase, so that the return value "camelCase" is clearly an instance.

View on HN

Indeed, New-Agnostic Constructor Pattern, is the simpliest patter if you want to avoid the new keyword:

   function User (name, lastname) {
       if (!(this instanceof User)) {
       return new User(name, lastname);
      }
       this.name = name || 'Unknown';
       this.lastname = lastname || 'Unknown'
   };

note that this pattern will break subclassing:

    var Person = User.extend({});

    var person = Person();
    person instanceof Person; // false!
    person instanceof User; // true

The pattern didn't break subclassing there, your code did by not continuing the pattern and then not using new :)

Personally, I only use this pattern for cases where it's more convenient not to have to use new (e.g. building declarative APIs for defining things) and let 'use strict'; catch the rest.

this part here is supposed to solve the problem with people forgetting new:

    if (!(this instanceof User)) {
       return new User(name, lastname);
    }

I'm pointing out that this doesn't work if you extend the class.

The point is - don't forget `new` because tricks like this will not save you, in fact this is arguably worse - you think you're getting a `Person` but you get a `User` with no immediate errors, at least if you forget `new` then you'll get an error straight away in strict mode.

I've using Js for quite some time, and the behavior of prototype chain and instanceof always give me headache when I'm trying to do simple inheritance...

For now, I'll keep using `_.create` to do Inheritance. Of course it means another library to keep using and more verbose. But whatever...

    var Person = function(){ User.call(this) };

    Person.prototype = _.create(User.prototype, { 'constructor': Person });

    var p = new Person();

    p instanceof User //true
    p instanceof Person //true

If that's Backbone's extend, that can be fixed:

http://bl.ocks.org/insin/raw/db5f79d7d97ee6200245/

Works fine with npm "inherits" module. Not that you should be using instanceof anyways...

Personally, I think this makes it unclear what the code actually does--IMHO, forgetting `new` is not a real concern.

I generally just add a `create` method to the prototype so that you can do things like, `_.map(items, Constructor.create)`

The issue has very little to do with forgetting "new" and more to do with hiding implementation details and improving module composability.

Reply on news.ycombinator.com