Here is a simple example you can use:

var Pancake = (function() {
    function Pancake() {
        this.flavor = "delicious"
    }

    return exportCtor( Pancake );
})();


var pancake = Pancake();

alert(pancake.flavor);

console.log(Pancake);

/*
function ConstructorProxy() {
    "use strict";
    return new Constructor();
}
*/

http://jsfiddle.net/ywQJF/

This code also supports variable arguments

arguments.callee, which points to the current function, offers a straightforward solution. However, it is considered deprecated and should be used cautiously.

function Waffle() {
    if (!(this instanceof arguments.callee))
        return new arguments.callee();

    this.tastes = 'delicious';
}

This issue becomes complex because retaining the passed arguments is essential, as pointed out by Vinothbabu. If your main goal is to enforce the use of new, you can simply trigger an error with just two lines of code:

if (!(this instanceof Waffle))
    throw new Error('Constructor invoked without new');

You could encapsulate this logic within a function as well:

function cons(C) {
    var c = function () {
        if (!(this instanceof c))
            throw new Error('Constructor invoked without new');

        C.apply(this, arguments);
    };
    c.prototype = C.prototype;
    return c;
}

var Waffle = cons(function () {
    this.tastes = 'delicious';
});
Waffle.prototype.wantAnother = function () {
    return true;
};

new Waffle(); // { tastes: 'delicious', 'wantAnother': true }
Waffle(); // triggers an error

Therefore, calling Waffle without using new will result in an error being thrown.

In my view, the most effective strategy is to avoid the possibility of invoking things incorrectly:

function Pancake() {
  if (!(this instanceof Pancake)) {
    throw "Pancakes must be made correctly or they won't taste good. Remember to use 'new'.";
  }
}

However, if you absolutely feel the need to allow for inconsistent code, consider separating initialization into a distinct step.

function Pancake(options) {
  var o = options || {};
  if (this instanceof Pancake) {
    this.init = function() {
      /* this essentially acts as your constructor */
      console.log("Initializing ... ");
    }

    if (!o.__do_not_initialize) {
      this.init(arguments);
    }
  } else {
    var rv = new Pancake( { __do_not_initialize: true } );
    rv.init(arguments);
    return rv;
  }
}

If you prefer enforcing consistency in the opposite direction -- never using the new keyword, you can create a builder function:

function BuildPancake(options) {
  var o = options || {};

  if (this instanceof PancakeBuilder) {
    throw "BuildPancake should not be instantiated.";
  }

  var Pancake = function Pancake() { /* do something */ }
  Pancake.prototype.doSomethingElse = function() { /* additional actions */ }

  var rv = new Pancake(options);
  return rv;
}

Here's a simple way to ensure the creation of a new object without using new:

function Pancake() {
    return {flavor:"delicious"};
}

var x = Pancake();
var y = new Pancake();

alert(x.flavor); // delicious
alert(y.flavor); // delicious

Explanation

When using new with a function, there are two scenarios:

• The function returns an object: this object becomes the result of the new function() expression
• The function does not return an object: the function itself is returned with a new context

Refer to the ECMAScript documentation for more information.

Alternative Solution: prototype and arguments

function Pancake(flavor,type) {
    return {
        flavor: flavor+" "+type,
        __proto__: Pancake.prototype
    }
}
Pancake.prototype.wantmore = "yes";

var x = Pancake("tasty","lot");
var y = new Pancake("yummy","little");

console.log(x.flavor,y.flavor); // tasty lot, yummy little
console.log(x.wantmore,y.wantmore); // yes, yes

Check out this JSFiddle demo.

Note: Using constructor.name (as seen in your code snippet) is considered non-standard. Refer to MDN documentation.

Note 2: While __proto__ is not standardized, it is supported by modern browsers and will be part of ES6 standardization.

if (!(this instanceof Pancake)) {
    return new Pancake();
}

This method presents a couple of issues...

1. First, it will not function properly within an anonymous function with no name.
2. Secondly, it fails to retain any arguments passed to the constructor.

A more universal approach would resemble something like this:

if (!checkInstance(this, arguments)) {
    return constructInstance(this, arguments);
}

This revised technique guarantees that the constructor is invoked using new, without requiring the function's name, and

preserves all constructor arguments to prevent loss during the process

Below is the complete code for the aforementioned solution:

Function.prototype.callNew = function (args) {
    var argArray = [];
    for (var index = 0; index < args.length; index++) argArray.push("argArray[" + index + "]");
    var func = new Function("var argArray=arguments;return new this(" + argArray.join(",") + ");");
    return func.apply(this, args);
}

function checkInstance(variable, args) {
    if (variable instanceof args.callee) {
        return true;
    } else {
        return false;
    }
}

function constructInstance(variable, args) {
    var func = args.callee;
    if (!checkInstance(variable, args)) {
        return func.callNew(args);
    }
}

function Pancake(item1, item2, item3) {
    if (!checkInstance(this, arguments)) {
        return constructInstance(this, arguments);
    }
    this.item1 = item1;
    this.item2 = item2;
    this.item3 = item3;
}

Pancake.prototype.serve = function () {
    var output = [];
    for (var key in this) {
        if (!this.hasOwnProperty(key)) continue;
        output.push(key + ': ' + this[key]);
    }
    return '{' + output.join(",\n") + '}';
}

An interactive demo can be accessed via this link: http://jsfiddle.net/RkPpH/

var pancake = Pancake(1, 2, 3);
alert(pancake.serve());

It was not clear whether this pertained to client-side or server-side development, but there is a pattern I sometimes employ that can be adapted for both environments. While I primarily use this in Node.js, I have made an effort to make it compatible with client-side solutions as well - I have included comments for the Node-specific components which can serve as a reference depending on your setup.

To begin with, I create a structure similar to a traditional object-oriented base or super class like so:

//// Node:
//module.exports.Base = Base;

function Base(opts) {
    var self = this;
    if (!(self instanceof Base)) return new Base(opts);
    self.opts = opts || {};
}

You can then define your methods within this structure as per usual practice. Additionally, you can manually enforce method requirements by throwing errors if certain methods must be implemented by subclasses:

// commonMethod is accessible to subclasses:
Base.prototype.commonMethod = function () {
    var self = this;
    // Access self.opts to retrieve constructor arguments.
}

// Define abstractMethod, leaving implementation to subclasses:
Base.prototype.abstractMethod = function () {
    throw new Error('implement me');
}

Subsequently, you can proceed as follows:

//// If utilizing Node:
//var inherits = require('util').inherits;
//var Parent = require('./Base').Base;

function Sub (opts) {
    var self = this;
    //// For Node users who wish to invoke super_ before creating a new Sub instance:
    //if(Sub.super_) Sub.super_.call(this, opts);

    // Always include this check:
    if (!(self instanceof Sub)) return new Sub(opts);

    //// For Node users comfortable with calling super_ after creating Sub:
    //if(Sub.super_) Sub.super_.call(this, opts);
    //// Otherwise:
    parent(opts);
}

//// If using Node:
//inherits(Sub, Base);
//// Otherwise:
Sub.prototype.constructor = Base;
Sub.prototype.parent = Base.prototype;

// Implement the functionality for abstractMethod:
Sub.prototype.abstractMethod() {
    // Implementation details...
}

In regard to the initial question, the block of code marked by

if (!(self instanceof Sub)) return new Sub(opts);

ensures a fresh instantiation of the object.