Memahami Pergi melalui Lensa TypeScript/JavaScript

Jika anda datang dari latar belakang TypeScript/JavaScript dan menyelami Go, anda boleh membuat persamaan antara kedua-dua bahasa untuk mempercepatkan pembelajaran anda. Walaupun pada asasnya ia berbeza dalam banyak cara (Go sebagai bahasa yang ditaip secara statik, disusun dan TypeScript/JavaScript ditaip, ditafsirkan atau ditranskripsikan secara dinamik), terdapat beberapa analogi berguna yang akan membantu menjadikan Go lebih intuitif.

1. Struktur dalam Go ≈ Jenis dalam TypeScript

Dalam TypeScript, anda menentukan jenis dan antara muka untuk menerangkan bentuk objek. Begitu juga, Go mempunyai struct, yang digunakan untuk menentukan jenis tersuai. Sesuatu struct boleh mengandungi medan jenis yang berbeza, sama seperti cara jenis atau antara muka TypeScript mungkin mengandungi sifat yang berbeza.

Skrip Jenis:

type Book = {
  title: string;
  pages: number;
  read(): void;
}

Pergi:

type Book struct {
    Title string
    Pages int
}

func (b Book) Read() {
    fmt.Println("Reading", b.Title)
}

Dalam kedua-dua kes, anda mentakrifkan struktur objek. Walau bagaimanapun, struct Go adalah lebih tegar dan tidak menyokong warisan, tidak seperti TypeScript, yang membenarkan tingkah laku yang lebih dinamik dengan antara muka dan warisan kelas.

2. Kaedah dalam Go: Penerima ≈ Prototaip dalam JavaScript

Dalam JavaScript, apabila anda mentakrifkan kaedah pada prototaip objek, ia dikaitkan dengan tika objek itu. Go menggunakan konsep yang serupa dengan fungsi penerima yang diikat pada struct tertentu. Ini terasa serupa dengan cara fungsi dilampirkan pada objek dalam JavaScript melalui prototaip.

JavaScript:

function Book(title, pages) {
    this.title = title;
    this.pages = pages;
}

Book.prototype.read = function() {
    console.log("Reading", this.title);
}

Pergi:

type Book struct {
    Title string
    Pages int
}

func (b Book) Read() {
    fmt.Println("Reading", b.Title)
}

Dalam Go, kaedah Baca mempunyai penerima (b Book), yang bertindak serupa dengan cara kaedah dikaitkan dengan prototaip dalam JavaScript. Ia memberikan anda contoh objek (b di sini), membenarkan anda mengakses medan dan menggunakan kaedah tersebut.

3. let, var, const dalam TypeScript ≈ Pengisytiharan Pembolehubah dalam Go

Cara anda mengisytiharkan pembolehubah dalam Go adalah mengingatkan let, var dan const JavaScript. Dalam Go, pembolehubah diisytiharkan dengan var dan pemalar dengan const, sama seperti TypeScript.

Skrip Jenis:

let name: string = "TypeScript";
const maxItems: number = 100;

Pergi:

var name string = "Go"
const maxItems int = 100

Shorthand := dalam Go terasa agak seperti diizinkan JavaScript kerana ia membenarkan pengisytiharan pembolehubah pantas:

type Book = {
  title: string;
  pages: number;
  read(): void;
}

Dalam Go, tiada perbezaan antara let dan const seperti dalam JavaScript. Secara lalai, semua pembolehubah dalam Go boleh berubah apabila diisytiharkan dengan var, bermakna nilainya boleh ditukar kemudian. Jika anda ingin menjadikan pembolehubah tidak berubah dalam Go, anda mesti menggunakan kata kunci const secara eksplisit. Tidak seperti JavaScript, di mana anda telah membiarkan kedua-duanya untuk pembolehubah boleh ubah dan const untuk pembolehubah tidak berubah, dalam Go, semuanya boleh berubah melainkan anda mengisytiharkannya sebagai const.

4. Antara Muka Go ≈ Antara Muka TypeScript (dengan perbezaan)

