Skip to main content
SimilarExport ZIP
100%

Bowl of Fruit - Nested Elements

✓ Published1🌍 Public
JJordan Chiu
Last edited Jan 27, 2020
Created on Jan 27, 2020

This example demonstrates a nested SVG visualization where circular fruits inside a rounded bowl update dynamically over time. Using D3 v5 and the `fruitBowl` module, elements are bound to a `fruits` array, with apples (red, radius 50) and lemons (yellow, radius 30) encoded through ordinal color and size scales. The code shows incremental changes: removing an apple, altering one apple to a lemon, and filtering out another, showcasing how D3’s selection merging, `.merge()`, and `.exit()` handle transitions. The rendering uses raw SVG `rect`, `circle`, and `text` elements, driven by timer-based state mutations.

AI-generated description

Tutorial!

MIT Licensed

Similar vizzes

Loading thumbnail…

Bowl of fruits - nested element

This example demonstrates a fruit bowl visualization with nested SVG elements, showing apples and lemons as colored circles with labels. It uses D3.js version 5 with a data join pattern, employing `selection.enter()`, `merge()`, and `exit()` to handle dynamic updates. The code uses `d3.scaleOrdinal` for both color and radius mapping, while `d3.range` generates the initial fruit array. Over timed intervals, the visualization removes fruits, changes a fruit type, and filters elements, showcasing how nested groups and child elements update responsively.

Aaxliao
95% match
Loading thumbnail…

Bowl of Fruit - Nested Elements

This example demonstrates how D3.js can manage dynamic updates to nested SVG elements within a fixed container. Five fruits are initially displayed as colored circles with text labels, representing apples in red and a lemon in yellow, all layered over a bowl-shaped rectangle. Over three seconds, the visualization reacts to data changes: an apple is removed, another apple transforms into a lemon, and a second apple is deleted. The code uses D3’s scaleOrdinal for color and radius mapping, selection merging via `.merge()` to update existing elements, and a simple `setTimeout` sequence to trigger re-renders. The SVG rendering approach is visible throughout the process.

EEllednera
95% match
Loading thumbnail…

Bowl of fruit - Nested Elements

A bowl of fruit demonstrates nested SVG elements with a dynamic data join, showing apples and lemons arranged in a row. The visualization uses a D3 ordinal scale to map fruit types to colors and radii, while enter, update, and exit selections manage the transitions as fruits are eaten or replaced over time. Circles and text labels are appended within each group element, and the bowl is drawn as a rounded rectangle behind the fruit.

Hhugomell
95% match
Loading thumbnail…

Bowl of fruit - Nested

This example demonstrates a nested data visualization of a fruit bowl, where circles and labels are bound to an array of fruit objects in SVG. It shows five apples that are sequentially removed or replaced with a lemon over timed intervals, highlighting layout updates. The code uses D3 v5’s `scaleOrdinal` for color and radius mapping, SVG `g`, `circle`, and `text` elements, plus React-style enter/merge/exit patterns via `selection.enter()`, `selection.merge()`, and `selection.exit()`. A static `rect` renders the bowl container.

NNkwachi Abel
94% match
Loading thumbnail…

Bowl of Fruit - Nested Elements_Singular Elements

A bowl of fruit demonstrates nested SVG elements with singular data joins. Five apples render as red circles inside a rounded rectangle bowl, each group containing a circle and a text label. Over time, the dataset shrinks, one apple changes into a yellow lemon, and another apple is removed. Using `d3.scaleOrdinal` for color and radius, the code performs enter, update, and exit selections via `selection.enter()`, `merge()`, and `exit().remove()` to transition the fruit groups dynamically. The example shows how to manage hierarchical SVG structures with D3 v5.

MMinwoo Pak
94% match
Loading thumbnail…

D3 Bowl of Fruit - With Nested Elements

This example demonstrates dynamic data updates with nested SVG elements, rendering apples and lemons in a rounded bowl shape. The visualization uses d3-selection's enter/merge/exit pattern within a custom `fruitBowl` function, updating fruit positions and styles as the data array changes over timed intervals. The code leverages `d3.scaleOrdinal` for color and radius mappings, and binds fruit data to `<g>` groups containing nested `<circle>` and `<text>` elements. The animation cycles through removing, modifying, adding, and filtering fruits to show how joins handle each change.

Rrdeichert
94% match
Loading thumbnail…

Bowl of Fruits - Nested elements

A bowl of fruits demonstrates nested SVG elements and data joins in D3.js v5. Rectangular bowls hold circular fruits, with apples and lemons distinguished by color and size through d3.scaleOrdinal scales. The visualization updates over time as fruits are removed and types change, showing enter, update, and exit selections. The code uses d3.select and selection methods like .merge() and .exit().remove() to manage dynamic rendering, with text labels positioned below each fruit.

YYasara Peiris
94% match
Loading thumbnail…

Bowl of Fruit - Nested

Five apples render as nested SVG circles in a row, their size and color mapped by `d3.scaleOrdinal` to fruit type. The code uses the `fruitBowl` module to draw circles and labels with `.enter()`, `.merge()`, and `.exit()` transitions. Timed actions mutate the `fruits` array, removing one apple, replacing another with a lemon, and filtering out a third, demonstrating incremental updates to the DOM.

HHe Jianfeng
93% match