Skip to main content
SimilarExport ZIP
100%

D3 SVG Tutorial

✓ Published0🌍 Public
JJamestiberiuseanes
Last edited Feb 3, 2016
Created on Feb 3, 2016

This example shows a static bar chart of a 20-point dataset rendered as an SVG, with each bar’s height and color intensity tied to its value. The code uses D3.js version 3.5.5, applying the `d3.select` and `data().enter()` pattern to append rectangles and text labels. Bars are positioned with arithmetic on the dataset length and fixed width/height variables, while fill colors are generated as RGB values scaled by data. The chart demonstrates basic SVG shape binding and data-driven styling without axes or interaction.

AI-generated description

VI2 - James Eanes

Part 1 - Tableau:

  • Bar chart of passing yards per player (best displayed as a horizontal bar chart), with conference mapped to color
    • Insight: this is incredibly easy to do with an off-the-shelf tool (i.e., a few mouse clicks) versus the hours it took to learn enough about R to make this same graph!

tableau_barchart_passingyds_confcolor

  • Scatterplot of 2 interesting variables, with conference mapped to color
    • Insight: I chose to plot pass attempts and interceptions to determine what correlation might exist between them and what outliers might exist; as one might expect, those with the most interceptions also had relatively high pass attempts; however, there is one passer who clear surpasses everyone in interceptions (22, with about 440 passes), and there is one with a remarkable 8 interceptions with 550 passes. Good plot for finding standouts.

tableau_scatterplot_passattempts_vs_interceptions

  • One other interesting graph that uses a derived variable
    • Insight: I chose to plot the sum of passing and rushing yards per passer; this gives a quick view of the most capable “threats” in terms of both their arms and legs, with about 7 real stand-outs.

sumrushingpassing

Comments on using Tableau:

  1. It's very easy to use for simple charts, but takes some time to get used to the layout.
  2. I had to search around to figure out how to get the sum of two measures; turned out I needed to right-click on one of the measures and create a "Calculated Field", which wasn't the most obvious of ways to get there.

What I learned in this part of the D3 tutorial:

  1. Internet Explorer 8+ doesn't support SVG...seems bad...
  2. SVG syntax is apparently based on (or at least very similar to) XML
  3. There are multiple ways to represent just about everything, but the "chaining" approach really helps when adding lots of attributes (instead of typing in values as attributes on a DOM element).

Similar vizzes

Loading thumbnail…

CS 725 Information Visualization - VI2

This example demonstrates a bar chart for a dataset of 20 numeric values, with each bar’s height and color intensity proportional to its value. The chart is rendered as an SVG using D3.js (version 3.5.5), where `d3.select` appends an SVG element, and `selectAll("rect")` with `data()` and `enter()` creates the bars. Text labels are positioned at each bar’s top using an inverted coordinate system, where `y` is calculated from the height. The source code is a standalone HTML file, and the dataset is hardcoded as an array. The rendering uses basic D3 APIs such as `attr` for styling and `text-anchor` for label alignment.

CChristosT
86% match
Loading thumbnail…

D3: Drawing a Bar Chart

This example demonstrates a basic bar chart built with D3 v7 in an SVG container, visualizing an array of 20 numeric values. The bars grow downward from the top of a 500×100 pixel canvas, with each bar’s height proportional to its data value multiplied by 4, and its fill color transitioning from dark to lighter blue based on the data. The chart also overlays each bar with white, 11px sans-serif text labels showing the exact data values, centered horizontally within each bar. The code uses `d3.select` to append SVG elements and the data-join pattern with `.enter()` to create rectangles and text nodes.

MMarisa Tania
86% match
Loading thumbnail…

D3 Page Template

This example uses D3 v5 to render a simple bar chart. It creates an SVG canvas of 300 by 300 pixels, then defines a dataset of six numeric values. The code selects the SVG element, binds the data to it, and appends rectangles with widths proportional to the data values. Each rectangle’s height is fixed at 30 pixels minus a small gap, and its y-position is offset by index. The bars are uniformly colored steel blue. The rendering is purely SVG-based, using `d3.select`, `.append`, `.data`, and `.enter` to construct and position the bars.

AAn Jingyi
86% match
Loading thumbnail…

VI2

This example demonstrates a basic D3.js bar chart visualizing a static dataset of twenty numeric values. The visualization uses SVG rectangles to represent each value, with bar height proportional to the data point and a color scale that darkens with increasing magnitude. Text labels display the exact value above each bar, and the chart employs D3’s selection, data binding, and attribute methods (`attr`) to render the visualization. The dataset is hardcoded within the script, and the SVG canvas is sized at 500 by 150 pixels.

NN0taN3rd
86% match
Loading thumbnail…

D3 bar chart with data-binding

This example demonstrates a simple D3 bar chart that binds an array of numeric values to SVG rectangles, with each bar’s height proportional to its data point. It uses D3 v4’s `scaleLinear` to map the data domain to a fixed pixel range, then applies the `data()` and `enter()` methods to create and position the rectangles. The chart renders with a minimal style—unfilled bars with black outlines—and the data is hardcoded as a static array. The code relies on standard D3 selection and scale APIs, with the SVG container set to 960 by 500 pixels.

4456lumen
85% match
Loading thumbnail…

D3: SVG bar chart with value labels (centered)

This example renders a static SVG bar chart from an inline array of 20 numeric values, with each bar’s value displayed as white, centered text labels at its top. The visualization uses D3 v7’s data join (`selectAll`, `data`, `enter`) to append SVG `rect` elements and corresponding `text` elements, with bar heights and fill intensities scaled to the data. Bar spacing and label positioning are computed arithmetically from the chart width and dataset length, while text anchoring is handled via the `text-anchor` attribute.

AAlark Joshi
85% match
Loading thumbnail…

D3: Basic Barchart

This example shows a basic bar chart of 20 numeric values rendered as SVG rectangles, with each bar labeled by its value in white text. The chart uses D3 v5 scales, including a `scaleBand` for the x-axis positioning and a `scaleLinear` for the y-axis height calculation. Data is bound via `selectAll("rect").data()`, with bars and text labels positioned using the scales. The code loads D3 from UNPKG and demonstrates simple SVG generation without axes or interactivity.

AAnissa Belkelfa
84% match
Loading thumbnail…

svg & d3 - example

This example demonstrates a simple bar chart built with D3.js v4, using an SVG-based rendering approach. It displays a small dataset of four numeric values as horizontal bars, with a separate checklist interface above the chart that lists the same data points as labeled checkboxes. The visualization pairs categorical data with an interactive checklist, though the chart itself is static and does not respond to checkbox state. The code uses D3 selections and data binding (`d3.select`, `selectAll`, `data`, `enter`, `append`) to create both the label inputs and the bar elements, while CSS styles define the bar colors and text alignment. The chart is rendered as a series of `div` elements within a container, with widths proportional to the data values.

BBharath4259
84% match