No, there is not. With ES6, you might be able to use an arrow function: ()=>{} which is a bit shorter.

If you really need this very often (you shouldn't?!), you can declare one yourself:

function noop(){}

and then refer to that repeatedly. If you don't want to clutter your scope, you can also use the Function.prototype function (sic!) which does nothing but constantly return undefined - yet that's actually longer than your function expression.

I don't know what jsLint thinks but if this is a problem and you need a solution then you can do something like the following:

var blah = function() { return undefined; }; // or just return;

Update : I think, Bergi's guess is right because, on the jslint site in the Required Blocks section :

JSLint expects that if, while, do and for statements will be made with blocks {that is, with statements enclosed in braces}.JavaScript allows an if to be written like this:if (condition) statement;That form is known to contribute to mistakes in projects where many programmers are working on the same code. That is why JSLint expects the use of a block:

if (condition) { statements; }

Experience shows that this form is more resilient.

So, It probably just checks for empty blocks { } and invalidate the blank function.

This is idiomatic JavaScript:

a = a || 'N/A';

Note that a will take the value 'N/A' for all falsy values of a.

Since ECMAScript 2020, there is an arguably even more idiomatic alternative in the form of the nullish coalescing assignment (??=) operator:

a ?? = 'N/A';

Rather than performing the assignment in all cases where the value of a is falsy, it only does so when a is either null or undefined.

To handle multiple variables: ECMAScript 6's destructuring assignment lets you assign default values to the variables that are undefined in an array of variables:

var a = "some value";
var b = "";
var c = "some other value";
var d;

[a='N/A', b='N/A', c='N/A', d='N/A'] = [a, b, c, d];

console.log(a); // "some value"
console.log(b); // ""
console.log(c); // "some other value"
console.log(d); // "N/A"

Or you can use the destructuring assignment in combination with map() to treat all falsy values as in my first example:

var a = "some value";
var b = "";
var c = "some other value";
var d;

[a, b, c, d] = [a, b, c, d].map(x => x || 'N/A'); // or x => x ?? 'N/A'

console.log(a); // "some value"
console.log(b); // "N/A"
console.log(c); // "some other value"
console.log(d); // "N/A"

If you don't need to maintain the separate variables, you can of course also just apply map to the data array directly:

var data = ["some value", "", "some other value", undefined];

data = data.map(x => x || 'N/A'); // or x => x ?? 'N/A'

console.log(data); // ["some value", "N/A", "some other value", "N/A"]

this.init.apply(this, arguments);

is basically just

this.init(arguments[0], arguments[1], ..., arguments[N]);

But as soon as we don't know the exact number of arguments - we just use .apply()

Usage example:

var newConstructor = exports.Controller.create();
newConstructor.include({
    init: function(a, b, c) { console.log(a, b, c, 'yay!'); }
});

var newInstance = new newConstructor(1, 2, 3);

Complete demo: http://jsfiddle.net/nbq6d/1/