Di Typecript, apa perbedaan antara type dan interface?

Apa perbedaan antara berikut ini?

type Foo = { 
    foo: string 
};
interface Foo {
   foo: string;
}

Antarmuka dapat diperpanjang

interface A {
  x: number;
}
interface B extends A {
  y: string;
}

dan juga ditambah

interface C {
  m: boolean;
}
// ... later ...
interface C {
  n: number;
}

Alias ​​tipe, bagaimanapun, dapat mewakili beberapa hal yang tidak dapat dilakukan antarmuka

type NumOrStr = number | string;
type NeatAndCool = Neat & Cool;
type JustSomeOtherName = SomeType;

Jadi secara umum jika Anda hanya memiliki tipe objek biasa, seperti yang ditunjukkan dalam pertanyaan Anda, antarmuka biasanya merupakan pendekatan yang lebih baik. Jika Anda mendapati diri Anda ingin menulis sesuatu yang tidak dapat ditulis sebagai antarmuka, atau hanya ingin memberi nama yang berbeda, alias tipe lebih baik.

Juga, sebuah antarmuka dapat diimplementasikan .

Tipe seperti Antarmuka dan sebaliknya: keduanya dapat diimplementasikan oleh kelas. tetapi ada beberapa perbedaan penting: 1. ketika Type diimplementasikan oleh sebuah kelas, properti milik Type harus diinisialisasi di dalam kelas, sedangkan dengan Interface mereka harus dideklarasikan. 2. seperti yang disebutkan @ryan: Antarmuka dapat memperluas Antarmuka lain. Tipe tidak bisa.

type Person = {
    name:string;
    age:number;
}

// must initialize all props - unlike interface
class Manager implements Person {
    name: string = 'John';
    age: number = 55;

    // can add props and methods
    size:string = 'm';
}

const jane : Person = {
    name :'Jane',
    age:46,

    // cannot add more proprs or methods
    //size:'s'
}

Perbedaan antara ini juga sudah ada di utas ini.

type Foo = {
    foo: string
};
interface Foo {
    foo: string;
}

Disini type Foodan interface Footampilannya hampir mirip sehingga membingungkan.

interfaceadalah kontrak bahwa properti berikut (di sini foo:string) harus ada di objek. interfacetidak class. Ini digunakan ketika bahasa tidak mendukung Warisan Ganda. Jadi interfacebisa menjadi struktur umum antara kelas yang berbeda.

class Bar implements Foo {
    foo: string;
}

let p: Foo = { foo: 'a string' };

Tetapi typedan interfacedigunakan dalam konteks yang sangat berbeda.

let foo: Foo;
let today: Date = new Date();

Ini typedari fooadalah Foodan todayadalah Date. Ini seperti deklerasi variabel yang menyimpan informasi jenis variabel lain. typeseperti superset antar muka, kelas, tanda tangan fungsi, jenis lain atau bahkan nilai (seperti type mood = 'Good' | 'Bad'). Di bagian akhir typemenjelaskan kemungkinan struktur atau nilai variabel.

Salah jika mengatakan "Antarmuka dapat diimplementasikan" karena tipe juga dapat diterapkan

type A = { a: string };


class Test implements A {

    a: string;
}

Meskipun Anda dapat melakukan ini, Anda tidak dapat menerapkan tipe yang merupakan gabungan tipe, yang benar-benar masuk akal :)

tipe di skrip ketikan digunakan untuk mereferensikan tipe yang sudah ada . Itu tidak bisa diperpanjang seperti interface. Contohnya typeadalah:

type Money = number;
type FormElem = React.FormEvent<HTMLFormElement>;
type Person = [string, number, number];

Anda dapat menggunakan Istirahat dan Spread dalam tipe:

type Scores = [string, ...number[]];
let ganeshScore = ["Ganesh", 10, 20, 30]
let binodScore = ["Binod", 10, 20, 30, 40]

Antarmuka, di sisi lain, memungkinkan Anda membuat JENIS BARU.

interface Person{
  name: string,
  age: number, 
}

Interface can be extended with extends keyword.
interface Todo{
  text: string;
  complete: boolean;
}

type Tags = [string, string, string]

interface TaggedTodo extends Todo{
 tags: Tags
}