Begini, kita perlu bercakap tentang ketagihan pemeriksaan jenis anda. Ya, anda – yang mempunyai 47 contoh semakan dalam perisian tengah pengesahan anda. Pembangun yang menulis lebih banyak kes ujian daripada kod sebenar. Orang yang menganggap TypeScript seperti itu hanya ulasan JSDoc yang mewah.

Intervensi

Izinkan saya melukis gambar kepada anda: Sekarang tengah hari, anda sedang menikmati secawan kopi ke-4 anda dan anda sedang menyahpepijat isu pengeluaran. Log menunjukkan pengguna entah bagaimana melepasi lima belas lapisan pengesahan masa jalan anda. Anda mempunyai lebih banyak ujian unit berbanding Twitter mempunyai pengguna aktif, namun entah bagaimana, entah bagaimana, seseorang berjaya menghantar nombor di mana rentetan sepatutnya berada.

"Tetapi itu mustahil!" anda menangis, menatal laporan liputan ujian anda menunjukkan 100% murni. "Saya menyemak untuk ini!"

Adakah anda? Adakah anda sangat? Atau adakah anda hanya menulis cek yang sama tiga kali:

1. Sekali dalam antara muka TypeScript
2. Sekali lagi dalam perisian tengah pengesahan anda
3. Dan sekali lagi dalam ujian unit anda

Berhenti Menguji Apa TypeScript Sudah Tahu

Berikut ialah idea revolusioner: Bagaimana jika kita hanya... mempercayai pengkompil? Saya tahu, konsep liar. Tapi dengar cakap saya.

interface ValidRabbit {
    username: string;
    password: string;
}
interface InvalidRabbit {
    username: number;
    password: string;
}


type ValidateRabbit<Rabbit> = Assert<
    //assert that Rabbit is of type {username, password}
    Is.Type<
        User,
        {
            username: string;
            password: string;
        }
    >,
    //custom compile time exceptions
    "Trix are for kids. Provide a username and password.",
    User
>;

// Ha! Silly Rabbit...
function checkRabbit<T>(rabbit: ValidateRabbit<T>) {
    // .... protect your trix
}

declare const rabbit1: ValidRabbit;
declare const rabbit2: InvalidRabbit;

checkRabbit(rabbit1);
checkRabbit(rabbit2);
/**        ~~~~~~~~~
 *           └───── Type Exception! "...Provide a username and password"
 */

"Tetapi Bagaimana dengan Pengeluaran?"

Saya boleh mendengar anda sekarang: "Tetapi bagaimana jika seseorang menghantar JSON tidak sah ke API saya?"

Pertama sekali, siapa yang menyakiti anda? Kedua, ya, sahkan sempadan API anda. Tetapi apabila data tersebut memasuki domain skrip taip anda, sudah tiba masanya untuk melepaskannya. Biarkan penyusun menjadi bouncer anda.

Inilah perkara yang dibawa oleh Byzantium kepada pihak isu amanah anda:

// Define your trust boundaries
type APIRequest<Request> = Assert<
    And<
    Is.On<Request, "body">,
    Or<Is.In<Request["method"], "POST">, Is.In<Request["method"], "PUT">>
>;,
    "Someone's being naughty with our API"
>;

// Now everything inside is type-safe
function handleRequest<R>(req: APIRequest<R>) {
    // If it compiles, it's valid
    // If it's valid, it compiles
    // This is the way
}

Pasukan DevOps Akan Menyayangi Anda (Untuk Sekali)

Gambar ini: Saluran paip CI/CD anda selesai dalam beberapa minit dan bukannya beberapa jam. Log pengeluaran anda tidak diisi dengan ralat jenis. Bil AWS anda tidak kelihatan seperti nombor telefon.

Bagaimana? Kerana Byzantium menggerakkan pemeriksaan jenis anda untuk menyusun masa. Tiada lagi:

• Menjalankan beribu-ribu ujian unit yang hanya menyemak jenis
• Menggunakan kitaran CPU menyemak jenis yang sama berulang kali
• Bangun pada pukul 3 pagi kerana seseorang melepasi fungsi yang tidak ditentukan dengan jelas bahawa ia mahukan rentetan

// Before: Your CPU crying for help
function validateUserMiddleware(req, res, next) {
    try {
        validateId(req.params.id)        // CPU cycle
        validateBody(req.body)           // CPU cycle
        validatePermissions(req.user)    // CPU cycle
        validateToken(req.headers.auth)  // CPU cycle
        // Your CPU is now considering a career change
        next()
    } catch (e) {
        res.status(400).json({ error: e.message })
    }
}

