В чем разница между типом и классом в Typescript?

class myClass extends myParentClass implements myInterface{

}

let value = new myClass();

// value is from type any and from type myClass and from type myParentClass and from type myInterface. Its class is myClass

Вы можете использовать new только с именами классов. Но Point - это не имя класса, а значение.

class Point{
    private x;
    private y;
    constructor(x,y) {
        this.x = v1;
        this.y = v2;
    }
}

Теперь Point - это класс, и вы можете:

let p = new Point(1,2);

Вы используете type (или в других случаях interface) для аннотаций типов, чтобы указать структуру объектов JavaScript:

type Point = {
  x: number, y: number
}

function doSomething(p: Point) {
}

let p: Point = { x: 10, y: 15 };
doSomething(p);

Эти аннотации типов подлежат структурной типизации, что означает, что в этом конкретном случае вы можете отбросить аннотацию типа:

let p = { x: number, y: number };
doSomething(p);

Класс - это нечто совершенно иное, что обеспечивает более элегантную альтернативу наследованию прототипа JS:

class Point {
    public x: number;
    public y: number;

    constructor(x: number, y: number) {
        this.x = x;
        this.y = y;
    }

    public move(deltaX: number, deltaY: number) {
        this.x = this.x + deltaX;
        this.y = this.y + deltaY;
    }
}

let p = new Point(10, 15);
p.move(1, 2);

Когда вы посмотрите на сгенерированный JS-код, вы быстро заметите разницу:

Объявление type опускается в сгенерированный код.

Определение класса превращено в JS-функцию с наследованием прототипа.

В Typescript есть две разные юниверсы, которые соприкасаются в некоторых точках: пространство значений и пространство типов. Пространство типов - это место, где типы определяются, а типы полностью стираются и не существуют во время выполнения. Пространство значений содержит значения и, очевидно, будет существовать во время выполнения.

Что такое ценность? Литералы значений, переменные, константы и параметры, очевидно, являются значениями. Функции и объявления классов также являются значениями, поскольку у них есть резервный объект среды выполнения, а именно объект функции и конструктор класса (также функция). Перечисления также являются значениями, поскольку они поддерживаются объектом во время выполнения.

Что такое тип? Любое определение с ключевым словом type является типом, а также интерфейсами, объявления классов и перечисляет

Вы заметите, что я упомянул объявления классов в обоих местах. Классы существуют как в пространстве типов, так и в пространстве значений. Вот почему мы можем использовать их как в аннотациях типов (let foo: ClassName), так и в выражениях (например, new ClassName()).

Перечисления также охватывают оба мира, они также представляют тип, который мы можем использовать в аннотации, а также объект среды выполнения, который будет содержать перечисление.

Имена в пространстве типов и пространстве значений не конфликтуют, поэтому мы можем определить как тип, так и переменную с одним и тем же именем:

type Foo = { type: true }
var Foo = { value : true } // No error, no relation to Foo just have the same name in value space 

Объявления классов и перечисления, поскольку они охватывают оба пространства, будут `` использовать '' имя в обоих пространствах, и поэтому мы не можем определить переменную или тип с тем же именем, что и объявление класса или перечисление (хотя мы можем выполнить слияние, но это это другое понятие)

В вашем конкретном случае Point - это просто тип, то, что мы можем использовать в аннотациях типов, а не то, что мы можем использовать в выражениях, которые должны присутствовать во время выполнения. В этом случае тип полезен, поскольку он позволяет компилятору структурно проверить, что литерал объекта может быть назначен типу Point:

let p: Point = { x: 10, y: 15 }; // OK
let p: Point = { x: 10, y: 15, z: 10 }; // Error

Если вы хотите создать класс, вам нужно будет сделать это с помощью ключевого слова class, так как это создаст значение времени выполнения, которое не является просто типом:

class Point{
    constructor(public x: number, public y: number){}
}
let p = new Point(10,10)

Для лучшего понимания создаю таблицу всех отличий:

| Description                                             | Type | Interface |
|---------------------------------------------------------|------|-----------|
| Describe functions                                      |   ✔  |     ✔     |
| Describe constructors                                   |   ✔  |     ✔     |
| Describe tuples                                         |   ✔  |     ✔     |
| Interfaces can extend                                   |   ≈  |     ✔     |
| Classes can extend                                      |   ✘  |     ✔     |
| Classes can implement                                   |   ≈  |     ✔     |
| Divide another one of its own kind                      |   ✔  |     ≈     |
| Create a union with another one of its own kind         |   ✔  |     ✘     |
| Be used to create mapped types                          |   ✔  |     ✘     |
| Be mapped over with mapped types                        |   ✔  |     ✔     |
| Expands in error messages and logs                      |   ✔  |     ✘     |
| Be completed                                            |   ✘  |     ✔     |
| Be recursive                                            |   ≈  |     ✔     |

Hint: `≈` means partially

Возможно, для новых версий TypeScript в этой таблице есть некоторые изменения, если есть, пожалуйста, исправьте таблицу, отредактировав текущий пост.