Əsas məzmuna keç
FrontDepth, Ana səhifə

React və virtual DOM → Signal-lar və fine-grained reactivity

2013 – bu gün · 2021 – bu gün

Köhnə dövr
Yeni dövr
Müqayisə et

Nə dəyişdi

State harada yaşayır

React və virtual DOM

Ən yuxarıdakı App class-ının this.state-ində: todo-lar, filtr və yazılan mətn, yalnız this.setState ilə dəyişir.

Signal-lar və fine-grained reactivity

Signal-larda: siyahı və filtr signal-dır, hər todo-nun done-u isə ayrıca signal-dır. left və hər sətrin shown-u computed-dur.

Səhifə necə render olunur

React və virtual DOM

render() hər dəyişiklikdə bütün UI-ı React elementləri kimi qaytarır; React onları əvvəlkilərlə müqayisə edir və DOM-da yalnız fərqli olanı düzəldir.

Signal-lar və fine-grained reactivity

Adi DOM: sətir bir dəfə, todo-su yarananda qurulur. Bundan sonra ona yalnız effect-lər toxunur; nə virtual DOM var, nə də template-in yenidən render olunması.

Dəyişiklikdə nə baş verir

React və virtual DOM

Bind olunmuş handler this.setState-i çağırır; React dəyişikliyi state-ə birləşdirir və render()-i yenidən çağırır.

Signal-lar və fine-grained reactivity

.value-nu dəyişmək yalnız həmin signal-ı oxuyan effect-ləri dərhal yenidən işlədir: todo-nu işarələmək onun sətrinin class-ını və sayğacın mətnini yeniləyir, başqa heç nəyi.

Kod necə qurulub

React və virtual DOM

State-in sahibi olan class komponent və props alan kiçik funksiya komponenti: data aşağıya props kimi gedir, dəyişikliklər callback-lərlə yuxarı qayıdır.

Signal-lar və fine-grained reactivity

Yuxarıda signal-lar və computed dəyərlər, sonra hər biri DOM-un bir parçasına bağlı kiçik effect-lər.

Niyə dəyişdi

Yol boyu hər dövrdə nə ağrıtdı və ondan sonra hansı dövr gəldi.

  1. React və virtual DOM→Flux və Redux

    Bir neçə komponentə lazım olan state onların ən yaxın ortaq parent-ində yaşamalı və aradakı hər komponentdən, hətta onu sadəcə ötürənlərdən də, props kimi aşağı keçməli idi; onu dəyişən callback-lər də eyni yolla aşağı gedirdi. Böyük tətbiqdə kliklər, server cavabları və taymerlər müxtəlif komponentlərdə setState çağırır və ekranda görünəni dəyişirdi, ona görə ekranın niyə məhz belə göründüyünü izləmək çətinləşirdi. Flux və Redux paylaşılan state-i komponentlərdən çıxarıb yalnız action-larla dəyişən store-a köçürdü.

  2. Flux və Redux→Komponent framework-ləri (Vue, Angular, Svelte)

    Hər kiçik funksiya üçün bir neçə faylda eyni hissələr lazım idi: action tipi sabiti, action creator, reducer-də case, komponenti qoşmaq üçün mapStateToProps / mapDispatchToProps, üstəlik heç nə mutasiya olunmasın deyə obyektləri əl ilə kopyalamaq. Store-u middleware və DevTools ilə qurmaq isə daha çox kod tələb edirdi. Sonradan Redux özü Redux Toolkit ilə cavab verdi; Vue, Angular və Svelte kimi komponent framework-ləri birbaşa dəyişdirilən reaktiv state və özünü yeniləyən HTML template-ləri təklif etdi, özü də xeyli az mərasimlə.

  3. Komponent framework-ləri (Vue, Angular, Svelte)→SSR, SSG və meta-framework-lər

    Bu tətbiqlər yenə brauzerdə render olunurdu. Server demək olar ki, boş səhifə göndərirdi, framework-ün və tətbiqin JavaScript-i yüklənib işləyənə qədər faydalı heç nə görünmürdü; JavaScript işlətməyən crawler-lər və link önizləmələri isə ümumiyyətlə heç nə görmürdü. Routing, server rendering, code splitting və data yükləməni hər komanda özü bir araya gətirməli idi. Next.js və Nuxt kimi meta-framework-lər bu hissələri komponent framework-ü ətrafında birləşdirdi və səhifələri serverdə və ya build zamanı render etdi.

  4. SSR, SSG və meta-framework-lər→Hooks

    Səhifələr artıq render olunmuş gəlirdi, amma komponentlər hələ də class idi: bir funksiyanın məntiqi componentDidMount, componentDidUpdate və componentWillUnmount arasında paylanırdı, state-li məntiqi paylaşmaq üçün higher-order komponentlər və ya render props lazım idi, hər handler isə this-ə bind olunmalı idi (constructor-a bax). Hooks (React 16.8, 2019) funksiya komponentlərinə state və effect verdi, onları custom hook kimi paylaşmaq mümkün oldu.

    Hydration-un da öz qiyməti vardı: brauzer bütün səhifənin, hətta heç vaxt dəyişməyən hissələrin də kodunu yükləyib işlədir, data isə iki dəfə gəlir: HTML kimi və JSON kimi. Sonralar islands və server komponentləri məhz bu problemin üzərinə getdi.

  5. Hooks→Server komponentləri və island-lar

    Hər şey yenə brauzerdə işləyirdi: səhifə boş gəlirdi, faydalı nəsə görünməzdən əvvəl hər komponentin JavaScript-i yüklənməli, işləməli və render olunmalı idi, server rendering isə heç nəyin interaktiv olmadığı yerlərdə də bütün səhifəni hydrate edirdi. Dependency massivli effect-lər və köhnəlmiş closure-lar tez-tez bug mənbəyinə çevrildi. Islands və React Server Components interaktiv olmayan hissələri yenidən serverə qaytardı.

  6. Server komponentləri və island-lar→Signal-lar və fine-grained reactivity

    Island-ın içində, eləcə də hər client komponentində heç nə dəyişmədi: hər state dəyişikliyi komponenti yenidən işlədir, React isə yeni nəticəni köhnəsi ilə müqayisə edir. Burada bir checkbox-u işarələmək bütün TodoApp-i yenidən render edir və hər elementi müqayisə edir; böyük island-ları sürətli saxlamaq üçün memo, useMemo və useCallback lazım olur. Signals və fine-grained reactivity DOM-un hansı hissəsinin hansı dəyəri oxuduğunu izləyir və yalnız həmin hissəni yeniləyir.

