IT

PHP 8.0: Memperkenalkan Versi PHP Baru

Dengan senang hati kami mengumumkan PHP 8.0 sekarang tersedia di server Hostinger. Versi ini hadir dengan fitur dan perubahan baru untuk memberikan kinerja terbaik untuk proyek web Anda.

Karena ini adalah pembaruan besar, kami mendorong semua pengguna yang bermigrasi ke rilis terbaru untuk membiasakan diri dengan perubahan baru yang akan kami bahas dalam artikel ini.

Mengapa Anda Membutuhkan PHP 8.0?

Tes benchmark terbaru oleh Phoronix menunjukkan PHP 8.0 berkinerja 10% lebih baik dari pendahulunya. Data ini menunjukkan masa depan yang menjanjikan untuk situs web dan aplikasi berbasis PHP.

Patokan PHP 9.0-rc5

Lebih baik lagi, pengujian bahkan tidak dilakukan dengan menggunakan kompiler JIT, fitur pengoptimalan baru yang diperkenalkan dengan PHP 8.0. Pengembang dapat mengharapkan kinerja yang jauh lebih cepat jika diaktifkan.

Selain itu, versi ini mengimplementasikan fitur baru untuk membuat pengkodean lebih cepat dan lebih bersih, mengurangi banyak boilerplate dan kode yang berlebihan.

Karena ini adalah pembaruan versi, situs web Anda kemungkinan akan mengalami perubahan yang mungkin merusaknya jika Anda beralih ke PHP 8.0 tanpa melakukan modifikasi sebelumnya. Untuk membantu mempersiapkan migrasi, kami akan memandu Anda melalui semua fitur terbaru.

Mengubah Versi PHP Anda

Klien Hostinger dapat mengikuti langkah-langkah berikut untuk memperbarui versi PHP mereka:

  1. Masuk ke hPanel dan buka Anda Akun Hosting dasbor .
  2. Di bawah bagian Lanjutan , klik Konfigurasi PHP .
  3. The PHP Versi tab akan menampilkan yang PHP yang Anda gunakan. Untuk memperbaruinya ke rilis terbaru, pilih PHP 8.0 dan tekan Simpan .
PHP 8.0 dipilih pada layar Konfigurasi PHP di hPanel

Perhatikan bahwa pembaruan mungkin memerlukan beberapa menit untuk diselesaikan dan menyebabkan situs web Anda tidak tersedia untuk sementara.

Apa yang Baru di PHP 8.0

Ada banyak perubahan kualitas hidup yang datang dengan pembaruan baru bersama banyak fitur baru. Mari kita jelajahi apa yang baru dan apa yang berubah di PHP 8.0.

Kompiler JIT (Just-in-Time)

The JIT compiler adalah salah satu pembaruan yang paling menarik untuk PHP 8.0. Fitur ini bertujuan untuk bekerja dengan opcache untuk meningkatkan kinerja dalam eksekusi skrip.

Apa itu JIT?

Singkatan dari just-in-time , JIT mengkompilasi opcode ke dalam kode mesin tepat sebelum dijalankan untuk output. Untuk memahami apa artinya dan cara kerjanya, kita perlu memahami tahapan eksekusi script PHP, yaitu:

  • Analisis leksikal. Langkah ini adalah di mana Zend Engine, interpreter PHP, menerjemahkan kode menjadi token yang dapat dibaca mesin.
  • Pengurai. Interpreter mem-parsing token untuk menghasilkan Abstract Syntax Tree (AST) – representasi seperti pohon yang menunjukkan cara kerja kode.
  • Kompilasi. Interpreter mengubah node AST menjadi opcode yang merupakan instruksi yang dapat dibaca mesin yang memberi tahu mesin virtual Zend (VM) operasi apa yang harus dilakukan.
  • Eksekusi. Interpreter mengirimkan opcode ke Zend VM, yang akan mengkompilasi opcode menjadi kode mesin untuk dieksekusi.

