Typescript 静态属性继承未按预期工作_Typescript_Browserify_Visual Studio Code_Tsify

Typescript 静态属性继承未按预期工作

typescript visual-studio-code

Typescript 静态属性继承未按预期工作,typescript,browserify,visual-studio-code,tsify,Typescript,Browserify,Visual Studio Code,Tsify,我有这样的东西 TestBase.ts export class TestBase { static myValue: boolean; constructor() { TestBase.myValue = true; } } import {Test} from './Test'; import {TestBase} from './TestBase'; export class SomeOtherClass { constructor()

我有这样的东西

TestBase.ts

export class TestBase {
    static myValue: boolean;
    constructor() {
        TestBase.myValue = true;
    }
}

import {Test} from './Test';
import {TestBase} from './TestBase';

export class SomeOtherClass {
    constructor() {
        var test = new Test();
        console.log(Test.myValue); // undefined
        Test.myValue = false;
        console.log(Test.myValue, TestBase.myValue); // false, true
    }
}

export class TestBase {
    static someObject = { myValue: boolean };
    constructor() {
        TestBase.someObject.myValue = true;
    }
}

import {Test} from './Test';
import {TestBase} from './TestBase';

export class SomeOtherClass {
    constructor() {
        var test = new Test();
        console.log(Test.someObject.myValue); // true
        Test.myValue = false;
        console.log(Test.someObject.myValue, TestBase.someObject.myValue); // false, false
    }
}

测试

import {TestBase} from './TestBase'

export class Test extends TestBase {
    constructor() {
        super();
    }
}

import {TestBase} from './TestBase'

export class Test extends TestBase {
    constructor() {
        super();
    }
}

SomeOtherClass.ts

export class TestBase {
    static myValue: boolean;
    constructor() {
        TestBase.myValue = true;
    }
}

import {Test} from './Test';
import {TestBase} from './TestBase';

export class SomeOtherClass {
    constructor() {
        var test = new Test();
        console.log(Test.myValue); // undefined
        Test.myValue = false;
        console.log(Test.myValue, TestBase.myValue); // false, true
    }
}

export class TestBase {
    static someObject = { myValue: boolean };
    constructor() {
        TestBase.someObject.myValue = true;
    }
}

import {Test} from './Test';
import {TestBase} from './TestBase';

export class SomeOtherClass {
    constructor() {
        var test = new Test();
        console.log(Test.someObject.myValue); // true
        Test.myValue = false;
        console.log(Test.someObject.myValue, TestBase.someObject.myValue); // false, false
    }
}

我的IDE建议

myValue

在

Test

上可用，但在运行时它并不反映

TestBase.myValue

的值。IDE是否错误地建议允许静态属性继承，或者browserify/tsify是否破坏了某些东西？

它的类级属性尝试作为成员级实例将不起作用。我们需要声明为成员实例并初始化为成员实例，而不是类对象

export class TestBase {
    static myValue: boolean;
    constructor() {
        this.myValue = true;
    }
}

它的类级属性尝试作为成员级实例将不起作用。我们需要声明为成员实例并初始化为成员实例，而不是类对象

export class TestBase {
    static myValue: boolean;
    constructor() {
        this.myValue = true;
    }
}

我认为它与typescript无关，而且您的IDE是正确的。静态成员被继承（）。我已经在node.js环境和chrome浏览器中尝试了您的示例，并将其输出

真的

假，真

正如所料。所以我想你是正确的，假设有其他东西把事情搞砸了，可能是浏览化。

我认为这与typescript无关，你的IDE是正确的。静态成员被继承（）。我已经在node.js环境和chrome浏览器中尝试了您的示例，并将其输出

真的

假，真

正如所料。所以我想你是正确的，假设有其他东西把事情搞砸了，可能是浏览化。

你不能继承静态属性或方法。

你不能继承静态属性或方法

class TestBase {
    static myValue: boolean;
    constructor() {
        TestBase.myValue = true;
    }
}

class Test extends TestBase {
    constructor() {
        super();
    }
}

class SomeOtherClass {
    constructor() {
        var test = new Test();
        console.log(Test.myValue); // undefined
        Test.myValue = false;
        console.log(Test.myValue, TestBase.myValue); // false, true
    }
}

class HelloWorld{
    public static main(){
        let some = new SomeOtherClass();
    }
}
HelloWorld.main();

我认为它是未定义的，因为只有在调用该类的构造函数时才初始化它

用这个换

class TestBase {
        static myValue: boolean = true;
        constructor() {
            TestBase.myValue = true;
        }
    }

您可能已经知道，但不需要构建对象来调用静态成员

在第一次构建对象时，

Test.myValue

和

TestBase.myValue

是未定义的。对于类

TestBase

在

constructor

中的更改，

TestBase.myValue=true，但不用于测试，因为在创建要更改但不在Test
中的对象后，可以静态访问Test.myValue或TestBase.myValue，以及TestBase.myValue

适用于原始代码：
class SomeOtherClass {
    constructor() {

        console.log(Test.myValue);     // undefined
        console.log(TestBase.myValue); // undefined

        var test = new Test();

        console.log(Test.myValue);     // undefined
        console.log(TestBase.myValue); // true
    }
}

我认为它是未定义的，因为只有在调用该类的构造函数时才初始化它
用这个换
class TestBase {
        static myValue: boolean = true;
        constructor() {
            TestBase.myValue = true;
        }
    }


您可能已经知道，但不需要构建对象来调用静态成员
在第一次构建对象时，Test.myValue
和TestBase.myValue
是未定义的。对于类TestBase
在constructor
中的更改，TestBase.myValue=true，但不用于测试，因为在创建要更改但不在Test
中的对象后，可以静态访问Test.myValue或TestBase.myValue，以及TestBase.myValue

适用于原始代码：
class SomeOtherClass {
    constructor() {

        console.log(Test.myValue);     // undefined
        console.log(TestBase.myValue); // undefined

        var test = new Test();

        console.log(Test.myValue);     // undefined
        console.log(TestBase.myValue); // true
    }
}

在Typescript中，静态原语并没有像我期望的那样被继承，但是静态对象是。我能够通过将值保存在对象中来解决这个问题
TestBase.ts
export class TestBase {
    static myValue: boolean;
    constructor() {
        TestBase.myValue = true;
    }
}

import {Test} from './Test';
import {TestBase} from './TestBase';

export class SomeOtherClass {
    constructor() {
        var test = new Test();
        console.log(Test.myValue); // undefined
        Test.myValue = false;
        console.log(Test.myValue, TestBase.myValue); // false, true
    }
}

export class TestBase {
    static someObject = { myValue: boolean };
    constructor() {
        TestBase.someObject.myValue = true;
    }
}

import {Test} from './Test';
import {TestBase} from './TestBase';

export class SomeOtherClass {
    constructor() {
        var test = new Test();
        console.log(Test.someObject.myValue); // true
        Test.myValue = false;
        console.log(Test.someObject.myValue, TestBase.someObject.myValue); // false, false
    }
}

测试
import {TestBase} from './TestBase'

export class Test extends TestBase {
    constructor() {
        super();
    }
}

import {TestBase} from './TestBase'

export class Test extends TestBase {
    constructor() {
        super();
    }
}

SomeOtherClass.ts
export class TestBase {
    static myValue: boolean;
    constructor() {
        TestBase.myValue = true;
    }
}

import {Test} from './Test';
import {TestBase} from './TestBase';

export class SomeOtherClass {
    constructor() {
        var test = new Test();
        console.log(Test.myValue); // undefined
        Test.myValue = false;
        console.log(Test.myValue, TestBase.myValue); // false, true
    }
}

export class TestBase {
    static someObject = { myValue: boolean };
    constructor() {
        TestBase.someObject.myValue = true;
    }
}

import {Test} from './Test';
import {TestBase} from './TestBase';

export class SomeOtherClass {
    constructor() {
        var test = new Test();
        console.log(Test.someObject.myValue); // true
        Test.myValue = false;
        console.log(Test.someObject.myValue, TestBase.someObject.myValue); // false, false
    }
}

在Typescript中，静态原语并没有像我期望的那样被继承，但是静态对象是。我能够通过将值保存在对象中来解决这个问题
TestBase.ts
export class TestBase {
    static myValue: boolean;
    constructor() {
        TestBase.myValue = true;
    }
}

import {Test} from './Test';
import {TestBase} from './TestBase';

export class SomeOtherClass {
    constructor() {
        var test = new Test();
        console.log(Test.myValue); // undefined
        Test.myValue = false;
        console.log(Test.myValue, TestBase.myValue); // false, true
    }
}

export class TestBase {
    static someObject = { myValue: boolean };
    constructor() {
        TestBase.someObject.myValue = true;
    }
}

import {Test} from './Test';
import {TestBase} from './TestBase';

export class SomeOtherClass {
    constructor() {
        var test = new Test();
        console.log(Test.someObject.myValue); // true
        Test.myValue = false;
        console.log(Test.someObject.myValue, TestBase.someObject.myValue); // false, false
    }
}

测试
import {TestBase} from './TestBase'

export class Test extends TestBase {
    constructor() {
        super();
    }
}

import {TestBase} from './TestBase'

export class Test extends TestBase {
    constructor() {
        super();
    }
}

SomeOtherClass.ts
export class TestBase {
    static myValue: boolean;
    constructor() {
        TestBase.myValue = true;
    }
}

import {Test} from './Test';
import {TestBase} from './TestBase';

export class SomeOtherClass {
    constructor() {
        var test = new Test();
        console.log(Test.myValue); // undefined
        Test.myValue = false;
        console.log(Test.myValue, TestBase.myValue); // false, true
    }
}

export class TestBase {
    static someObject = { myValue: boolean };
    constructor() {
        TestBase.someObject.myValue = true;
    }
}

import {Test} from './Test';
import {TestBase} from './TestBase';

export class SomeOtherClass {
    constructor() {
        var test = new Test();
        console.log(Test.someObject.myValue); // true
        Test.myValue = false;
        console.log(Test.someObject.myValue, TestBase.someObject.myValue); // false, false
    }
}

使用this
访问静态
值是无效的Typescript。使用this
访问静态
值是无效的Typescript。如果属性是静态的，那么第二行的输出不应该是true，true
？不在Typescript中，因为它是在javascript中编译的吗（es5-使用原型，es6-类）。我注意到的另一个观察结果是：在上面的测试中，我的目标是es6，但如果我的目标是es5（例如在typescript中运行代码）-我将像您一样在输出中获得“undefined”（未定义）。因此，我会说编译到ES5和ES6之间存在差异，可能是错误？在这种情况下，IDE是否不正确，考虑到属性不应该在子类上可用？我认为根据规范，属性应该在子类中，因为它是继承的（尽管静态继承的行为与C#不同）-因此IDE是正确的。我看到的唯一错误行为是为不同的目标编译时的“未定义”与“true”。“静态继承的行为与C#不同。”-我想这就是我在这里缺少的。你能指出一个描述这一点的链接，或者规范的一部分吗？如果属性是静态的，那么第二行的输出不应该是true，true
？不是在Typescript中，因为它是用javascript编译的（es5-使用原型，es6-类）.我注意到的另一个观察结果是：在上面的测试中，我的目标是ES6，但如果我的目标是ES5（例如，在typescript中运行代码）-我将像您一样在输出中获得“undefined”（未定义）。因此，我会说编译到ES5和ES6之间存在差异，可能是错误？在这种情况下，IDE是否不正确，考虑到属性不应该在子类上可用？我认为根据规范，属性应该在子类中，因为它是继承的（尽管静态继承的行为与C#不同）-因此IDE是正确的。我看到的唯一错误行为是为不同的目标编译时的“未定义”与“true”。“静态继承的行为与C#不同。”-我想这就是我在这里缺少的。你能指出一个描述这一点的链接，或者规范的一部分吗？我认为这不是真的，如果不是为什么他可以在TestBase中声明myValue时执行Test.myValue。