以下内容同样适用于TypeScript和JavaScript：
没有对等的。
JavaScript中的每一个成员访问都是动态分派的，这是因为JavaScript中的成员访问本质上是在哈希表中查找键。
一个对象可以声明一个成员，它通过原型链继承了一个相同的键，从而 * 影子 * 继承的成员，但这与虚拟性不同，虚拟性是语言中不存在的概念。

是的有。

//non-abstract or abstract class
class A {
    
    // The virtual method
    protected virtualStuff1?():void;

    public Stuff2(){
        //Calling overridden child method by parent if implemented
        this.virtualStuff1 && this.virtualStuff1();
        alert("Baseclass Stuff2");
    }
}

//class B implementing virtual method
class B extends A{
    
    // overriding virtual method
    public virtualStuff1()
    {
        alert("Class B virtualStuff1");
    }
}

//Class C not implementing virtual method
class C extends A{
 
}

var b1 = new B();
var c1= new C();
b1.Stuff2();
b1.virtualStuff1();
c1.Stuff2();

Javascript和Typescript中的所有方法在技术上都是虚拟的，因为没有什么可以阻止你重写任何方法。

我使用箭头函数作为类的属性来实现这一点（注意这是在ts中，但如果你对现代js很熟悉，它应该可以工作）：

class baseClass {
    doSomething = () => {};
}

class derivedClass extends baseClass {
    constructor() {
        this.doSomeThing = () => { console.log('something'); };
    }
}

如果你想定义一个函数而不给它赋值，你可以使用?字符。

class MyAbstract {
 myMethod?(arg: string): void;
}

class MyImpl {
 myMethod(arg: string): void { .... }
}

但是，当访问声明为MyAbstract的示例时，调用myMethod将始终引发Cannot invoke an object which is possibly 'undefined'.ts(2722)，因此您必须使用!字符来指定您确定它已实现。

let inst: MyAbstract;
// ...
inst.myMethod!('blah');