Proses ini menggunakan sejumlah besar sumber daya server, terutama jika skrip PHP mendapat permintaan berulang.

Itu sebabnya PHP 5.5 memperkenalkan opcache ekstensi , yang menyimpan opcode dari tahap kompilasi.

Ketika server menerima permintaan baru untuk skrip yang sama, interpreter dapat segera menjalankan opcode dari opcache. Dengan begitu, tidak perlu mengulang proses eksekusi dari awal.

PHP 7.4 menambahkan preloading fitur beberapa tahun kemudian agar skrip precompile opcache menjadi opcode saat startup. Hasilnya, interpreter dapat segera mengirimkan opcode untuk dieksekusi ketika server pertama kali menerima permintaan skrip.

Terlepas dari fasilitas ini, ada beberapa kelemahan. Salah satunya adalah menjelang akhir proses, Zend VM masih perlu mengubah opcode menjadi kode mesin sebelum menjalankannya, yang dapat memakan waktu dan sumber daya yang signifikan.

Di situlah kompiler JIT masuk. Ini akan mengkompilasi opcode ke dalam kode mesin selama menjalankan pertama untuk mempersiapkan eksekusi berikutnya.

Ketika ada permintaan untuk skrip yang dikompilasi JIT, PHP akan menjalankannya langsung oleh CPU alih-alih Zend VM, sehingga menghasilkan kinerja yang lebih cepat. Berikut tahapan eksekusi skrip pada PHP 8.0, dibandingkan dengan versi sebelumnya:

Tahap eksekusi skrip PHP 8

Ada dua mesin kompilasi JIT:

  • Fungsi. Pendekatan ini akan mengidentifikasi dan mengkompilasi seluruh fungsi tanpa mencari tahu bagian mana yang sering dipanggil.
  • Pelacakan. Mode ini hanya akan menganalisis dan mengkompilasi bagian-bagian yang paling sering digunakan dalam fungsi untuk menghemat waktu dan memori. Ini adalah mesin default di PHP 8.0.

Apa Arti JIT bagi Saya?

Menurut RFC , mengaktifkan JIT adalah cara paling signifikan untuk meningkatkan kinerja PHP. Dengan demikian, melewatkan fitur ini dapat mengakibatkan hilangnya manfaat utama.

Untungnya, tes terbaru menunjukkan kompiler JIT telah mampu meningkatkan proses eksekusi skrip – terutama jika Anda menggunakan mesin Tracing.

PHP Benchmark sintetis mengungkapkan peningkatan kecepatan tiga kali lebih besar setelah mengaktifkan mode Tracing. Dalam aplikasi yang berjalan lama, Anda dapat mengharapkan peningkatan kinerja hingga dua kali lipat.

Kontribusi JIT untuk kinerja PHP 8

Untuk pengguna dan pengembang WordPress, kompiler JIT juga dapat menambahkan sedikit peningkatan, meskipun mungkin tidak terlalu signifikan.

Anda perlu mengurangi TTFB, mengoptimalkan database, dan menurunkan jumlah permintaan HTTP untuk mendapatkan performa terbaik. Konon, pengembang PHP akan melanjutkan upaya peningkatan dengan menggunakan profiling dan optimasi spekulatif.

Jika Anda ingin mengaktifkan JIT, pastikan ekstensi opcache aktif.

Klien paket hosting bersama dapat melakukannya dengan membuka Akun Hosting dasbor -> Konfigurasi PHP . Pada Ekstensi PHP tab , pastikan untuk mencentang kotak “opcache” .

Layar ekstensi PHP

Fitur Baru di PHP 8.0

Ada banyak fitur menarik selain JIT. Bagian ini akan memberikan gambaran tentang penambahan dan perubahan utama dalam PHP 8.0.

Jenis Serikat 2.0