Antara muka TypeScript mentakrifkan bentuk objek, manakala antara muka Go mentakrifkan gelagat (iaitu, satu set kaedah yang mesti ada pada objek). Dalam Go, objek "melaksanakan" antara muka secara tersirat dengan mempunyai semua kaedah yang diperlukan, yang berbeza dengan pelaksanaan eksplisit TypeScript.

Skrip Jenis:

type Book struct {
    Title string
    Pages int
}

func (b Book) Read() {
    fmt.Println("Reading", b.Title)
}

Pergi:

function Book(title, pages) {
    this.title = title;
    this.pages = pages;
}

Book.prototype.read = function() {
    console.log("Reading", this.title);
}

Dalam Go, sebarang jenis yang melaksanakan kaedah Baca dianggap melaksanakan antara muka Pembaca, walaupun tanpa mengisytiharkannya secara eksplisit.

5. Ralat Pengendalian dalam Go ≈ Try-Catch dalam JavaScript (tetapi berbeza)

Ralat pengendalian dalam Go terasa sangat berbeza berbanding dengan percubaan tangkap JavaScript. Dalam Go, pengendalian ralat dilakukan secara eksplisit dengan nilai pulangan, manakala JavaScript menggunakan pengecualian.

JavaScript:

type Book struct {
    Title string
    Pages int
}

func (b Book) Read() {
    fmt.Println("Reading", b.Title)
}

Pergi:

let name: string = "TypeScript";
const maxItems: number = 100;

Dalam Go, ralat dikembalikan daripada fungsi dan perlu disemak dengan jelas, yang membawa kepada aliran kawalan yang lebih boleh diramal tetapi memerlukan lebih banyak pengendalian ralat manual berbanding dengan mekanisme tangkap cuba JavaScript.

6. Sistem Pakej dalam Go ≈ Modul ES dalam TypeScript

Dalam TypeScript, anda menyusun kod anda ke dalam modul yang boleh mengimport/mengeksport bahagian fungsi lain. Go mempunyai sistem pakej yang serupa di mana setiap fail adalah sebahagian daripada pakej dan pakej boleh mengimport fungsi daripada pakej lain.

Skrip Jenis:

var name string = "Go"
const maxItems int = 100

Pergi:

name := "Go" // type inference, like in TypeScript

Dalam Go, pakej utama ialah titik masuk aplikasi anda, sama seperti cara fail utama boleh berfungsi sebagai titik masuk untuk projek TypeScript menggunakan modul ES.

7. Konkurensi dalam Go: Goroutines ≈ Pengaturcaraan Asynchronous

Pengaturcaraan tak segerak JavaScript dengan async/menunggu dan janji terasa agak serupa dengan goroutin Go. Goroutines membenarkan fungsi berjalan serentak, menjadikan model konkurensi Go sangat berkuasa.

JavaScript:

interface Reader {
  read(): void;
}

class Book implements Reader {
  read() {
    console.log("Reading a book");
  }
}

Pergi:

type Reader interface {
    Read()
}

type Book struct {
    Title string
}

func (b Book) Read() {
    fmt.Println("Reading", b.Title)
}

Dengan goroutine Go, anda boleh melancarkan fungsi serentak dengan kata kunci go, manakala TypeScript mencapai ini melalui async/wait and promises.

Kesimpulan

Beralih daripada TypeScript/JavaScript kepada Go mungkin kelihatan menakutkan pada mulanya, tetapi membuat perbandingan ini boleh membantu menjadikan peralihan lebih lancar. Memahami sistem jenis Go yang lebih ketat, antara muka eksplisit dan model konkurensi akan menjadikan perjalanan anda bermanfaat. Sebaik sahaja anda membiasakan diri dengan sifat Go yang lebih jelas dan tersusun, anda akan menghargai prestasi dan kebolehpercayaannya dalam membina sistem yang mantap.

Atas ialah kandungan terperinci Memahami Pergi melalui Lensa TypeScript/JavaScript. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!