Bereaksi Profil Kinerja Aplikasi

Hari ini kita akan berbicara tentang mengukur kinerja rendering komponen Bereaksi menggunakan React Profiler API. Kami juga akan mengevaluasi interaksi dengan komponen menggunakan API Pelacakan Interaksi eksperimental baru. Selain itu, kami akan menggunakan API Pengaturan Waktu Pengguna untuk melakukan pengukuran kami sendiri.

Kami akan menggunakan aplikasi Antrean Film React sebagai platform untuk eksperimen.


Bereaksi Aplikasi Antrean Film

Bereaksi Profiler API


React Profiler API dirancang untuk mengukur kinerja render dan membantu mengidentifikasi hambatan kinerja aplikasi.

import React, { Fragment, unstable_Profiler as Profiler} from "react";

Komponen Profilermenerima panggilan balik onRendersebagai properti. Itu disebut setiap kali komponen di pohon diprofilkan melakukan pembaruan.

const Movies = ({ movies, addToQueue }) => (
  <Fragment>
    <Profiler id="Movies" onRender={callback}>

Mari, untuk tujuan pengujian, coba mengukur waktu yang diperlukan untuk membuat bagian-bagian suatu komponen Movies. Ini tampilannya.


Aplikasi React Movies Queue dan riset Film menggunakan

alat callback pengembang ReactonRender menerima parameter yang menjelaskan apa yang sedang dirender dan waktu yang diperlukan untuk merender. Ini termasuk yang berikut:

  • id: Properti iddari pohon komponen Profilertempat perubahan dilakukan.
  • phase: atau mount(jika pohon itu dipasang), atau update(jika pohon itu dirender ulang).
  • actualDuration: Waktu yang diperlukan untuk membuat pembaruan tetap.
  • baseDuration: Diperkirakan waktu untuk membuat seluruh subtree tanpa caching.
  • startTime: Waktu Bereaksi mulai merender pembaruan ini.
  • commitTime: waktu ketika React melakukan pembaruan ini.
  • interactions: Banyak "interaksi" untuk pembaruan ini.

const callback = (id, phase, actualTime, baseTime, startTime, commitTime) => {
    console.log(`${id}'s ${phase} phase:`);
    console.log(`Actual time: ${actualTime}`);
    console.log(`Base time: ${baseTime}`);
    console.log(`Start time: ${startTime}`);
    console.log(`Commit time: ${commitTime}`);
}

Kami akan memuat halaman dan pergi ke konsol Alat Pengembang Chrome. Di sana kita harus melihat yang berikut ini.


Membuat profil hasil di alat pengembang

Kami, di samping itu, dapat membuka alat Bereaksi pengembang, pergi ke bookmarkProfilerdan memvisualisasikan informasi tentang waktu rendering komponen. Di bawah ini adalah visualisasi kali ini dalam bentuk grafik nyala.


Bekerja dengan memprofilkan hasil dalam React Developer Tools

Saya juga suka menggunakan mode tampilan di siniRanked, yang menyediakan tampilan data yang terurut. Akibatnya, komponen yang paling banyak membuat waktu untuk membuat berada di bagian atas daftar.


Melihat hasil profil dalam mode Peringkat.

Selain itu, Anda dapat menggunakan beberapa komponen untuk melakukan pengukuran di berbagai bagian aplikasiProfiler:

import React, { Fragment, unstable_Profiler as Profiler} from "react";

render(
  <App>
    <Profiler id="Header" onRender={callback}>
      <Header {...props} />
    </Profiler>
    <Profiler id="Movies" onRender={callback}>
      <Movies {...props} />
    </Profiler>
  </App>
);

Dan bagaimana cara menganalisis interaksi pengguna dengan komponen?

API Pelacakan Interaksi


Alangkah baiknya untuk dapat melacak interaksi pengguna dengan antarmuka aplikasi (seperti klik pada item). Ini akan memungkinkan Anda menemukan jawaban untuk pertanyaan menarik seperti ini: "Berapa lama untuk memperbarui DOM setelah mengklik tombol ini?". Untungnya, React memiliki dukungan eksperimental untuk menganalisis interaksi pengguna dengan aplikasi menggunakan Interaction Tracing API dari paket scheduler baru . Anda dapat membaca dokumentasi di sini .

Informasi tentang interaksi pengguna dan aplikasi disediakan dengan deskripsi (misalnya, "Pengguna mengklik tombol Tambahkan ke Keranjang") dan stempel waktu. Selain itu, ketika menyiapkan analisis interaksi, panggilan balik digunakan di mana tindakan yang terkait dengan satu atau interaksi lain dilakukan.

Dalam aplikasi kami ada tombol Add Movie To Queuedi mana ikon ditampilkan +. Ini berfungsi untuk menambahkan film ke antrian menonton.


Tombol untuk menambahkan film ke antrian tontonan

Berikut adalah contoh kode yang memantau pembaruan status untuk interaksi pengguna ini dengan aplikasi:

import { unstable_Profiler as Profiler } from "react";
import { render } from "react-dom";
import { unstable_trace as trace } from "scheduler/tracing";

class MyComponent extends Component {
  addMovieButtonClick = event => {
    trace("Add To Movies Queue click", performance.now(), () => {
      this.setState({ itemAddedToQueue: true });
    });
  };
}

Kami dapat merekam informasi tentang interaksi ini dan mempelajari durasinya dengan menghubungi alat Bereaksi pengembang.


Analisis interaksi pengguna dengan elemen aplikasi

Menggunakan API Pelacakan Interaksi, Anda juga dapat mengumpulkan informasi tentang rendering komponen pertama:

import { unstable_trace as trace } from "scheduler/tracing";

trace("initial render", performance.now(), () => {
   ReactDom.render(<App />, document.getElementById("app"));
});



Analisis rendering pertama komponen

. Penulis API memberikan contoh lainpenggunaannya. Misalnya, menggambarkan profil tugas asinkron.

Dalang


Untuk otomatisasi pengujian interaksi pengguna dengan elemen aplikasi, penggunaan Puppeteer mungkin tampak menarik . Ini adalah perpustakaan Node.js yang menyediakan akses ke API tingkat tinggi yang dirancang untuk mengontrol browser Chrome tanpa antarmuka pengguna menggunakan protokol DevTools.

Saat menggunakan Puppeteer, pengembang disediakan dengan metode pembantu tracing.start()dan tracing.stop()dirancang untuk mengumpulkan indikator kinerja DevTools. Di bawah ini adalah contoh penggunaan mekanisme ini untuk mengumpulkan data tentang apa yang terjadi ketika Anda mengklik tombol yang menarik bagi kami.

const puppeteer = require('puppeteer');

(async () => {
  const browser = await puppeteer.launch();
  const page = await browser.newPage();
  const navigationPromise = page.waitForNavigation();
  await page.goto('https://react-movies-queue.glitch.me/')
  await page.setViewport({ width: 1276, height: 689 });
  await navigationPromise;

  const addMovieToQueueBtn = 'li:nth-child(3) > .card > .card__info > div > .button';
  await page.waitForSelector(addMovieToQueueBtn);

  //  ...
  await page.tracing.start({ path: 'profile.json' });
  //   
  await page.click(addMovieToQueueBtn);
  //  
  await page.tracing.stop();

  await browser.close();
})()

Sekarang, setelah memuat file profile.jsonke Performancebilah alat pengembang, kita dapat melihat pemanggilan fungsi apa yang dipicu dengan mengklik tombol.


Analisis konsekuensi mengklik tombol

Jika Anda tertarik pada topik analisis kinerja komponen - lihatmateri ini .

API Pengaturan Waktu Pengguna


User Timing API memungkinkan pengembang untuk membuat metrik kinerja khusus menggunakan perangko waktu yang sangat akurat. Metode ini window.performance.mark()membuat timestamp tempat nama tersebut ditetapkan. Metode ini window.performance.measure()memungkinkan Anda untuk mengetahui waktu yang telah berlalu antara dua pengukuran.

//     
performance.mark('Movies:updateStart');
//  

//     
performance.mark('Movies:updateEnd');

//        
performance.measure('moviesRender', 'Movies:updateStart', 'Movies:updateEnd');

Saat membuat profil aplikasi Bereaksi menggunakan tab PerformanceAlat Pengembang Chrome, Anda dapat menemukan bagian yang Timingdiisi dengan metrik sementara mengenai komponen Bereaksi. Bereaksi, saat merender, dapat mempublikasikan informasi ini menggunakan API Pengaturan Waktu Pengguna.


Tab kinerja alat pengembang Chrome.

Perhatikan bahwa Timing API Pengguna dihapus dari majelis DEV Bereaksi, menggantikannya dengan React Profiler API, yang menyediakan cap waktu yang lebih akurat. Mungkin di masa depan dukungan untuk API ini akan dikembalikan dengan melakukannya untuk browser yang mendukung spesifikasi Tingkat Waktu Pengguna 3. 

Di Internet, Anda dapat menemukan Bereaksi situs yang menggunakan API Pengaturan Waktu Pengguna untuk menentukan metrik mereka sendiri. Ini termasuk, misalnya,Time to first post title visiblemetrikRedditdan metrik SpotifyTime to playback ready.


Metrik khusus yang digunakan di Situs Bereaksi

Metrik yang dibuat oleh API Timing Pengguna ditampilkan dengan mudahdi panel Mercusuar alat pengembang Chrome.


Metrik di panel Mercusuar

Misalnya, versi terbaru Next.js mencakup metrik khusus dan mekanisme untuk mengukur berbagai peristiwa. Termasuk yang berikut ini:

  • Next.js-hydration: waktu yang diperlukan untuk membawa markup yang telah ditentukan ke kondisi kerja.
  • Next.js-nav-to-render: Waktu dari mulai navigasi hingga awal rendering.

Semua pengukuran ini ditampilkan di area tersebut Timings.


Analisis Metrik Next.js

Alat Pengembang dan Mercusuar


Saya mengingatkan Anda bahwa Lighthouse dan PerformanceToolbar Pengembang Chrome dapat digunakan untuk menganalisis secara mendalam proses pemuatan dan kinerja aplikasi Bereaksi. Di sini Anda dapat menemukan metrik yang secara khusus memengaruhi persepsi halaman oleh pengguna.


Menganalisis Kinerja Halaman

Mereka yang bekerja dengan React mungkin menyukai fakta bahwa mereka akan memiliki metrik baru yang tersedia - seperti metrik Total Blocking Time (TBT), yang memberikan informasi tentang berapa lama halaman dalam mode non-interaktif hingga andal dapat bekerja dalam mode interaktif ( Waktu ke Interaktif ). Berikut adalah indikator TBT ("sebelum" dan "setelah") untuk aplikasi yang menggunakan mode kompetitif eksperimental, yang penggunaannya membantu aplikasi untuk beradaptasi dengan spesifik lingkungan di mana ia menjalankannya.


Ubah TBT

Alat-alat ini berguna dalam menganalisis hambatan kinerja aplikasi, seperti tugas yang membutuhkan waktu lama untuk diselesaikan, menunda transisi online aplikasi. Misalnya, ini mungkin terkait dengan analisis kecepatan reaksi aplikasi terhadap penekanan tombol.


Analisis aplikasi

Mercusuar, di samping itu, memberi pengembang Bereaksi banyak tips khusus tentang banyak masalah. Di bawah ini adalah hasil analisis di Lighthouse 6.0 . Di sini, bagian Hapus JavaScript yang tidak digunakan dibuka, yang melaporkan kode JavaScript yang tidak digunakan yang dimuat ke dalam aplikasi, yang dapat diimpor menggunakanReact.lazy().


Menganalisis aplikasi di

Aplikasi Mercusuar selalu berguna untuk menguji pada perangkat keras, yang kemungkinan besar tersedia untuk pengguna akhir. Saya sering mengandalkan data Webpagetest dan RUM dan CrUX dalam hal-hal seperti itu, yang memungkinkan saya untuk mendapatkan informasi yang lebih lengkap tentang kinerja aplikasi.

Pembaca yang budiman! Bagaimana Anda meneliti kinerja aplikasi Bereaksi Anda?


All Articles