Dalam banyak kasus, suatu fungsi dapat menggunakan lebih dari satu tipe, tetapi tidak mungkin untuk menentukan ini di versi PHP sebelumnya kecuali Anda mendeklarasikan tipe menggunakan DocComments.

Berikut ini contoh tampilannya:

kelas Nomor {
/**
* @var int|float $number
*/
pribadi $nomor;
/**
* @param int|float $number
*/
publik fungsi setNumber ( $number ) {
$ ini – > angka = $angka;
}
/**
* @return int|mengambang
*/
publik fungsi getNumber () {
kembalikan $ ini – > angka;
}
}

Versi PHP sebelumnya memperkenalkan dua tipe union khusus – Nullable (menggunakan ?Type sintaks ) dan Iterable (untuk array dan Traversable ).

Namun, yang hilang adalah dukungan asli untuk jenis serikat sewenang-wenang, yang merupakan fitur yang disertakan dengan PHP 8.0. Sekarang, Anda cukup menulis tipe yang dapat digunakan fungsi dan memisahkannya menggunakan T1|T2|… sintaks , seperti:

kelas Nomor {
private int|float $angka;
publik fungsi setNumber ( int|float $number ) : void {
$ ini – > angka = $angka;
}
publik fungsi getNumber () : int|float {
kembalikan $ ini – > angka;
}
}

Perhatikan bahwa contoh tidak menyertakan @var , @param , atau @return lagi, membuat kode lebih bersih.

Anda dapat menggunakan tipe gabungan untuk properti, argumen, dan tipe pengembalian – meskipun ada beberapa batasan yang harus diperhatikan. Lihat RFC untuk informasi lebih lanjut.

Argumen bernama

Di versi PHP sebelumnya, meneruskan beberapa argumen ke suatu fungsi akan memerlukan penggunaan posisi urutan di mana parameter dideklarasikan, seperti:

array_fill ( 0 , 100 , 50 ) ;

Satu tantangan dengan ini adalah Anda mungkin tidak mengingat urutan parameter. Selain itu, mungkin sulit untuk memahami apa yang dirujuk oleh masing-masing kode saat Anda meninjau kembali kode tersebut.

Dengan PHP 8.0, Anda memiliki opsi untuk menambahkan nama di sebelah parameter sehingga Anda dapat meneruskannya ke suatu fungsi dengan menggunakan namanya. Inilah yang biasanya terlihat seperti:

// Menggunakan argumen posisi:
array_fill ( 0 , 100 , 50 ) ;
// Menggunakan argumen bernama:
array_fill ( start_index: 0 , num: 100 , nilai: 50 ) ;

Salah satu manfaat dari fitur ini adalah dengan mempelajari apa yang dilakukan setiap parameter akan membuat proses keseluruhan menjadi lebih cepat.

Selain itu, argumen bernama tidak bergantung pada urutan, jadi Anda tidak perlu mengingat posisi urutan setiap parameter dalam deklarasinya. Oleh karena itu, contoh di bawah ini akan memiliki arti yang sama dengan yang di atas:

array_fill ( nilai: 50 , num: 100 , start_index: 0 ) ;

Menggabungkan argumen bernama dan posisi juga dimungkinkan, selama yang disebutkan berada di urutan kedua. Dengan kata lain, kode berikut dapat diterima:

test($foo, param: $bar);

On the other hand, this code will result in an error:

test(param: $bar, $foo);

Terakhir, dengan argumen bernama, Anda hanya perlu menulis parameter yang nilai defaultnya ingin Anda timpa. Jangan ragu untuk melewati yang dengan nilai default yang ingin Anda pertahankan. Berikut adalah contoh yang diberikan dalam RFC :

htmlspecialchars ( $string, default, default, false ) ;
// vs
htmlspecialchars ( $string, double_encode: false ) ;

