JS: And if every function return "this" as a default value?

Question

I have a code design question. Consider the following code:

thatObj.doThis().setThat().add().update();

To allow chaining, I'm often writing return this;, and sometimes, here or there I forget to do it, then I got an error.

In many cases, I'm not asking for a particular result (e.g. thatObj.getName() or thatObj.getChildren()), but instead wanting to do some updates or calling setters (e.g. thatObj.setName("foo") or thatObj.addChild(child) or thatObj.update()), I was wondering if it would be more convenient to return this; for any call of methods, I mean as a javascript default behaviour, and if not, what could be the reasons not to do so.

Answer 1

• JS returns undefined if you don't return something explicitely,
• JS constructors return this unless your constructor returns an Object.
• CoffeeScript returns the last expression by default,
• You want this to be returned by default by all methods on an object

everybody has it's own opinion what's the "right" way to do it.

could it be a good idea to say from now JS will always return this from any methods ?

And from one moment to the other, at least 2/3 of the web will be broken. So, tell me, is it a good idea?

JS has set its rules a long time ago, and something that basic is not going to change (as Pointy already mentioned). So why don't you take care of that behaviour:

//extracted that from the function to avoid memory leakage
function wrapFunction(fn) {
  return function() {
    let result = fn.apply(this, arguments);
    return result === undefined ? this : result;
  }
}

//filter === false   => only own methods
//filter === true    => own methods and inherited methods
//filter is Array    => only the passed keys (if they are methods)
//filter is RegExp   => use the RegExp to filter the keys
//filter is function => regular filterFunction
function returnThisAsDefault(objectOrConstructor, filter = false) {
  if (objectOrConstructor !== Object(objectOrConstructor))
    throw new TypeError("Passed argument must be an object or a constructor. Got ", typeof objectOrConstructor);

  const validKey = key => typeof proto[key] === "function" && key !== "constructor" && key !== "prototype";

  let proto = typeof objectOrConstructor === "function" ?
    objectOrConstructor.prototype :
    objectOrConstructor;

  let filterFn = Array.isArray(filter) ? filter.includes.bind(filter) :
    filter === false || filter === true ? () => true :
    filter instanceof RegExp ? filter.test.bind(filter) :
    typeof filter === "function" ? filter :
    () => false;

  let wrapped = {};
  for (let p = proto, done = new Set(["constructor", "prototype"]); p != null && p !== Object.prototype;) {
    for (let key of Object.getOwnPropertyNames(p)) {
      if (typeof proto[key] !== "function" || done.has(key) || !filterFn.call(p, key)) continue;
      done.add(key);

      let d = Object.getOwnPropertyDescriptor(p, key);
      //typeof d.value !== "function" means that proto[key] contains a getter returning a function
      if (!d.writable && !d.configurable || typeof d.value !== "function") {
        console.log(`function ${JSON.stringify(key)} not fit to be wrapped`, d);
        continue;
      }

      d.value = wrapFunction(d.value);
      wrapped[key] = d;
    }

    if (filter === false) break;
    else p = Object.getPrototypeOf(p);
  }

  Object.defineProperties(proto, wrapped);
  return objectOrConstructor;
}

let thatObject = returnThisAsDefault({
  doThis() {
    console.log("doThis()");
  },

  setThat() {
    console.log("setThat()");
  },

  add() {
    console.log("add()");
  },

  update() {
    console.log("update()");
    return "success";
  },
});

let result = thatObject.doThis().setThat().add().update();

console.log("result: ", result);

.as-console-wrapper {
  top: 0;
  max-height: 100%!important
}