Eyni tətbiq yan-yana

Hər versiyanın əsas faylı. Hər iki tətbiq eyni testdən keçir: eyni markup, eyni davranış, fərqli ideyalar.

Tətbiqlər brauzerində sandbox-larda işləyir.

React və virtual DOM
Signal-lar və fine-grained reactivity

React və virtual DOM

React 19.3.0, React DOM 19.3.0

/src/App.jsx · 98 sətir

JSX
// Virtual DOM dövrü: render() bütün UI-ı this.state-dən təsvir edir, DOM-u isə React yeniləyir.
// O vaxt JSX React.createElement-ə çevrilirdi, ona görə hər fayl React-i import edirdi; burada işlədilən automatic runtime-a bu lazım deyil.
import React from "react";
import TodoItem from "./TodoItem.jsx";

const FILTERS = { all: "All", active: "Active", done: "Done" };

let nextId = 3;

export default class App extends React.Component {
  constructor(props) {
    super(props);
    // State-in sahibi ən yuxarıdakı komponentdir; uşaqları onun hissələrini props kimi alır.
    this.state = {
      todos: [
        { id: 1, title: "Read the docs", done: true },
        { id: 2, title: "Write the app", done: false },
      ],
      filter: "all",
      title: "",
    };
    // Callback kimi ötürülən class metodu `this`-i itirir, ona görə hər handler burada bir dəfə bind olunur.
    this.handleChange = this.handleChange.bind(this);
    this.handleSubmit = this.handleSubmit.bind(this);
    this.toggle = this.toggle.bind(this);
  }

  handleChange(event) {
    // setState verilən açarları this.state-ə birləşdirir və React-dən yenidən render istəyir.
    this.setState({ title: event.target.value });
  }

  handleSubmit(event) {
    event.preventDefault();
    const title = this.state.title.trim();
    if (!title) return;
    const todo = { id: nextId++, title, done: false };
    // setState dərhal dəyişiklik deyil, sorğudur: funksiya forması ən son state-i alır.
    this.setState((state) => ({ todos: state.todos.concat(todo), title: "" }));
  }

  toggle(id) {
    // Todo-nu dəyişmək əvəzinə kopyalayırıq. Object spread ({ ...t }) yalnız ES2018-də
    // standart oldu, ona görə o vaxtın kodu Object.assign işlədirdi.
    this.setState((state) => ({
      todos: state.todos.map((t) => (t.id === id ? Object.assign({}, t, { done: !t.done }) : t)),
    }));
  }

