在TypeScript中访问外部类的成员

Question

从TypeScript 1.6开始,我们可以使用类表达式轻松创建内部类.在像Java这样的其他以OOP为中心的语言中,内部类可以访问外部类的成员,甚至是私有成员.

此行为类似于闭包的概念,其中函数可以从定义它的作用域中访问变量.

为什么我无法在TypeScript中实现这一点？ECMAScript 2015中的类规范是否起作用？

显示预期行为的代码:

class OuterClass {
    private outerField = 1337;

    public InnerClass = class { 
        public accessOuter() {
            return this.outerField; // outerField not defined
        }
    }
}

var outer = new OuterClass();
var inner = new outer.InnerClass();
var win = inner.accessOuter();

Answer 1

如果你查看代码的已编译的javascript,你就更容易理解为什么你不能这样做:

var OuterClass = (function () {
    function OuterClass() {
        this.outerField = 1337;
        this.InnerClass = (function () {
            function class_1() {
            }
            class_1.prototype.accessOuter = function () {
                return this.outerField; // outerField not defined
            };
            return class_1;
        }());
    }
    return OuterClass;
}());

如您所见,outerField被定义为OuterClass像这样的成员:

this.outerField = 1337;

当您尝试访问它时,您InnerClass可以:

return this.outerField;

但this这里是实例class_1,而不是OuterClass所以没有outerField在this.
此外,您无法从内部类访问外部类的实例.

在java中解决这个问题的方式是这样的:

class OuterClass {
    private int outerField = 1337;

    public class InnerClass {
        public int accessOuter() {
            return OuterClass.this.outerField;
        }
    }
}

但是OuterClass.this.outerField在typescript/javascript中没有相同的东西.
看看typescript内部类更像是java中的静态内部类,但是在这里你也只能访问公共属性:

class OuterClass {
    public static outerField = 1337; // has to be public

    public InnerClass = class { 
        public accessOuter() {
            return OuterClass.outerField;
        }
    }
}

您可以将外部类的实例传递给内部类:

class OuterClass {
    public outerField = 1337;

    public InnerClass = class {
        constructor(private parent: OuterClass) {}

        public accessOuter() {
            return this.parent.outerField;
        }
    }
}

但同样,你需要outerField公开.

编辑

如果你想要实现一些模拟所需行为的东西(也就是说,内部类实例可以访问私有外部类成员),那么你可以这样做:

interface OuterClassProxy {
    outerField: number;
}

interface IInnerClass {}

class OuterClass {
    private outerField = 1337;

    static InnerClass = class implements IInnerClass {
        constructor(private parent: OuterClassProxy) {}

        public accessOuter() {
            return this.parent.outerField;
        }
    }

    public createInnerClass(): IInnerClass {
        let outerClassInstance = this;

        return new OuterClass.InnerClass({
            get outerField(): number {
                return outerClassInstance.outerField;
            },
            set outerField(value: number) {
                outerClassInstance.outerField = value;
            }
        });
    }
}

这是相当多的工作,但它会做到这一点.

Answer 2

@Nitzan的回答很棒.我只是想补充一点,我最近想出了这个,也许它会有所帮助:

class Outer {

    constructor() {
        this.val = 1337;
    }

    get Inner() {
        let Outer = this;
        return class {
            accessVal() { return Outer.val; }
        }
    }

}

new (new Outer()).Inner().accessVal(); // 1337