Skip to content
FrontDepth, Home

Two-way binding (AngularJS) → React and the virtual DOM

2010 – 2021 · 2013 – today

Older era
Newer era
Compare

What changed

Where the state lives

Two-way binding (AngularJS)

On $scope: plain objects in $scope.todos, the filter in $scope.show and the text field's value in $scope.newTitle.

React and the virtual DOM

In this.state of the top App class: the todos, the filter and the typed text, changed only through this.setState.

How the page is rendered

Two-way binding (AngularJS)

The HTML is the template: AngularJS compiles the ng-* attributes and {{ }} once, then each binding updates its own piece of the DOM.

React and the virtual DOM

render() returns the whole UI as React elements on every change; React compares them with the previous ones and patches only the DOM that differs.

What happens on a change

Two-way binding (AngularJS)

Directives run handlers inside $apply; the digest evaluates every watcher again and changes the DOM where a value differs. ng-model also writes from the field back to the scope.

React and the virtual DOM

A bound handler calls this.setState; React merges the change into the state and calls render() again.

How the code is organised

Two-way binding (AngularJS)

A module, a controller that fills $scope, and directives in the HTML. The controller has no DOM code.

React and the virtual DOM

A class component that owns the state and a small function component that gets props: data goes down as props, changes come back up through callbacks.

Why it changed

What hurt in each era along the way, and the era that came next.

  1. Two-way binding (AngularJS)→React and the virtual DOM

    Every binding added a watcher, and every digest checked all of them, at least twice whenever something had changed, so pages with many bindings slowed down on each click or keystroke (1.3 added one-time bindings, ::, to cut the count). Two-way bindings and watchers that change other values made it hard to see what changed what, and code outside AngularJS, like a setTimeout callback or a jQuery plugin, had to remember to call $scope.$apply().

    Angular 2 was a new framework rather than the next version: an app could not just upgrade, and the official path was to migrate it piece by piece, with both frameworks running side by side. React answered with one-way data flow: a component renders from its state, and a virtual DOM works out what to change on the page.

The same app, side by side

The main file of each version. Both apps pass the same test: same markup, same behaviour, different ideas.

The apps run in sandboxes in your browser.

Two-way binding (AngularJS)
React and the virtual DOM

Two-way binding (AngularJS)

AngularJS 1.8.3

/index.html · 35 lines

HTML
<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8" />
    <title>Todos · AngularJS</title>
    <link rel="stylesheet" href="/styles.css" />
  </head>
  <body>
    <!-- The page is the template: ng-* attributes and {{ }} bind it to TodoCtrl's $scope. -->
    <main class="todo-app" ng-controller="TodoCtrl">
      <h1>Todos</h1>
      <!-- A form without an action: AngularJS stops the real submit and calls add(). -->
      <form id="todo-form" ng-submit="add()">
        <!-- Two-way: typing writes $scope.newTitle, and setting newTitle changes the field. -->
        <input id="new-todo" ng-model="newTitle" placeholder="What needs doing?" autocomplete="off" aria-label="New todo" />
        <button id="add" type="submit">Add</button>
      </form>
      <ul id="todo-list">
        <!-- ng-repeat gives every <li> a child scope holding its todo. ng-model="todo.done" writes -->
        <!-- straight into that object, so the controller's list sees the change. -->
        <li ng-repeat="todo in todos | filter:matches" ng-class="{done: todo.done}">
          <label><input type="checkbox" data-toggle ng-model="todo.done" /> <span class="title">{{todo.title}}</span></label>
        </li>
      </ul>
      <div class="footer">
        <span id="todo-count">{{remaining()}} left</span>
        <div class="filters">
          <button type="button" data-filter="all" ng-class="{selected: show == 'all'}" ng-click="show = 'all'">All</button>
          <button type="button" data-filter="active" ng-class="{selected: show == 'active'}" ng-click="show = 'active'">Active</button>
          <button type="button" data-filter="done" ng-class="{selected: show == 'done'}" ng-click="show = 'done'">Done</button>
        </div>
      </div>
    </main>
  </body>
</html>

React and the virtual DOM

React 19.3.0, React DOM 19.3.0

/src/App.jsx · 98 lines

JSX
// Virtual DOM era: render() describes the whole UI from this.state, and React updates the DOM.
// JSX then compiled to React.createElement, so every file imported React; the automatic runtime used here does not need it.
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);
    // The top component owns the state; its children get pieces of it as props.
    this.state = {
      todos: [
        { id: 1, title: "Read the docs", done: true },
        { id: 2, title: "Write the app", done: false },
      ],
      filter: "all",
      title: "",
    };
    // A class method passed as a callback loses `this`, so each handler is bound once here.
    this.handleChange = this.handleChange.bind(this);
    this.handleSubmit = this.handleSubmit.bind(this);
    this.toggle = this.toggle.bind(this);
  }

  handleChange(event) {
    // setState merges the given keys into this.state and asks React to render again.
    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 is a request, not an immediate change: the function form gets the latest state.
    this.setState((state) => ({ todos: state.todos.concat(todo), title: "" }));
  }

  toggle(id) {
    // Copy the todo instead of changing it. Object spread ({ ...t }) only became standard
    // in ES2018, so code of the time used Object.assign.
    this.setState((state) => ({
      todos: state.todos.map((t) => (t.id === id ? Object.assign({}, t, { done: !t.done }) : t)),
    }));
  }

  // React calls it again on every state change, compares the new elements with the previous ones
  // (the virtual DOM) and changes only the DOM nodes that differ.
  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 goes down as props; the change comes back up through onToggle. */}
          {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>
    );
  }
}