11

Every time I create some class, I need to do the same boring procedure:

class Something {
  constructor(param1, param2, param3, ...) {
    this.param1 = param1;
    this.param2 = param2;
    this.param3 = param3;
    ...
  }
}

Is there any way to make it more elegant and shorter? I use Babel, so some ES7 experimental features are allowed. Maybe decorators can help?

troorl
  • 1,579
  • 1
  • 15
  • 20
  • 2
    Does it need to be a class? you could use the shorthand object litteral to assign the params as properties without repeating their names even once. – Touffy Oct 25 '15 at 09:38
  • 1
    To answer your last question, decorators won't help here as they cannot be attached to a `class constructor` – CodingIntrigue Oct 26 '15 at 08:27

3 Answers3

10

You can use Object.assign:

class Something {
  constructor(param1, param2, param3) {
    Object.assign(this, {param1, param2, param3});
  }
}

It's an ES2015 (aka ES6) feature that assigns the own enumerable properties of one or more source objects to a target object.

Granted, you have to write the arg names twice, but at least it's a lot shorter, and if you establish this as your idiom, it handles it well when you have arguments you do want on the instance and others you don't, e.g.:

class Something {
  constructor(param1, param2, param3) {
    Object.assign(this, {param1, param3});
    // ...do something with param2, since we're not keeping it as a property...
  }
}

Example: (live copy on Babel's REPL):

class Something {
  constructor(param1, param2, param3) {
    Object.assign(this, {param1, param2, param3});
  }
}
let s = new Something('a', 'b', 'c');
console.log(s.param1);
console.log(s.param2);
console.log(s.param3);

Output:

a
b
c
T.J. Crowder
  • 1,031,962
  • 187
  • 1,923
  • 1,875
  • That's pretty neat, but you're still repeating the param names (once in the argument list, once in the assign call). You could clone `arguments`, remove predefined properties, and pass that to `assign`. – Touffy Oct 25 '15 at 09:43
  • @Touffy: Does `arguments` have *named* properties for the arguments? I mean, with names other than `0`, `1`, and `2`? That's new to me, if so. – T.J. Crowder Oct 25 '15 at 09:44
  • Hmmm right it doesn't. I suppose you could parse them quite easily from the function's toString, but that's getting ugly. – Touffy Oct 25 '15 at 09:48
  • @Touffy: Yeah, and it's a useful idiom that you can keep using even when you just need some of them mapped to the object. – T.J. Crowder Oct 25 '15 at 09:55
  • What I'd do, is to treat the first argument as a property map, like in Chev's last solution (but with Object.assign instead of the loop, of course). Your solution is safer though, if you don't trust the calling code to send the right names. – Touffy Oct 25 '15 at 09:59
3

Unfortunately, all you can do are simple things like Object.assign, but if you're trying to remove the redundancy of typing all the params twice (once in constructor signature and once in assignment) there isn't much you can do.

That said, you could do a hack like this. Though I'm not sure the effort and modicum of obfuscation that comes with it is worth it.

var dependencies = ['param1', 'param2', 'param3'];

class Something {
  constructor(...params) {
    params.forEach((param, index) => this[dependencies[index]] = param);
  }
}

var something = new Something('foo', 'bar', 'baz');
// something.param1 === 'foo'

This way you're using a single array of argument names, then using that same array as a reference when creating the properties on your instance of Something. This pattern would work well in an Angular application where you're trying to preserve dependency names through minification by setting the $inject property.

Something.$inject = dependencies;

PS - Welcome to the redundant hell of classical languages that I thought I got away from when I became a JS developer :P

Honestly, you should probably just use a classic object literal unless you really need the formality of an actual class.

Edit: I suppose you could accept an object literal in your constructor if you want the ease of a literal and the formality of an actual class.

class Something {
  constructor(params) {
    Object.keys(params).forEach((name) => this[name] = params[name]);
  }
}

var something = new Something({
  param1: 'foo',
  param2: 'bar',
  param3: 'baz'
});

But now you've just turned a class into a dynamic class that can be instantiated with any properties, kinda like an object literal :P

Usually I want a class because I want to formalize the object and present a consistent and strictly testable API.

CatDadCode
  • 58,507
  • 61
  • 212
  • 318
  • 1
    This is ugly, but will give you the function's arguments' names so you can write them in the function definition instead of an external array: `arguments.callee.toString().match(/^function.*?\((.*?)\)/)[1].split(/,\s*/) }` – Touffy Oct 25 '15 at 10:11
  • 1
    @Touffy That wouldn't work for me. Strict Mode wouldn't allow me to access `arguments.callee` so you may need a [further workaround](http://stackoverflow.com/questions/29572466/how-do-you-find-out-the-caller-function-in-javascript-when-use-strict-is-enabled) for that solution, making it even more ugly. – CodingIntrigue Oct 26 '15 at 08:23
1

We could create a static method within each class that takes the arguments object and an array of names and returns an object that can be assigned to the new instance using Object.assign.

Check it out using the Babel REPL.

class Something {
  static buildArgs (ctx, args, paramNames) {
    let obj = {}
    Array.from(args).forEach(function (arg, i) {
      let name = paramNames[i] || i
      obj[name] = args[i]
    })
    Object.assign(ctx, obj)
  }

  constructor () {
    Something.buildArgs(this, arguments, [
      'param1',
      'param2'
    ]);
    console.log(this)
  }
}

new Something('one', 'two')

Admittedly the addition of a method buildArgs means that this solution is not shorter, however the body of the constructor is and we also have these advantages:

  1. You are only writing the parameter names once.
  2. You are protected against minification.

The code above accommodates extra arguments (i >= paramNames.length) however we could modify it if this behaviour is undesirable such that these are still parsed, but not assigned to the instance:

class Something {
  static buildArgs (ctx, args, paramNames) {
    let obj = {instance: {}, extra: {}}
    Array.from(args).forEach(function (arg, i) {
      let name = paramNames[i] || i
      if (name) {
          obj.instance[name] = args[i]
      } else {
          obj.extra[i] = args[i]
      }
    })
    Object.assign(ctx, obj)
  }

  constructor () {
    let args = Something.buildArgs(this, arguments, ['param1', 'param2']);
    // Do stuff with `args.extra`
  }
}

Or ignored altogether:

  static buildArgs (args, paramNames) {
    let obj = {}
    Array.from(args).forEach(function (arg, i) {
      let name = paramNames[i]
      if (name) obj[name] = args[i]
    })
    return obj
  }
sdgluck
  • 24,894
  • 8
  • 75
  • 90