Sintaks standar untuk argumen bernama adalah paramName: $value . Jangan menulis nama secara dinamis, seperti yang digambarkan di bawah ini karena akan mengakibatkan kesalahan.

// Tidak didukung.
function_name ( $variableStoringParamName: $nilai ) ;

Ekspresi Pertandingan

Ekspresi kecocokan mirip dengan pernyataan sakelar karena tujuannya adalah untuk membandingkan beberapa nilai. Namun, semantik jauh lebih efisien dan kurang rentan terhadap kesalahan.

Consider the following switch statement example from the RFC:

switch ($this–>lexer->lookahead[‘type’]) {
case Lexer::T_SELECT:
$statement = $this–>SelectStatement();
break;
case Lexer::T_UPDATE:
$statement = $this–>UpdateStatement();
break;
case Lexer::T_DELETE:
$statement = $this–>DeleteStatement();
break;
default:
$this–>syntaxError(‘SELECT, UPDATE or DELETE’);
break;
}

Dengan ekspresi kecocokan, pernyataan yang sama akan terlihat jauh lebih pendek:

$pernyataan = cocok ( $ this – > lexer- > lookahead [ ‘type’ ]) {
Lexer::T_SELECT = > $ this – > SelectStatement () ,
Lexer::T_UPDATE = > $ this – > UpdateStatement () ,
Lexer::T_DELETE = > $ this – > DeleteStatement () ,
default = > $ this – > syntaxError ( ‘SELECT, UPDATE or DELETE’ ) ,
} ;

Blok kode di atas menunjukkan bahwa ekspresi kecocokan dapat mengembalikan nilai. Ini tidak seperti pernyataan switch di mana Anda harus menetapkan $result menjelang akhir.

Selain itu, tidak perlu menambahkan istirahat setelah setiap lengan karena telah diterapkan secara implisit.

Selain itu, fitur ini akan melakukan perbandingan ketat “===” daripada yang longgar “==”. Perbandingan longgar, seperti yang dilakukan oleh pernyataan switch, sering kali dapat menghasilkan hasil yang tidak terduga, menciptakan bug dalam kode Anda. Mari kita lihat kode di bawah ini:

beralih ( ‘foo’ ) {
kasus 0 :
$result = “Oh tidak!\n” ;
merusak;
kasus ‘foo’ :
$result = “Ini yang saya harapkan\n” ;
merusak;
}
echo $hasil;
//> Ah tidak!

Ekspresi kecocokan akan memberikan hasil yang lebih tepat:

gema pertandingan ( ‘foo’ ) {
0 = > “Oh tidak!\n” ,
‘foo’ = > “Ini yang saya harapkan\n” ,
} ;
//> Ini yang aku harapkan

Hal penting yang perlu diingat saat menggunakan fitur ini adalah salah satu lengan harus memiliki nilai yang sesuai dengan kondisi. Atau, harus ada yang default dideklarasikan. Jika tidak, itu akan melempar UnhandledMatchError .

Attributes

An attribute is a metadata function that can document what a section of code means. Developers can place it in functions, classes, class constants, class properties, class methods, and function or method parameters.

This feature is similar to DocComments, though there are some differences.

Pertama, fakta bahwa ini asli dari sistem PHP membuatnya dapat dibaca oleh alat seperti penganalisis statis dan penyorot sintaks. Itu sebabnya RFC mengusulkan atribut sebagai bentuk metadata yang lebih terstruktur dan sintaksis.

Untuk menandakan atribut, lampirkan teks di antara dua kurang dari dan lebih besar dari simbol , seperti <<Contoh>> . Anda dapat menambahkannya sebelum deklarasi yang mereka tentukan, seperti:

<< Contoh Atribut >>
kelas Foo
{
<< Contoh Atribut >>
public const FOO = ‘foo’ ;
<< Contoh Atribut >>
publik $x;
<< Contoh Atribut >>
publik fungsi foo (<< ExampleAttribute >> $bar ) { }
}