  // React onu hər state dəyişikliyində yenidən çağırır, yeni elementləri əvvəlkilərlə müqayisə edir
  // (virtual DOM) və yalnız fərqli olan DOM node-larını dəyişir.
  render() {
    const { todos, filter, title } = this.state;
    const shown = todos.filter((t) => filter === "all" || (filter === "done") === t.done);
    const left = todos.filter((t) => !t.done).length;

    return (
      <main className="todo-app">
        <h1>Todos</h1>
        <form id="todo-form" onSubmit={this.handleSubmit}>
          <input
            id="new-todo"
            value={title}
            onChange={this.handleChange}
            placeholder="What needs doing?"
            autoComplete="off"
            aria-label="New todo"
          />
          <button id="add" type="submit">
            Add
          </button>
        </form>
        <ul id="todo-list">
          {/* Data aşağıya props kimi gedir; dəyişiklik isə onToggle ilə yuxarı qayıdır. */}
          {shown.map((todo) => (
            <TodoItem key={todo.id} todo={todo} onToggle={this.toggle} />
          ))}
        </ul>
        <div className="footer">
          <span id="todo-count">{left} left</span>
          <div className="filters">
            {Object.keys(FILTERS).map((name) => (
              <button
                key={name}
                type="button"
                data-filter={name}
                className={filter === name ? "selected" : undefined}
                onClick={() => this.setState({ filter: name })}
              >
                {FILTERS[name]}
              </button>
            ))}
          </div>
        </div>
      </main>
    );
  }
}

Signal-lar və fine-grained reactivity

Preact Signals 1.14.5

/src/main.js · 78 sətir

JavaScript
// Signals dövrü: state signal-larda yaşayır, hər effect DOM-un bir parçasını uyğun saxlayır.
// Effect oxuduğu signal-ları yadda saxlayır və yalnız onlardan biri dəyişəndə yenidən işləyir.
import { signal, computed, effect } from "@preact/signals-core";

let nextId = 1;
// Hər todo-nun done-u ayrıca signal-dır, ona görə bir todo-nu işarələmək yalnız onun sətrinə toxunur.
const createTodo = (title, done = false) => ({ id: nextId++, title, done: signal(done) });

const todos = signal([createTodo("Read the docs", true), createTodo("Write the app")]);
const filter = signal("all");
// Computed cache-lənir: yalnız oxuduğu signal dəyişəndən sonra yenidən hesablanır.
const left = computed(() => todos.value.filter((t) => !t.done.value).length);

const list = document.getElementById("todo-list");
const rowTemplate = document.getElementById("todo-row");

// Sətri bir dəfə qurur. Bundan sonra ona yalnız öz iki effect-i toxunur.
function renderRow(todo) {
  const li = rowTemplate.content.firstElementChild.cloneNode(true);
  const checkbox = li.querySelector("[data-toggle]");
  li.querySelector(".title").textContent = todo.title;
  checkbox.addEventListener("change", () => {
    todo.done.value = checkbox.checked;
  });

  // Yalnız MƏHZ bu todo-nun done-u dəyişəndə yenidən işləyir.
  effect(() => {
    li.classList.toggle("done", todo.done.value);
    checkbox.checked = todo.done.value;
  });

  // Filtr və ya bu todo-nun done-u dəyişəndə yenidən hesablanır. Cavab eyni qalırsa
  // ("All" altında todo-nu işarələyəndə), onu oxuyan effect ümumiyyətlə işləmir.
  const shown = computed(() => filter.value === "all" || (filter.value === "done") === todo.done.value);
  effect(() => {
    li.style.display = shown.value ? "" : "none";
  });
  return li;
}

// Yalnız siyahının özü dəyişəndə (todo əlavə olunanda) yenidən işləyir. Yeni todo-lar üçün
// sətir qurur, mövcudlara toxunmur. Burada heç nə silinmir, ona görə heç bir effect dispose olunmur.
const rendered = new Set();
effect(() => {
  for (const todo of todos.value) {
    if (rendered.has(todo)) continue;
    rendered.add(todo);
    list.append(renderRow(todo));
  }
});

// left dəyişəndə yenidən işləyir: todo əlavə edəndə və ya işarələyəndə, filtr seçəndə heç vaxt.
const count = document.getElementById("todo-count");
effect(() => {
  count.textContent = `${left.value} left`;
});

// Filtr dəyişəndə yenidən işləyir: "selected" class-ını köçürür.
const buttons = document.querySelectorAll("[data-filter]");
effect(() => {
  for (const button of buttons) button.classList.toggle("selected", button.dataset.filter === filter.value);
});

for (const button of buttons) {
  button.addEventListener("click", () => {
    filter.value = button.dataset.filter;
  });
}

document.getElementById("todo-form").addEventListener("submit", (event) => {
  event.preventDefault();
  const input = document.getElementById("new-todo");
  const title = input.value.trim();
  if (!title) return;
  // Yeni massiv: signal yeni dəyər alır və onu oxuyan effect-lər yenidən işləyir.
  todos.value = [...todos.value, createTodo(title)];
  input.value = "";
});