Q:

Use of .apply() with 'new' operator.  Is this possible? 

In JavaScript, I want to create an object instance (via the new operator), but pass an arbitrary number of arguments to the constructor.  Is this possible? 
What I want to do is something like this (but the code below does not work):
function Something(){
    // init stuff
}
function createSomething(){
    return new Something.apply(null, arguments);
}
var s = createSomething(a,b,c); // 's' is an instance of Something

The Answer
From the responses here, it became clear that there's no built-in way to call .apply() with the new operator.  However, people suggested a number of really interesting solutions to the problem. 
My preferred solution was this one from Matthew Crumley (I've modified it to pass the arguments property):
var createSomething = (function() {
    function F(args) {
        return Something.apply(this, args);
    }
    F.prototype = Something.prototype;

    return function() {
        return new F(arguments);
    }
})();

A:

With ECMAScript5's Function.prototype.bind things get pretty clean:
function newCall(Cls) {
    return new (Function.prototype.bind.apply(Cls, arguments));
    // or even
    // return new (Cls.bind.apply(Cls, arguments));
    // if you know that Cls.bind has not been overwritten
}

It can be used as follows:
var s = newCall(Something, a, b, c);

or even directly:
var s = new (Function.prototype.bind.call(Something, null, a, b, c));

var s = new (Function.prototype.bind.apply(Something, [null, a, b, c]));

This and the eval-based solution are the only ones that always work, even with special constructors like Date:
var date = newCall(Date, 2012, 1);
console.log(date instanceof Date); // true

edit
A bit of explanation:
We need to run new on a function that takes a limited number of arguments.  The bind method allows us to do it like so:
var f = Cls.bind(anything, arg1, arg2, ...);
result = new f();

The anything parameter doesn't matter much, since the new keyword resets f's context.  However, it is required for syntactical reasons.  Now, for the bind call: We need to pass a variable number of arguments, so this does the trick:
var f = Cls.bind.apply(Cls, [anything, arg1, arg2, ...]);
result = new f();

Let's wrap that in a function.  Cls is passed as argument 0, so it's gonna be our anything. 
function newCall(Cls /*, arg1, arg2, ... */) {
    var f = Cls.bind.apply(Cls, arguments);
    return new f();
}

Actually, the temporary f variable is not needed at all:
function newCall(Cls /*, arg1, arg2, ... */) {
    return new (Cls.bind.apply(Cls, arguments))();
}

Finally, we should make sure that bind is really what we need. ( Cls.bind may have been overwritten).  So replace it by Function.prototype.bind, and we get the final result as above. 

A:

Here's a generalized solution that can call any constructor (except native constructors that behave differently when called as functions, like String, Number, Date, etc.)  with an array of arguments:
function construct(constructor, args) {
    function F() {
        return constructor.apply(this, args);
    }
    F.prototype = constructor.prototype;
    return new F();
}

An object created by calling construct(Class, [1, 2, 3]) would be identical to an object created with new Class(1, 2, 3). 
You could also make a more specific version so you don't have to pass the constructor every time.  This is also slightly more efficient, since it doesn't need to create a new instance of the inner function every time you call it. 
var createSomething = (function() {
    function F(args) {
        return Something.apply(this, args);
    }
    F.prototype = Something.prototype;

    return function(args) {
        return new F(args);
    }
})();

The reason for creating and calling the outer anonymous function like that is to keep function F from polluting the global namespace.  It's sometimes called the module pattern. 
[UPDATE]
For those who want to use this in TypeScript, since TS gives an error if F returns anything:
function construct(constructor, args) {
    function F() : void {
        constructor.apply(this, args);
    }
    F.prototype = constructor.prototype;
    return new F();
}

A:

If your environment supports ECMA Script 2015's spread operator (...), you can simply use it like this
function Something() {
    // init stuff
}

function createSomething() {
    return new Something(...arguments);
}

Note: Now that the ECMA Script 2015's specifications are published and most JavaScript engines are actively implementing it, this would be the preferred way of doing this. 
You can check the Spread operator's support in few of the major environments, here.