Ironi Penaipan Statik dalam Bahasa Dinamik

Anda juga boleh membaca artikel ini di Medium.

Selalu lucu apabila kita melihat bagaimana bahasa pengaturcaraan berkembang dari semasa ke semasa.

Pada suatu masa dahulu, apabila saya memulakan perjalanan saya dalam dunia pembangunan perisian, bahasa dinamik seperti Python, PHP dan JavaScript dihargai kerana fleksibiliti dan sintaks ringkas yang sesuai untuk pembangunan pesat.

Walau bagaimanapun, apabila bahasa yang ditaip lemah ini berkembang, ia menggabungkan ciri bahasa yang ditaip dengan kuat, menjadikannya hampir serupa dengan C dan Java:

• Python: Keupayaan pembayang jenis diperkenalkan sejak versi 3.5 pada 2015 dan dipertingkatkan dalam versi 3.12 pada 2022.
• PHP: Jenis yang diisytiharkan diperkenalkan dalam versi 7 pada 2015.
• JavaScript: Dilanjutkan dengan keluaran TypeScript pada tahun 2012 yang ditakrifkan sebagai "JavaScript dengan sintaks untuk jenis".

Kenapa peralihan ini?

Dalam bahasa menaip ketat, kami mentakrifkan jenis pembolehubah dalam kod kami secara eksplisit. Matlamatnya adalah untuk menangkap ralat semasa fasa pembangunan sebelum melaksanakan program dan memberikan petunjuk kepada pengkompil tentang saiz memori untuk diperuntukkan kepada pembolehubah ini.

// C++ example: 'y' will be an integer
float x = 3.14;
int y = x;  //  y = 3 (ignored the decimal part of the number)

Sebaliknya, bahasa yang ditaip secara dinamik seperti Python, PHP dan JavaScript membenarkan kami membuat pembolehubah dan membiarkan penterjemah membayangkan jenisnya semasa masa jalan:

# In python and PHP: 'y' will take the same type as 'x'
x = 3.14
y = x  // y = 3.14 (float)

Bagaimanakah penaipan eksplisit diperkenalkan dalam bahasa dinamik ?

Dalam contoh berikut, kami mengisytiharkan fungsi yang sama menggunakan penaipan dinamik dan statik.

Python:

# using the classic syntax:
def add(x, y):
    return x + y
# using explicit typing:
def add(x: int, y:int) -> int:
    return x + y

JavaScript / TypeScript:

// using the classic syntax
function add(x, y) {
    return x + y;
}
// using explicit typing
function add(x: number, y: number): number {
    return x + y;
}

PHP:

// using the classic syntax:
function add($x, $y) {
    return $x + $y;
}
// using explicit typing:
function add(int $x, int $y): int {
    return $x + $y;
}

PHP 8.2 (dikeluarkan pada Disember 2022) meneruskannya dengan memperkenalkan sokongan untuk null, true dan false sebagai jenis yang berdiri sendiri:

public null $nil = null;
public false $false = false;`

Di manakah ironinya?

Jangan anggap artikel ini sebagai bantahan terhadap ciri baharu ini, saya mengakui kelebihan menggunakan bahasa yang ditaip dengan ketat. Walau bagaimanapun, menggunakan anotasi jenis dalam Python, sebagai contoh, tidak menghalang anda daripada menukar jenis pembolehubah anda:

x: int = 0
x = "John" 
print(type(x))   # <class 'str'>

Sama untuk PHP, ia hanya akan mencetak amaran Dihentikan pada konsol.

Orang mungkin bertanya mengapa jurubahasa membenarkan kami melaksanakan kod ini?
Ini kerana bahasa ini dibina sedemikian: ia ditaip secara dinamik mengikut takrifan. Jika kita mengalih keluar ciri ini, ia tidak akan dinamik lagi; mereka akan menjadi bahasa ditaip ketat seperti C , tetapi lebih perlahan.

Mudah-mudahan, anda boleh meminta jurubahasa anda untuk menjadi lebih tegar dengan menetapkan strict_types kepada benar dalam fail PHP anda:

declare(strict_types=1);

Semasa dalam python, anda boleh menggunakan pakej 'mypy' untuk menganalisis kod anda dan menangkap pepijat:

// C++ example: 'y' will be an integer
float x = 3.14;
int y = x;  //  y = 3 (ignored the decimal part of the number)

Anda boleh melihat 'mypy' sebagai penasihat yang memberitahu anda kesalahan yang anda lakukan, tetapi ia tidak menghalang anda daripada melaksanakan kod anda atas risiko anda.

Walaupun anda tidak pasti tentang jenis pembolehubah anda, anda masih boleh menggunakan operator kesatuan untuk mengurangkan senarai jenis yang diterima:

Contoh berikut daripada PHP dan Python menunjukkan cara melakukannya:

# In python and PHP: 'y' will take the same type as 'x'
x = 3.14
y = x  // y = 3.14 (float)

Adakah kita mengorbankan kebolehbacaan kod?

Sepuluh tahun yang lalu, saya memutuskan untuk menggunakan Python untuk PhD saya kerana kesederhanaan dan keupayaan untuk membuat prototaip idea baharu dengan cepat. Kemudian saya mula menggunakannya juga untuk projek saya yang lain.

Kini, saya mendapati diri saya membaca beberapa PEP yang pelik dan menyoal diri sendiri sama ada ia benar-benar berbaloi untuk merumitkan pangkalan kod saya dengan memasukkan ciri baharu ini.

Mari lihat fungsi contoh yang mencetak item kamus. Berikut ialah versi awal:

# using the classic syntax:
def add(x, y):
    return x + y
# using explicit typing:
def add(x: int, y:int) -> int:
    return x + y

Dengan menggunakan pengesyoran daripada PEP 692 yang diperkenalkan dalam Python 3.12, kod tersebut menjadi:

// using the classic syntax
function add(x, y) {
    return x + y;
}
// using explicit typing
function add(x: number, y: number): number {
    return x + y;
}

Ringkasnya: kami mencipta kelas yang mewarisi daripada TypedDict, menyatakan nama dan jenis setiap item dan menggunakan operator Unpack untuk memberitahu "mypy" bahawa objek yang diterima ialah TypedDict.

Akibatnya, saiz kod kami meningkat dua kali ganda. Ia akan menjadi lebih panjang jika objek kita mempunyai lebih banyak item.

Nasib baik, kami boleh menggunakan penaipan statik untuk beberapa bahagian kod kami dan membiarkan yang lain sebagai dinamik. Atau kita boleh memilih untuk tidak menggunakannya sama sekali jika kita mahu.

Bilakah kita harus menggunakannya?

Jangan berasa tertekan untuk menulis semula keseluruhan pangkalan kod anda hanya kerana anda mempelajari ciri baharu yang berkilat.

Ciri baharu ini seperti alatan. Nasihat saya gunakannya dengan bijak:

Gunakan penaipan statik dalam senario berikut:

• Apabila mendapatkan semula data daripada sumber luaran, seperti pangkalan data, perpustakaan dan API.
• Di bahagian kritikal kod anda di mana kegagalan tidak dibenarkan.
• Apabila pangkalan kod anda terdedah kepada pepijat yang kerap berlaku.

Elakkan menggunakan penaipan statik apabila anda:

• Mereka bentuk prototaip untuk menguji idea anda dengan cepat.
• Melaksanakan logik dalaman dengan pemeriksaan jenis hanya akan menghasilkan kod bertele-tele dengan dan tiada faedah.
• Hanya memaparkan data pada skrin (cth. merancang carta, imej, nombor…).
• Menulis skrip baris arahan tanpa input pengguna.

Perlu diingat bahawa apabila bercakap tentang pengekodan, peraturan emas sentiasa untuk berusaha untuk kesederhanaan, kecuali jika anda mempunyai sebab yang kukuh untuk merumitkan perkara.

Atas ialah kandungan terperinci Ironi Penaipan Statik dalam Bahasa Dinamik. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!