Sebagai pembangun, saya mendapati bahawa mengoptimumkan prestasi JavaScript adalah penting untuk mencipta aplikasi web yang responsif dan cekap. Selama bertahun-tahun, saya telah meneroka pelbagai teknik untuk membuat profil dan meningkatkan prestasi kod saya. Berikut ialah tujuh kaedah berkuasa yang telah saya gunakan dengan jayanya:
Alat Pembangun Penyemak Imbas ialah sumber yang tidak ternilai untuk pemprofilan prestasi. Saya kerap menggunakan Chrome DevTools untuk menganalisis aplikasi web saya. Panel Prestasi menyediakan banyak maklumat tentang masa muat, penggunaan CPU dan penggunaan memori. Untuk memulakan pemprofilan, saya membuka DevTools, navigasi ke tab Prestasi dan klik butang rekod. Selepas berinteraksi dengan aplikasi saya, saya menghentikan rakaman dan memeriksa hasilnya.
Carta nyala dalam panel Prestasi amat berguna. Ia menunjukkan kepada saya fungsi mana yang paling banyak mengambil masa untuk dilaksanakan. Saya boleh mengezum masuk pada kawasan tertentu carta untuk melihat pecahan terperinci bagi panggilan fungsi dan tempohnya. Ini membantu saya mengenal pasti kesesakan dalam kod saya yang mungkin tidak saya perasan sebaliknya.
Ciri lain yang saya rasa berguna ialah panel Rangkaian. Ia membolehkan saya melihat berapa lama setiap sumber diambil untuk dimuatkan, yang penting untuk mengoptimumkan masa muat halaman awal. Saya boleh mensimulasikan keadaan rangkaian yang berbeza untuk memastikan aplikasi saya berfungsi dengan baik walaupun pada sambungan yang lebih perlahan.
Lighthouse ialah satu lagi alat berkuasa yang disepadukan ke dalam Chrome DevTools. Ia menyediakan audit automatik untuk prestasi, kebolehaksesan, apl web progresif dan banyak lagi. Saya sering menjalankan audit Lighthouse pada aplikasi web saya untuk mendapatkan gambaran keseluruhan yang menyeluruh tentang prestasinya.
Untuk menggunakan Rumah Api, saya membuka DevTools, pergi ke tab Rumah Api, pilih kategori yang ingin saya audit dan klik "Jana laporan." Laporan yang dihasilkan memberikan markah untuk pelbagai aspek aplikasi saya dan menawarkan cadangan khusus untuk penambahbaikan.
Salah satu ciri Rumah Api yang paling berharga ialah keupayaannya untuk mensimulasikan peranti mudah alih dan sambungan rangkaian yang lebih perlahan. Ini membantu saya memastikan aplikasi saya berfungsi dengan baik merentas pelbagai peranti dan keadaan rangkaian.
API Garis Masa Prestasi ialah alat yang berkuasa untuk memperalatkan kod dan mengukur operasi tertentu. Saya menggunakannya untuk membuat entri prestasi tersuai yang membantu saya menjejaki masa pelaksanaan bahagian kritikal aplikasi saya.
Berikut ialah contoh cara saya boleh menggunakan API Garis Masa Prestasi:
performance.mark('startFunction');
// Complex function or operation
complexOperation();
performance.mark('endFunction');
performance.measure('functionDuration', 'startFunction', 'endFunction');
const measures = performance.getEntriesByType('measure');
console.log(measures[0].duration);
Kod ini mencipta tanda pada permulaan dan penghujung operasi yang kompleks, mengukur masa antara tanda ini dan mencatatkan tempoh. Ia merupakan cara yang mudah tetapi berkesan untuk menjejak prestasi bahagian tertentu kod saya.
API Pemasa Pengguna berkait rapat dengan API Garis Masa Prestasi dan menyediakan cara untuk menambah data pemasaan tersuai pada garis masa prestasi penyemak imbas. Saya mendapati ia amat berguna untuk mengukur tempoh fungsi atau proses kritikal dalam aplikasi saya.
Berikut ialah contoh cara saya menggunakan API Masa Pengguna:
performance.mark('startFunction');
// Complex function or operation
complexOperation();
performance.mark('endFunction');
performance.measure('functionDuration', 'startFunction', 'endFunction');
const measures = performance.getEntriesByType('measure');
console.log(measures[0].duration);
Kod ini menandakan permulaan dan tamat proses, mengukur masa antara tanda ini dan mencatatkan tempohnya. Ini cara yang bagus untuk mendapatkan maklumat masa yang tepat untuk bahagian tertentu aplikasi saya.
Chrome Tracing ialah alat yang lebih maju yang membolehkan saya menangkap data prestasi terperinci untuk analisis mendalam tentang pelaksanaan dan pemaparan JavaScript. Walaupun ia lebih kompleks untuk digunakan berbanding alat pembangun terbina dalam penyemak imbas, ia memberikan tahap perincian yang belum pernah berlaku sebelum ini tentang perkara yang berlaku dalam penyemak imbas.
Untuk menggunakan Pengesanan Chrome, saya biasanya mengikut langkah berikut:
Fail jejak yang terhasil menunjukkan kepada saya apa yang dilakukan oleh penyemak imbas pada setiap milisaat, termasuk pelaksanaan JavaScript, pengiraan reka letak, lukisan dan banyak lagi. Tahap perincian ini tidak ternilai apabila saya cuba mengoptimumkan bahagian aplikasi saya yang kompleks atau kritikal prestasi.
Syot Kilat Memori ialah satu lagi ciri hebat Chrome DevTools yang saya gunakan untuk mengenal pasti kebocoran memori dan menganalisis corak pengekalan objek. Kebocoran memori boleh menyebabkan masalah prestasi yang ketara dari semasa ke semasa, jadi adalah penting untuk mengenal pasti dan membetulkannya.
Untuk mengambil gambar memori, saya ikuti langkah berikut:
Berikut ialah contoh mudah kod yang mungkin menyebabkan kebocoran memori:
performance.mark('startProcess');
// Complex process
for (let i = 0; i < 1000000; i++) {
// Some complex operation
}
performance.mark('endProcess');
performance.measure('processTime', 'startProcess', 'endProcess');
const measurements = performance.getEntriesByName('processTime');
console.log(`Process took ${measurements[0].duration} milliseconds`);
Dalam kes ini, largeArray disimpan dalam ingatan walaupun selepas createLeak telah selesai melaksanakan kerana leak.someMethod mengekalkan rujukan kepadanya. Gambar memori akan membantu saya mengenal pasti isu ini.
Carta Api ialah alat visualisasi yang saya dapati amat berguna untuk memahami aliran pelaksanaan kod JavaScript saya. Mereka menunjukkan kepada saya timbunan panggilan dari semasa ke semasa, menjadikannya mudah untuk melihat fungsi mana yang paling banyak mengambil masa untuk dilaksanakan.
Chrome DevTools menjana carta nyala secara automatik apabila anda merakam prestasi. Paksi-x mewakili masa, dan paksi-y menunjukkan timbunan panggilan. Setiap bar dalam carta mewakili panggilan fungsi, dengan lebar bar menunjukkan tempoh masa yang diambil untuk melaksanakan fungsi.
Saya sering menggunakan carta api untuk mengenal pasti fungsi yang kerap dipanggil atau mengambil masa yang lama untuk dilaksanakan. Ini membantu saya menumpukan usaha pengoptimuman saya pada bahagian kod saya yang akan memberi kesan terbesar pada prestasi keseluruhan.
Apabila mengoptimumkan prestasi JavaScript, adalah penting untuk diingat bahawa pengoptimuman pramatang boleh membawa kepada kod yang lebih kompleks dan sukar untuk diselenggara. Saya sentiasa bermula dengan menulis kod yang bersih dan boleh dibaca dan kemudian menggunakan teknik pemprofilan ini untuk mengenal pasti kesesakan sebenar.
Satu teknik yang saya dapati amat berkesan ialah pemuatan malas. Ini melibatkan penangguhan pemuatan sumber tidak kritikal sehingga ia diperlukan. Berikut ialah contoh mudah:
performance.mark('startFunction');
// Complex function or operation
complexOperation();
performance.mark('endFunction');
performance.measure('functionDuration', 'startFunction', 'endFunction');
const measures = performance.getEntriesByType('measure');
console.log(measures[0].duration);
Kod ini menggunakan Intersection Observer API untuk memuatkan imej hanya apabila ia kelihatan, dengan ketara mengurangkan masa pemuatan halaman awal untuk halaman dengan banyak imej.
Teknik lain yang sering saya gunakan ialah debouncing. Ini amat berguna untuk fungsi yang sering dipanggil, seperti pengendali acara untuk menatal atau mengubah saiz. Berikut ialah contoh:
performance.mark('startProcess');
// Complex process
for (let i = 0; i < 1000000; i++) {
// Some complex operation
}
performance.mark('endProcess');
performance.measure('processTime', 'startProcess', 'endProcess');
const measurements = performance.getEntriesByName('processTime');
console.log(`Process took ${measurements[0].duration} milliseconds`);
Fungsi nyahlantun ini memastikan bahawa pengendali ubah saiz hanya berjalan sebaik sahaja pengguna menghentikan saiz semula tetingkap selama 250 milisaat, mengurangkan bilangan kali fungsi dipanggil.
Dalam hal mengoptimumkan gelung, saya mendapati bahawa menggunakan kaedah tatasusunan seperti peta, penapis dan pengurangan selalunya boleh membawa kepada kod yang lebih mudah dibaca dan kadangkala lebih berprestasi daripada tradisional untuk gelung. Berikut ialah contoh:
let leak = null;
function createLeak() {
const largeArray = new Array(1000000).fill('leaky');
leak = {
someMethod: () => {
console.log(largeArray.length);
}
};
}
createLeak();
Satu lagi aspek penting prestasi JavaScript ialah mengurus operasi tak segerak dengan berkesan. Janji dan sintaks async/menunggu boleh membantu menjadikan kod tak segerak lebih mudah dibaca dan lebih mudah untuk difikirkan. Berikut ialah contoh:
function lazyLoad(element) {
if ('IntersectionObserver' in window) {
let observer = new IntersectionObserver((entries, observer) => {
entries.forEach(entry => {
if (entry.isIntersecting) {
let img = entry.target;
img.src = img.dataset.src;
observer.unobserve(img);
}
});
});
observer.observe(element);
} else {
// Fallback for browsers that don't support IntersectionObserver
element.src = element.dataset.src;
}
}
// Usage
document.querySelectorAll('img[data-src]').forEach(lazyLoad);
Fungsi async ini menggunakan try/catch untuk pengendalian ralat dan menunggu keputusan operasi tak segerak, menjadikan kod lebih mudah dibaca dan diselenggara berbanding dengan panggilan balik bersarang.
Mengenai manipulasi DOM, saya mendapati bahawa meminimumkan manipulasi langsung dan perubahan kumpulan boleh meningkatkan prestasi dengan ketara. Penggunaan serpihan dokumen boleh menjadi sangat berkesan:
function debounce(func, delay) {
let timeoutId;
return function (...args) {
clearTimeout(timeoutId);
timeoutId = setTimeout(() => func.apply(this, args), delay);
};
}
// Usage
window.addEventListener('resize', debounce(() => {
console.log('Window resized');
}, 250));
Pendekatan ini meminimumkan bilangan kali DOM dikemas kini, yang boleh menjadi peningkatan prestasi yang ketara untuk sejumlah besar elemen.
Kesimpulannya, pemprofilan dan pengoptimuman prestasi JavaScript ialah proses yang berterusan. Memandangkan aplikasi web menjadi lebih kompleks, adalah penting untuk sentiasa menilai dan meningkatkan prestasi. Teknik yang saya bincangkan di sini - daripada menggunakan alat pembangun penyemak imbas dan Rumah Api kepada melaksanakan pemuatan malas dan manipulasi DOM yang cekap - sangat berharga dalam kerja saya. Dengan menggunakan kaedah ini dan mempelajari secara berterusan tentang teknik pengoptimuman prestasi baharu, kami boleh mencipta aplikasi web yang lebih pantas dan cekap yang memberikan pengalaman pengguna yang lebih baik.
101 Buku ialah syarikat penerbitan dipacu AI yang diasaskan bersama oleh pengarang Aarav Joshi. Dengan memanfaatkan teknologi AI termaju, kami memastikan kos penerbitan kami sangat rendah—sesetengah buku berharga serendah $4—menjadikan pengetahuan berkualiti boleh diakses oleh semua orang.
Lihat buku kami Kod Bersih Golang tersedia di Amazon.
Nantikan kemas kini dan berita menarik. Apabila membeli-belah untuk buku, cari Aarav Joshi untuk mencari lebih banyak tajuk kami. Gunakan pautan yang disediakan untuk menikmati diskaun istimewa!
Pastikan anda melihat ciptaan kami:
Pusat Pelabur | Pelabur Central Spanish | Pelabur Jerman Tengah | Hidup Pintar | Epos & Gema | Misteri Membingungkan | Hindutva | Pembangunan Elit | Sekolah JS
Tech Koala Insights | Dunia Epok & Gema | Medium Pusat Pelabur | Medium Misteri Membingungkan | Sains & Zaman Sederhana | Hindutva Moden
Atas ialah kandungan terperinci Teknik Pengoptimuman Prestasi JavaScript yang luar biasa untuk Pembangun. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
