Apakah kita benar-benar membutuhkan TypeScript pada tahun 2020?

TypeScript telah menjadi salah satu keterampilan penting untuk pengembang web modern. Pada tahun 2019, ia memasuki TOP 10 bahasa yang paling banyak digunakan di GitHub , dukungannya sepenuhnya ditambahkan ke aplikasi Create react, dan Anda dapat menemukan banyak bukti lain dari popularitasnya yang semakin meningkat. Pada saat yang sama, bahasa seperti Java dan C terus kehilangan kekuatan.

Ketika kita berbicara tentang manfaat dari TypeScript, daftar berikut biasanya muncul di pikiran:

• TypeScript mendukung pengetikan statis
• TypeScript membuat kode lebih mudah dibaca dan dimengerti.
• TypeScript membantu menghindari banyak bug menyakitkan yang biasanya dibuat oleh pengembang, berkat mengetik kode check in
• TypeScript Mendorong Pengembang untuk Mengikuti Praktik OOP Terbaik
• Sebagai hasil dari hal di atas - TypeScript menghemat waktu pengembang

Menariknya, semua item dalam daftar ini diambil dengan keyakinan tanpa mata yang kritis. Hari ini saya sarankan Anda mempertimbangkan hal-hal ini lebih dekat dan mencari tahu apakah mereka benar-benar bermanfaat bagi kami.

Karena tujuan utama dari TypeScript adalah untuk mengurangi jumlah bug, mari kita putuskan mengapa ini sangat penting? Jawabannya sederhana: semakin sedikit bug - semakin murah waktu yang kita habiskan untuk pengembang dan penguji, oleh karena itu - kita akan mendapatkan produk berharga dengan lebih sedikit uang dan akan mulai menghasilkan pendapatan lebih awal.

Dengan mengingat hal itu, mari cari tahu bagaimana TypeScript dapat membantu kami meningkatkan produktivitas dan efisiensi kami.

Pengetikan statis - tablet ajaib untuk bug?

Fitur utama dari TypeScript adalah dukungan untuk pengetikan statis. Ada kepercayaan luas di kalangan pengembang bahwa pengetikan dinamis adalah sumber dari hampir semua masalah yang dimiliki pengembang JavaScript.

Saya bertanya-tanya apa yang ditemukan orang jahat dalam pengetikan dinamis? Mengapa rentetan kritik tidak jatuh pada bahasa dinamis lain, misalnya, Python dan Ruby? Saya hanya bisa berasumsi bahwa masalahnya bukan pada pengetikan dinamis seperti pada pengetikan tipe dalam JavaScript. Memang, kadang-kadang bisa sangat tidak menyenangkan untuk mengejutkan kode seperti ini:


Tapi ini adalah masalah pengetahuan yang agak buruk tentang JavaScript, dan bukan bahasa itu sendiri. Bayangkan Anda memiliki mobil sport yang kuat. Tetapi keterampilan mengemudi Anda cukup biasa-biasa saja. Akankah Anda meminta pabrikan mobil untuk membuat perubahan untuk mengurangi kecepatan maksimum mobil atau mempelajari keterampilan mengemudi yang canggih dan menjadi seorang profesional yang luar biasa? Apa yang ditawarkan TypeScript kepada kami adalah membatasi kemungkinan pengetikan dinamis, daripada mempelajari JavaScript dengan benar.

Pertanyaan lain untuk penentang pengetikan dinamis adalah bahwa jika pengetikan statis sangat bagus, mengapa kita masih menemukan bug dalam kode yang ditulis dalam Java dan C #? Ya, kami dapat menangkap kesalahan ini pada tahap kompilasi, tapi jujur ​​saja, ini tidak cukup. Kita harus mengikuti prinsip-prinsip SOLID dan praktik terbaik lainnya untuk memastikan kode kualitas. Dan lagi - ini berlaku lebih untuk pengetahuan dan kualifikasi programmer daripada bahasa pemrograman.

Apakah kode TypeScript lebih mudah dibaca?

Berikut adalah 2 contoh Redux Thunk:

const getUsers = async dispatch => { //... try { const users = await APIService.get('/users') dispatch(successGetUsers(users)) } catch(err) { dispatch(failedGetUsers(err)) } } 

dan sama pada TypeScript:

 const getUsers = (): ThunkAction<void, {}, {}, AnyAction> => async (dispatch: ThunkDispatch<{}, {}, AnyAction>) => { //... try { const users: User[] = await APIService.get('/users') dispatch(successGetUsers(users)) } catch(err) { dispatch(failedGetUsers(err)) } } 

Apa arti semua obat generik ini? Mengapa ada 2 benda kosong di dalamnya? Berapa banyak waktu yang harus kita habiskan membaca dokumentasi untuk mencari tahu semuanya? Nah, itu masih normal untuk Redux Thunk, karena ini adalah middleware yang sangat populer untuk Redux, mereka memiliki tim pendukung dan dokumentasi yang sangat baik. Tetapi bagaimana jika kita harus mempertahankan kode yang tidak memiliki semua ini?

Tidak akan ada lagi bug yang halus?

Pada contoh sebelumnya, Anda melihat bagaimana TypeScript membuat kode lebih bertele-tele. Seperti yang Anda tahu, semakin besar dan kompleks sistem, semakin besar kemungkinan kesalahan. Selain kesalahan yang bisa kita buat dalam kode JavaScript, kita juga harus berhati-hati untuk tidak membuat kesalahan ketik pada antarmuka, kesalahan dalam obat generik, dll. Dalam keadilan, perlu dicatat bahwa kompiler akan membantu Anda dengan cepat menemukan dan memperbaiki kesalahan tersebut, tetapi tanpa TypeScript kita tidak akan menemui mereka sama sekali.

Mengikuti praktik terbaik OOP

Seperti yang kita ketahui, kita harus mengikuti praktik terbaik jika kita ingin menulis kode berkualitas tinggi, mudah diskalakan, dan dikelola. Dan TypeScript dapat membantu kita dengan ini. Kedengarannya hebat, mari kita lihat contoh dari Express:

userRoute.js

 router.get('/users', (req, res) => { //get users from DB res.json(users) }) router.post('/users', (req, res) => { //create user res.json(userCreated) }) 

userRoute.ts

 class UserRouter { public router = express.Router() public address = '/users' constructor() { this.initRoutes() } initRoutes() { this.router.get(this.address, this.getUsers) this.router.post(this.addressm this.createUser) } getUsers(req: express.Request, res: express.Response) { //get users from DB res.json(users) } createUser(req: express.Request, res: express.Response) { //create user res.json(userCreated) } } 

Hal pertama yang menarik perhatian Anda adalah bahwa lebih banyak kode sedang ditulis lagi. Kami menggunakan kelas untuk menulis dalam gaya OOP. Kami kemudian harus instantiate kelas-kelas ini. Selain itu, kita dapat menggunakan antarmuka, tipe statis, dan konstruksi lainnya. Dan agar semua ini tidak berubah menjadi kekacauan total, kita tidak punya pilihan selain menggunakan praktik terbaik. Dan inilah yang disebut: "mendorong pengembang untuk menggunakan praktik OOP terbaik . "

Ketika pengembang memilih untuk bahasa yang sederhana, fleksibel dan dinamis seperti JavaScript dan Python, ketika paradigma pemrograman fungsional menunjukkan kelebihan dan kemampuan untuk memecahkan beberapa masalah dengan lebih elegan dan efisien (dan dalam JavaScript kita dapat menggunakan kedua pendekatan), TypeScript mendorong kita untuk untuk menulis kode dengan cara kuno dalam gaya OOP Java dan C #.

Untuk meringkas, kami melihat bahwa TypeScript tidak benar-benar menghemat waktu kami, itu tidak melindungi kami dari sejumlah besar bug, maupun meningkatkan produktivitas kami. Selain itu, diperlukan penulisan lebih banyak kode, konfigurasi tambahan, ketik file definisi, dan buang waktu membaca dokumentasi tambahan. Seorang pemula mungkin akan menulis, mungkin bukan yang ideal, tetapi aplikasi yang berfungsi dalam JavaScript atau Ruby, sementara kami akan menulis aplikasi TypeScript yang sangat baik sesuai dengan semua prinsip. Dan kemudian dia akan mempekerjakan kita untuk menulis ulang startup-nya, di mana kita dapat menggunakan TypeScript untuk melakukan semuanya dengan benar.

Sangat menyenangkan melihat bagaimana bahasa yang masif, verbal dan rumit pergi, tidak mampu menahan persaingan dengan yang lebih dinamis dan sederhana, dan kemudian yang terakhir meninggalkan segala sesuatu yang membantu mereka berkembang begitu cepat dan berusaha untuk menjadi lebih berat, lebih verbal dan lebih rumit.

Saya melihatnya seperti ini:

Oke, kami tidak ingin Java lagi, kami ingin JavaScript. Tapi kami tidak suka JavaScript apa adanya, jadi mari kita membuatnya sedikit lebih seperti Java. Hebat, sekarang kami memiliki semua yang ada di Jawa, dan ini bukan Jawa. Ayo pergi!