Selain itu, pengguna dapat menyertakan satu atau beberapa nilai terkait dalam atribut, seperti yang diilustrasikan di bawah ini:

<< Tanpa Argumen >>
<< Argumen Tunggal ( 0 )>>
<< SedikitArgumen ( ‘Halo’ , ‘Dunia’ )>>
fungsi foo () {}

Dimungkinkan juga untuk melampirkan atribut sebelum atau sesudah DocComment.

<< Contoh Atribut >>
/** docblock */
<< Atribut Contoh Lain >>
fungsi foo () {}

Promosi Properti Konstruktor

Fitur ini adalah sintaks singkatan baru yang bertujuan untuk mengurangi jumlah boilerplate saat menggunakan fungsi konstruktor.

Dalam versi PHP sebelumnya, seseorang akan mendefinisikan objek nilai sederhana dengan mengulangi properti – sekali dalam deklarasi properti, sekali dalam parameter konstruktor, dan dua kali dalam penetapan properti. Perhatikan contoh berikut:

kelas Titik {
pelampung publik $x;
pelampung publik $y;
pelampung publik $z;
publik fungsi __konstruksi (
mengapung $x = 0 . 0 ,
mengambang $y = 0 . 0 ,
mengapung $z = 0 . 0 ,
) {
$ ini – > x = $x;
$ ini – > y = $y;
$ ini – > z = $z;
}
}

Dengan PHP 8.0, Anda dapat mendeklarasikan properti sekali dan menggabungkannya dengan tanda tangan konstruktor, menawarkan pengalaman penulisan kode yang lebih efektif.

kelas Titik {
publik fungsi __konstruksi (
float publik $x = 0 . 0 ,
float publik $y = 0 . 0 ,
float publik $z = 0 . 0 ,
) {}
}

Script akan berjalan dengan cara yang sama seperti contoh sebelumnya. Jika parameter diawali dengan penanda visibilitas, PHP akan menerjemahkan sintaks ke versi tradisional dan menjalankannya setelah itu.

The RFC menjelaskan bahwa ada beberapa kendala yang perlu dipertimbangkan dengan promosi properti konstruktor. Salah satunya adalah menghindari penggunaan var kata kunci , karena fitur tersebut sudah mengharuskan properti mempromosikan menggunakan penanda visibilitas.

Kelas Tes {
// Kesalahan: kata kunci “var” tidak didukung.
publik fungsi __construct ( var $prop ) {}
}

Kedua, ketika tipenya null, itu harus dideklarasikan secara eksplisit menggunakan ?Type sintaks nullable.

Kelas Tes {
// Kesalahan: Menggunakan default nol pada properti yang tidak dapat dibatalkan
publik fungsi __construct ( tipe publik $prop = null ) {}
// Benar: Jadikan tipe tersebut secara eksplisit dapat dibatalkan
publik fungsi __construct ( publik ?Type $prop = null ) {}
}

Parameter yang dipromosikan hanya dapat terjadi pada konstruktor non-abstrak. Jadi, contoh berikut akan menghasilkan kesalahan:

// Kesalahan: Bukan konstruktor.
fungsi pengujian ( pribadi $x ) {}
abstrak kelas Tes {
// Kesalahan: Konstruktor abstrak.
publik abstrak fungsi __construct ( private $x ) ;
}

Kelas dapat memiliki properti yang dipromosikan oleh konstruktor dan deklarasi properti eksplisit. Namun, tidak mungkin menggunakan properti yang sama di keduanya, seperti:

Kelas Tes {
publik $ prop;
// Kesalahan: Deklarasi ulang properti.
publik fungsi __construct ( publik $prop ) {}
}

Juga tidak ada parameter variadic yang dipromosikan di konstruktor.

Kelas Tes {
// Kesalahan: Parameter variadik.
publik fungsi __construct ( string publik …$strings ) {}
}

