Skip to main content
SimilarExport ZIP
100%

Hello React + D3!

✓ Published0🌍 Public
CCurran Kelleher
Last edited Aug 26, 2016
Created on Aug 13, 2016

This example demonstrates a reusable React component that integrates with D3 to render animated SVG graphics. Dynamic data updates every second, repositioning circles while diagonal lines are redrawn to follow the resizing viewport. The code uses D3 v4 transitions for smooth attribute changes, React's lifecycle methods (`componentDidMount`, `componentWillUnmount`) for setup and cleanup, and a `setInterval` to update the visualization. It also responds to window resizing and keyboard input to toggle the graphic's visibility.

AI-generated description

Boilerplate D3 + React integration.

Features:

  • Uses D3 transitions
  • Responds to resize
  • Demonstrates complete lifecycle (mount, update, unmount)
  • Responds to dynamic data

Inspired by:

I'm new to React and I'm not sure if everything I've done here is "the react way". If you see something questionable please let me know on Twitter.

Many thanks to @DatMousse for this refactor proposal.

Built with blockbuilder.org

forked from <a href='http://bl.ocks.org/curran/'>curran</a>'s block: <a href='http://bl.ocks.org/curran/2e2a5f51d9b0dd74f504447f2b53f9aa'>React Boilerplate</a>

<!-- Start of SimpleHitCounter Code --> <div align="center"><img src="http://simplehitcounter.com/hit.php?uid=2153598&f=16777215&b=0" border="0" height="18" width="83"></a></div> <!-- End of SimpleHitCounter Code -->
mit Licensed

Similar vizzes

Loading thumbnail…

D3 and React

Two React components render D3 visualizations side-by-side. A bar chart maps an array of values to SVG rectangles and text labels, using D3's data join with `selectAll`, `enter`, and attribute setters, with colors via HSL strings and classes for high/low values. A second component demonstrates React's managed rendering alongside unmanaged D3 updates, appending HTML elements, merging enter/update selections, and animating appended spans with `transition().duration().delay()`. Both components use `useRef` and `useEffect` to access the DOM, with data generated by `d3.range`.

Ggjonor
81% match
Loading thumbnail…

React Import d3 Data

This example shows a React-based interactive face built with SVG. A single circle is rendered inside a 960 by 500 pixel SVG element, and its position is updated in real-time based on the mouse cursor's coordinates. The implementation uses React's `useState` and `useCallback` hooks to manage the mouse position state and handle `onMouseMove` events. The SVG circle is redrawn with new `cx` and `cy` attributes as the mouse moves, while the `ReactDOM.render` function mounts the application into the root HTML element.

AAki78
80% match
Loading thumbnail…

Interaction with React

This example demonstrates a real-time interactive visualization where a circular SVG element follows the mouse cursor across a 960x500 canvas. Built with React 17 and D3 v7, the application uses React’s `useState` and `useCallback` hooks to track mouse coordinates through an `onMouseMove` event handler on the `<svg>` element. As the pointer moves, React re-renders the circle’s `cx` and `cy` attributes, updating its position instantly. The visualization highlights how React manages state-driven updates for DOM elements, contrasting with D3’s imperative approach to data binding.

Nnicholasgonzalez1
80% match
Loading thumbnail…

D3 Selection Exercise

This animated visualization demonstrates D3’s data-join and selection pattern by continuously updating a set of circles and connecting lines in an SVG scene. The code uses `selectAll` and `.join()` within `drawCircles` and `drawLines` to bind and update elements based on procedurally generated data from `makeCircleData` and `makeLineData`. Circle positions, radii, and colors oscillate with a time counter `t`, while lines link adjacent circles and inherit their stroke colors. Running at 60fps via `setInterval`, the example highlights how D3 v7’s `range`, `select`, and join methods handle dynamic, frame-by-frame updates in a React context.

Mmax-31
80% match
Loading thumbnail…

Interaction with React

This example demonstrates a React-based SVG visualization where a circle follows the mouse pointer across a 960-by-500 viewport. It shows how mouse events and unidirectional data flow manage interactive state in React, using the `useState` hook to track cursor coordinates and `useCallback` for the event handler. The single-circle rendering, with a white inner circle, updates its `cx` and `cy` attributes on every `onMouseMove` event, relying on D3 v6 for SVG utilities and React 16 for component rendering.

IIlgar Akalın
79% match
Loading thumbnail…

Loading data in react with d3

This example demonstrates a simple interactive visualization where a single circle follows the mouse cursor within an SVG canvas. It shows how to combine React’s state management with D3.js for rendering. The code defines a React component using `useState` to track mouse coordinates, and handles `onMouseMove` events to update the circle’s `cx` and `cy` attributes. It uses `d3.v6` for SVG handling and `ReactDOM.render` to mount the component, with the circle radius hard-coded as 30 pixels.

SSushan Prajapati
79% match
Loading thumbnail…

D3 Selection Exploration

This example demonstrates animated SVG circles in a wave-like pattern, updating every five seconds. It uses D3’s `select` and `range` to generate data and the `data().join()` pattern to handle circle enter and update states. The code appends circles to the body, setting their `cx` and `cy` attributes based on a sine function, with the animation driven by a JavaScript `setInterval` that increments time and re-renders the positions. The visualization shows how D3’s selection and data-binding APIs work with React-style vanilla JavaScript, rendering in full-screen SVG.

KKyuhyun
79% match
Loading thumbnail…

D3 Selection exploration

This example demonstrates how D3 selections manage dynamic data updates through animation. An SVG scene continuously redraws a set of circles and connecting lines, with the number of elements oscillating between 5 and 15 based on a sine wave. The code uses D3’s `select` and `range` functions, along with the `join` pattern to bind data to circle and line elements. Data is generated procedurally via `makeData`, updating positions and radii each frame. React serves as the framework wrapper, while the animation runs on a `setInterval` timer with a 60fps approximation.

Rrwata97
79% match