D3.js in action-advanced data visualization techniques and examples
I focus on the long-term foundations of computer science, software engineering, and emerging technologies.covering computer science, AI, semiconductors, quantum computing, and future engineering.
Basics
First, we need an HTML file to import the D3.js library and prepare a canvas to place our chart.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Getting Started with D3.js Example</title>
<script src="https://d3js.org/d3.v7.min.js"></script>
</head>
<body>
<svg width="500" height="500"></svg>
</body>
</html>
Create a simple line graph
// Assume we have the following data
var data = [4, 8, 15, 16, 23, 42];
// Create an SVG canvas
var svg = d3.select("svg"),
margin = {top: 20, right: 20, bottom: 30, left: 50},
width = +svg.attr("width") - margin.left - margin.right,
height = +svg.attr("height") - margin.top - margin.bottom;
// Create x and y scales
var x = d3.scaleLinear()
.domain(d3.extent(data, d => d))
.range([0, width]);
var y = d3.scaleLinear()
.domain([0, d3.max(data)])
.range([height, 0]);
// Create the x and y axes
var xAxis = d3.axisBottom(x),
yAxis = d3.axisLeft(y);
// Add axis
svg.append("g")
.attr("transform", "translate(0," + height + ")")
.call(xAxis);
svg.append("g")
.call(yAxis);
// Draw the polyline
var line = d3.line()
.x(d => x(d))
.y(d => y(d));
svg.append("path")
.datum(data)
.attr("class", "line")
.attr("d", line);
Creating a Bar Chart
// Suppose we have the following data
var data = [4, 8, 15, 16, 23, 42];
// Creating the SVG canvas and scale
var svg = d3.select("svg").attr("width", 500).attr("height", 500);
var margin = {top: 20, right: 20, bottom: 30, left: 40};
var width = +svg.attr("width") - margin.left - margin.right;
var height = +svg.attr("height") - margin.top - margin.bottom;
var x = d3.scaleBand().rangeRound([0, width]).padding(0.1);
var y = d3.scaleLinear().rangeRound([height, 0]);
// Mapping data to scale
x.domain(data.map(function(d) { return d; }));
y.domain([0, d3.max(data)]);
// Creating an SVG g Element
var g = svg.append("g")
.attr("transform", "translate(" + margin.left + "," + margin.top + ")");
// Adding x and y axes
g.append("g")
.attr("transform", "translate(0," + height + ")")
.call(d3.axisBottom(x));
g.append("g")
.call(d3.axisLeft(y));
// Draw a bar chart
g.selectAll(".bar")
.data(data)
.enter().append("rect")
.attr("class", "bar")
.attr("x", function(d) { return x(d); })
.attr("y", function(d) { return y(d); })
.attr("width", x.bandwidth())
.attr("height", function(d) { return height - y(d); });
Create a pie chart
// Suppose we have the following data
var data = [4, 8, 15, 16, 23, 42];
// Creating the SVG canvas and scale
var svg = d3.select("svg").attr("width", 500).attr("height", 500);
var radius = Math.min(svg.attr("width"), svg.attr("height")) / 2;
// Creating an arc scale
var arc = d3.arc().outerRadius(radius).innerRadius(0);
var pie = d3.pie().value(function(d) { return d; });
// Draw a pie chart
var g = svg.append("g")
.attr("transform", "translate(" + radius + "," + radius + ")");
var arcs = g.selectAll("arc")
.data(pie(data))
.enter().append("g")
.attr("class", "arc");
arcs.append("path")
.attr("d", arc)
.attr("fill", function(d, i) { return d3.schemeCategory10[i]; });
arcs.append("text")
.attr("transform", function(d) { return "translate(" + arc.centroid(d) + ")"; })
.attr("dy", ".35em")
.text(function(d) { return d.data; });
Interactivity and animation
Interactivity example: adding hover effects to a bar chart
// Assuming that the bar chart base code already exists
// ...
// Add hover effects
g.selectAll(".bar")
.on("mouseover", function(event, d) {
d3.select(this)
.transition()
.duration(200)
.attr("fill", "orange"); // Mouseover color change
// Show Data Tips
var tooltip = g.append("text")
.attr("class", "tooltip")
.attr("x", x(d) + x.bandwidth() / 2)
.attr("y", y(d) - 10)
.text(d);
})
.on("mouseout", function(event, d) {
d3.select(this)
.transition()
.duration(200)
.attr("fill", "steelblue"); // Restore original color
// Remove data tips
g.selectAll(".tooltip").remove();
});
Animation example: Smooth transition line chart data update
// Assume that there is already a line chart basic code
// ...
// Update data
var newData = [8, 15, 16, 23, 42, 45];
// Update scale domain
x.domain(d3.extent(newData));
y.domain([0, d3.max(newData)]);
// Update axis
g.select(".axis--x").transition().duration(750).call(xAxis);
g.select(".axis--y").transition().duration(750).call(yAxis);
// Update path
var path = g.select(".line");
path.datum(newData).transition().duration(750).attr("d", line);
Complex graphs: force-directed graphs
Force-directed graphs show the relationship between nodes and edges, which is very suitable for visualizing data such as networks and social graphs.
// Assume we have data on nodes and edges
var nodes = [{id: "A"}, {id: "B"}, {id: "C"}];
var links = [{source: nodes[0], target: nodes[1]}, {source: nodes[1], target: nodes[2]}];
// Creating the SVG Canvas
var svg = d3.select("svg"),
width = +svg.attr("width"),
height = +svg.attr("height");
// Creating a Force Simulation
var simulation = d3.forceSimulation(nodes)
.force("link", d3.forceLink(links).id(function(d) { return d.id; }))
.force("charge", d3.forceManyBody())
.force("center", d3.forceCenter(width / 2, height / 2));
// Creating links and nodes
var link = svg.append("g")
.attr("stroke", "#999")
.attr("stroke-opacity", 0.6)
.selectAll("line")
.data(links)
.join("line")
.attr("stroke-width", 2);
var node = svg.append("g")
.attr("stroke", "#fff")
.attr("stroke-width", 1.5)
.selectAll("circle")
.data(nodes)
.join("circle")
.attr("r", 5)
.call(d3.drag()
.on("start", dragstarted)
.on("drag", dragged)
.on("end", dragended));
node.append("title")
.text(function(d) { return d.id; });
simulation.on("tick", ticked);
function ticked() {
link
.attr("x1", function(d) { return d.source.x; })
.attr("y1", function(d) { return d.source.y; })
.attr("x2", function(d) { return d.target.x; })
.attr("y2", function(d) { return d.target.y; });
node
.attr("cx", function(d) { return d.x; })
.attr("cy", function(d) { return d.y; });
}
// Drag event handling function
function dragstarted(event, d) {
if (!event.active) simulation.alphaTarget(0.3).restart();
d.fx = d.x;
d.fy = d.y;
}
function dragged(event, d) {
d.fx = event.x;
d.fy = event.y;
}
function dragended(event, d) {
if (!event.active) simulation.alphaTarget(0);
d.fx = null;
d.fy = null;
}
Map Visualization
D3.js can work with geographic data formats such as GeoJSON to create interactive maps. This includes countries, states, city boundaries, etc.
Basic steps:
Load map data: Use D3's d3.json or d3.geoJson to load GeoJSON data.
Create scale: Define a geographic projection and scale, such as Mercator or Albers USA.
Bind data and draw: Bind GeoJSON data to SVG path elements and apply a projection.
Add interactions: Such as hover effects, click events, etc.
d3.json("world.geojson").then(function(geoData) {
var svg = d3.select("svg"),
projection = d3.geoMercator().scale(130).translate([400, 250]),
path = d3.geoPath().projection(projection);
svg.selectAll("path")
.data(geoData.features)
.enter().append("path")
.attr("d", path)
.attr("fill", "#ccc")
.attr("stroke", "#fff");
});
Data binding and dynamic update
Basic steps:
Initialize data binding: Use the data() method to bind data to DOM elements.
Enter, Update, Exit mode: process new data, update existing data, and remove useless data.
Dynamic update: monitor data changes, re-execute binding and rendering processes.
var svg = d3.select("svg"),
data = [4, 8, 15, 16, 23, 42];
// Initialize the bar chart
var bars = svg.selectAll("rect").data(data);
bars.enter().append("rect")
.attr("x", function(d, i) { return i * 50; })
.attr("y", function(d) { return 300 - d; })
.attr("width", 40)
.attr("height", function(d) { return d; });
// Dynamic Updates
setInterval(function() {
data = data.map(function(d) { return Math.max(0, Math.random() * 50); });
bars.data(data)
.transition()
.duration(500)
.attr("y", function(d) { return 300 - d; })
.attr("height", function(d) { return d; });
}, 2000);
Complex charts and advanced techniques
Advanced techniques:
Use D3 component libraries: Libraries like D3fc provide advanced chart components to simplify the creation of complex charts.
Animation and transition: Use the transition() method to create smooth animation effects.
Interactivity: Add click and hover events, and use brush and zoom functions to enhance user experience.
Performance optimization: Use selectAll(), data(), enter(), exit() reasonably to reduce DOM operations, and use requestAnimationFrame() to optimize animation performance.
👉 Click to join, the system improves development capabilities:
🧡 Patreon: Online subscription, daily updates, member community
📦 Tianya School Shop: Single or series of tutorials packaged learning
💰 Tianya School Store: Online learning or full download