Terakhir, tidak ada dukungan untuk menggunakan tipe yang dapat dipanggil dalam deklarasi properti konstruktor.

Kelas Tes {
// Kesalahan: Jenis yang dapat dipanggil tidak didukung untuk properti.
publik fungsi __construct ( dapat dipanggil publik $callback ) {}
}

Operator Nullsafe

Memeriksa nol menggunakan pernyataan bersyarat biasanya menghasilkan kode yang sangat bersarang dan sulit dibaca. Perhatikan contoh di bawah ini:

$negara = nol ;
if ( $session !== null ) {
$pengguna = $sesi- > pengguna;
if ( $pengguna !== null ) {
$alamat = $pengguna- > getAddress () ;
if ( $alamat !== null ) {
$negara = $alamat- > negara;
}
}
}
// lakukan sesuatu dengan $negara

Untuk mengatasi masalah ini, PHP 8.0 menghadirkan operator nullsafe . Dengan fitur ini, Anda dapat menulis kode dari contoh di atas dengan menggunakan ?-> sintaks .

$negara = $session?- > pengguna?- > getAddress () ?- > negara;
// lakukan sesuatu dengan $negara

Menurut RFC , PHP akan memeriksa apakah operator pertama $session menghasilkan null. Jika tidak, eksekusi akan berlanjut hingga operator terakhir. PHP akan menghentikan proses eksekusi ketika salah satu operator mengevaluasi null.

Salah satu batasan dengan menggunakan operator nullsafe adalah tidak dapat ada dalam konteks penulisan. Akibatnya, berikut ini akan membuat kesalahan:

foreach ([ 1 , 2 , 3 ] sebagai $foo?- > bar- > baz ) {}
// Tidak dapat menggunakan operator nullsafe dalam konteks penulisan

Selain itu, mengambil referensi dari rantai nullsafe tidak diperbolehkan.

// 1
$x = &$foo?- > bar;
// Kesalahan kompiler: Tidak dapat mengambil referensi dari rantai nullsafe
// 2
take_ref ( $foo?- > bar ) ;
// Kesalahan: Tidak dapat melewati parameter 1 dengan referensi
// 3
fungsi & return_by_ref ( $foo ) {
kembali $foo?- > bar;
// Kesalahan kompiler: Tidak dapat mengambil referensi dari rantai nullsafe
}

Peta Lemah

Dengan PHP 7.4, pengembang dapat membuat referensi lemah ke objek kunci sehingga, tidak seperti relasi kuat, mereka tidak meningkatkan penghitung referensi objek dan mencegah penghapusan objek saat tidak digunakan lagi.

Peta yang lemah adalah peningkatan fitur itu. Ini menyimpan nilai arbitrer yang digunakan sebagai referensi lemah ke suatu objek. Dengan begitu, ketika objek berada di luar cakupan atau tidak disetel, PHP dapat menghapus nilai terkait apa pun di peta yang lemah.

Contoh di bawah ini, bersumber dari RFC , yang menunjukkan bagaimana peta yang lemah akan terlihat seperti:

$ peta = baru WeakMap;
$obj = kelas baru std ;
$peta [ $obj ] = 42 ;
var_dump ( $peta ) ;
// objek(Peta Lemah)#1 (1) {
// [0]=>
// larik(2) {
// [“kunci”]=>
// objek(Kelas std)#2 (0) {
// }
// [“nilai”]=>
// int(42)
// }
// }
// Objek dihancurkan di sini, dan kuncinya secara otomatis dihapus dari peta yang lemah.
tidak disetel ( $obj ) ;
var_dump ( $peta ) ;
// objek(Peta Lemah)#1 (0) {
// }

Fitur ini akan lebih bermanfaat untuk aplikasi yang berjalan lama, terutama jika Anda ingin mencegah kebocoran memori dan menerapkan caching.

Fitur Baru Kecil