// After: Your CPU sending you a thank you note
type ValidRequest = Assert<
    And<
        Is.On<Request, 'params.id'>,
        Is.On<Request, 'body'>,
        Is.On<Request, 'user'>,
        Is.On<Request, 'headers.auth'>
    >,
    "Invalid request shape"
>;

function handleRequest(req: ValidRequest) {
    // Just business logic, no trust issues
}

"Tetapi Saya Suka Ujian Menulis!"

Hebat! Tulis ujian untuk perkara yang sebenarnya memerlukan ujian:

• Logik perniagaan
• Mata integrasi
• Aliran kerja pengguna
• Algoritma kompleks

Anda tahu apa yang tidak memerlukan ujian? Sama ada rentetan sebenarnya rentetan. Biarkan TypeScript menangani krisis kewujudan itu.

Perbincangan Nyata: Faedahnya

1. Pembangunan Lebih Pantas

   • Tiada lagi menulis pengesahan yang sama tiga cara berbeza
   • Tangkap ralat pada masa penyusunan, bukan pada 3 PG
   • Luangkan masa pada ciri, bukan plat dandang pengesahan

2. Prestasi Lebih Baik

   • Sifar masa jalanan overhed untuk semakan jenis
   • Saiz berkas yang lebih kecil (tiada perpustakaan pengesahan)
   • CPU gembira, hidup bahagia

3. Keselamatan yang Dipertingkat

   • Jaminan peringkat jenis tidak boleh dipintas
   • Tiada lagi "ops, terlupa untuk mengesahkannya"
   • Liputan lengkap secara lalai

4. Impian DevOps

   • Saluran paip CI/CD yang lebih pantas
   • Kos infrastruktur yang lebih rendah
   • Insiden pengeluaran yang lebih sedikit
   • Pasukan SRE yang lebih gembira (hasil mungkin berbeza-beza)

Bermula

interface ValidRabbit {
    username: string;
    password: string;
}
interface InvalidRabbit {
    username: number;
    password: string;
}


type ValidateRabbit<Rabbit> = Assert<
    //assert that Rabbit is of type {username, password}
    Is.Type<
        User,
        {
            username: string;
            password: string;
        }
    >,
    //custom compile time exceptions
    "Trix are for kids. Provide a username and password.",
    User
>;

// Ha! Silly Rabbit...
function checkRabbit<T>(rabbit: ValidateRabbit<T>) {
    // .... protect your trix
}

declare const rabbit1: ValidRabbit;
declare const rabbit2: InvalidRabbit;

checkRabbit(rabbit1);
checkRabbit(rabbit2);
/**        ~~~~~~~~~
 *           └───── Type Exception! "...Provide a username and password"
 */

Pilihan di Milik Anda

Anda boleh terus hidup dalam ketakutan, menulis semakan masa jalan untuk segala-galanya, menganggap TypeScript seperti menaip pilihan untuk JavaScript.

Atau anda boleh menyertai kami pada 2024, di mana kami mempercayai pengkompil kami dan membiarkannya menjalankan tugasnya.

Ingat: Setiap kali anda menulis semakan jenis masa jalan, di suatu tempat pengkompil TypeScript menangis.

Kesimpulan

Byzantium bukan sekadar perpustakaan lain – ia adalah campur tangan untuk isu kepercayaan anda dengan jenis. Sudah tiba masanya untuk melepaskan pemeriksaan masa jalan dan menerima kuasa jaminan masa kompilasi.

CPU anda akan berterima kasih kepada anda. Pasukan DevOps anda akan berterima kasih kepada anda. Pengguna anda akan berterima kasih kepada anda (dengan tidak mencari pepijat berkaitan jenis).

Dan yang paling penting, anda akan berterima kasih kepada diri sendiri pada pukul 3 PG apabila anda tidur nyenyak dan bukannya menyahpepijat ralat jenis dalam pengeluaran.

P.S. Jika anda masih tidak yakin, cuba kira berapa banyak semakan jenis masa jalan yang anda ada dalam pangkalan kod anda. Kemudian darabkan itu dengan kadar setiap jam anda. Itulah berapa banyak masa yang anda luangkan untuk tidak mempercayai TypeScript.

P.P.S. Tiada jenis yang dicederakan dalam pembuatan catatan blog ini. Walaupun beberapa semakan masa jalan telah dihentikan secara kekal.

*P.P.P.S. Jika anda ingin menyumbang, singgah di Github saya dan klon repo. Semuanya masih segar, jadi banyak peluang untuk menyumbang.

Dokumen dan Pakej tersedia di JSR.io

Atas ialah kandungan terperinci Intervensi TypeScript: Memecahkan Ketagihan Semakan Masa Jalanan Anda dengan Byzantium. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!