¿Es posible lograr un alcance dinámico en JavaScript sin recurrir a eval?

Para agregar una nota sobre este tema:

En JavaScript cada vez que haga uso de:

• Declaración de función declaración o expresión de definición de función entonces las variables locales tendrán Ámbito léxico .

• Function constructor entonces las variables locales se referirán al ámbito global (código de nivel superior)

• this es el único objeto incorporado en JavaScript que tiene una dinámica scoping y se establece a través de la ejecución (o invocación) contexto.

Así que para responder a su pregunta, En JS el this ya es característica de alcance dinámico del lenguaje e incluso no es necesario emular otro.

No lo creo.

Así no es como funciona el lenguaje. Tienes que usar algo más que variables para referirte a esta información de estado. La forma más" natural " es usar propiedades de this, supongo.

En su caso, en lugar de intentar usar el ámbito dinámico para establecer el constructor, ¿qué pasa si utiliza el valor devuelto?

function Class(clazz) {
    return function () {
        clazz.apply(this, arguments).apply(this, arguments);
    };
}

var Rectangle = new Class(function () {
    var width, height;

    this.area = function () {
        return width * height;
    };

    // Constructor
    return function (w, h) {
        width = w;
        height = h;
    };
});

var rectangle = new Rectangle(2, 3);
console.log(rectangle.area());

¿Por qué nadie dijo this?

Puede pasar variables del ámbito invocador a la función invocada vinculándola con un contexto.

function called_function () {
   console.log(`My env ${this} my args ${arguments}`, this, arguments);
   console.log(`JS Dynamic ? ${this.jsDynamic}`);
}

function calling_function () {
   const env = Object.create(null);
   env.jsDynamic = 'really?';

   ... 

   // no environment
   called_function( 'hey', 50 );

   // passed in environment 
   called_function.bind( env )( 'hey', 50 );

Quizás vale la pena mencionar que en modo estricto, todas las funciones no tienen ningún "entorno" enviado a ellas por defecto (this es null). En modo no estricto el objeto global es el valor predeterminado this para una función llamada.

Puede simular el alcance dinámico utilizando variables globales, si tiene una forma de hacer azúcar sintáctica (por ejemplo, macros con gensyms) y si tiene unwind-protect.

La macro puede aparecer para volver a enlazar la variable dinámica guardando su valor en un léxico oculto y luego asignando un nuevo valor. El código unwind-protect garantiza que no importa cómo termine ese bloque, se restaurará el valor original del global.

Seudocódigo Lisp:

(let ((#:hidden-local dynamic-var))
  (unwind-protect
    (progn (setf dynamic-var new-value)
           body of code ...)
    (set dynamic-var #:hidden-local)))

Por supuesto, esto no es un thread-forma segura de hacer alcance dinámico, pero si no estás haciendo threading, lo hará! Escondíamos detrás de una macro como:

(dlet ((dynamic-var new-value))
   body of code ...)

Entonces, si tiene unwind-protect en Javascript y un preprocesador de macro para generar algo de azúcar sintáctica (por lo que no está codificando manualmente todos sus guardados y restauraciones protegidas por unwind), podría ser factible.

Sé que esto no responde exactamente a la pregunta, pero es demasiado código para poner en un comentario.

Como un enfoque alternativo, es posible que desee buscar en la función extend de ExtJS. Así es como funciona:

var Rectangle = Ext.extend(Object, {
    constructor: function (w, h) {
        var width = w, height = h;
        this.area = function () {
            return width * height;
        };
    }
});

Con propiedades públicas en lugar de variables privadas:

var Rectangle = Ext.extend(Object, {
    width: 0,
    height: 0,  

    constructor: function (w, h) {
        this.width = w;
        this.height = h;
    },

    area: function () {
        return this.width * this.height;
    }
});