Berikut adalah beberapa fitur tambahan kecil yang dapat Anda harapkan dari PHP 8.0:

  • Tanda koma di daftar parameter. Anda dapat membuat daftar parameter dalam format vertikal alih-alih standar, horizontal.
  • str_berisi(). Fungsi ini akan memeriksa apakah sebuah string dimasukkan sebagai elemen dari string lain. Ini akan mengembalikan nilai boolean tergantung pada apakah kondisinya benar atau salah. Anda dapat menganggapnya sebagai alternatif yang lebih mudah dibaca untuk str_pos() .
  • str_starts_with(). Ini akan memeriksa apakah string dimulai dengan substring yang ditentukan.
  • str_ends_with(). Ini akan menentukan apakah string berakhir dengan substring yang diberikan.
  • Antarmuka yang dapat dirangkai. Kelas yang menggunakan metode __toString() sekarang akan mengimplementasikan antarmuka Stringable secara otomatis. Tujuannya adalah untuk mengizinkan string|Stringable union type, yang berarti PHP dapat menerima string atau objek menggunakan metode __toString() .
  • fdiv(). PHP 8.0 menerima pembagian dengan nol dan akan mengembalikan INF, -INF, atau NAN sebagai ganti kesalahan.
  • get_debug_type(). Fungsi ini bekerja mirip dengan gettype() , meskipun akan mengembalikan nama tipe asli dan nama kelas. The tabel referensi di bawah ini menunjukkan bagaimana keduanya berbeda.
Tabel referensi PHP 8
  • get_resource_id(). Fungsi ini adalah alternatif tipe-safe untuk (int) $resource. Ini akan mengambil ID dari sumber daya eksternal, seperti koneksi database.
  • PhpToken::tokenize(). Metode ini akan menggantikan fungsi token_get_all() . Alih-alih mengembalikan string atau array nilai, itu akan mengembalikan array objek. Kode yang dihasilkan akan lebih mudah dibaca dan hemat memori.
  • Standar Hidup DOM baru di ext/dom. Antarmuka baru dan properti publik untuk beradaptasi dengan API DOM saat ini, yang telah menjadi kebutuhan saat menangani dokumen XML dan HTML.

Fitur Usang di PHP 8.0

PHP 8.0 akan menghentikan fitur berikut:

  • Menyertakan nilai default dalam parameter diikuti dengan parameter yang diperlukan, karena nilai default tidak berpengaruh
  • Menggunakan get_defined_functions() dengan exception_disabled secara eksplisit disetel ke false
  • enchant_broker_set_dict_path() fungsi
  • enchant_broker_get_dict_path() fungsi
  • enchant_dict_add_to_personal() fungsi
  • enchant_dict_is_in_session() fungsi
  • enchant_broker_free() fungsi
  • enchant_broker_free_dict() fungsi
  • ENCHANT_MYSPELL konstan
  • ENCHANT_ISPELL konstan
  • libxml_disable_entity_loader() fungsi
  • The PGSQL_LIBPQ_VERSION_STR konstan, bersama dengan beberapa fungsi alias di pgsql ekstensi
  • Menggunakan fungsi perbandingan sortir yang mengembalikan true atau false
  • Menggunakan file kosong sebagai ZipArchive
  • API prosedural Zip
  • ReflectionFunction::isDisabled() fungsi
  • ReflectionParameter::getClass() fungsi
  • ReflectionParameter::isArray() fungsi
  • ReflectionParameter::isCallable() fungsi

Lihat ini sumber daya untuk informasi selengkapnya tentang fitur yang tidak digunakan lagi.

Perubahan Tidak Kompatibel ke Belakang untuk PHP 8.0

Migrasi ke PHP 8.0 membawa banyak perubahan yang tidak kompatibel dengan versi PHP yang lebih lama. Beberapa di antaranya adalah:

  • Perbandingan string ke angka. Membandingkan angka dengan string non-numerik sekarang akan kembali sebagai salah. Lihat tabel referensi di bawah ini:
Tabel perbandingan string PHP 8
  • Tidak ada spasi dalam nama dengan spasi nama. Misalnya, nama seperti “Foo \ bar” tidak akan diterima. Gunakan “Foo\bar” sebagai gantinya.
  • Sumber daya untuk migrasi objek. Beberapa fungsi sekarang akan mengembalikan objek alih-alih sumber daya.
  • Penghapusan bendera FILTER_FLAG_SCHEME_REQUIRED dan FILTER_FLAG_HOST_REQUIRED . Ini karena FILTER_VALIDATE_URL sudah menggunakan tanda ini secara default saat digabungkan dengan fungsi filter_var() .
  • E_ALL sekarang menjadi level error_reporting default. PHP 8.0 akan menyertakan pemberitahuan dan perubahan yang tidak digunakan lagi dalam pesan kesalahan.

Pastikan untuk membaca dokumentasi resmi untuk melihat perubahan lain yang tidak kompatibel.

Perubahan PHP 8.0 Lainnya

Perubahan di bawah ini tidak akan mengakibatkan ketidakcocokan ke belakang, tetapi tetap penting untuk diperhatikan. Beberapa di antaranya adalah:

  • Anda dapat memfilter hasil dari ReflectionClass::getConstants() dan ReflectionClass::getReflectionConstants() menggunakan baru filter parameter .
  • Metode ZipArchive::addGlob() dan ZipArchive::addPattern() sekarang menerima flags , comp_method , comp_flags , env_method , dan enc_password dalam opsi larik .
  • Ada baru flags argumen untuk metode ZipArchive::addEmptyDir() , ZipArchive::addFile() dan ZipArchive::addFromString() .
  • Karena peran pentingnya dalam PHP, JSON ekstensi sekarang diaktifkan secara default.
  • Fungsi array_slice() tidak perlu menemukan posisi awal jika array tidak memiliki celah.

ini Sumber daya dapat memberikan informasi lebih lanjut tentang perubahan.

WordPress dan PHP 8.0

WordPress 5.6 dan ke atas kompatibel dengan PHP 8.0. Tim pengembang telah menghapus banyak fitur usang untuk mencapai hal ini.

Namun, mereka tidak dapat mengklaim kompatibilitas penuh karena banyak plugin dan tema mungkin belum mendukung PHP 8.0. Jika Anda ingin beralih ke PHP 8.0, pastikan Anda dapat melakukan transisi tanpa masalah. Jika tidak, jika Anda bekerja dengan pengembang web profesional, minta dia untuk membantu transisi Anda.

Jika Anda seorang pengembang plugin atau tema, WordPress mendorong untuk mengadaptasi kode produk Anda ke versi PHP yang baru. Dengan begitu, pengguna plugin atau tema tidak akan mengalami perubahan yang mengganggu di situs web mereka jika mereka memperbarui perangkat lunak.

Artikel ini telah menguraikan perubahan besar yang mungkin berlaku untuk pengembang WordPress. Karena itu, kami sarankan untuk membaca ini pengumuman WordPress untuk melihat mana yang harus Anda perhatikan secara khusus.

Ingatlah bahwa Anda selalu dapat menurunkan versi Anda jadi PHP 7.4 jika ada terlalu banyak masalah yang harus diselesaikan.

Kesimpulan

PHP 8.0 memiliki beberapa perubahan dan peningkatan yang menarik untuk pengembang PHP. Dari kompiler JIT, promosi properti konstruktor, hingga peta yang lemah, diharapkan untuk melihat peningkatan kinerja situs web dan pengalaman penulisan kode.

Pastikan untuk memeriksa RFC dan dokumentasi sehingga proyek Anda dapat sepenuhnya kompatibel dengan versi PHP terbaru. Semoga beruntung!

Tinggalkan Balasan