Reuniendo a React, D3 y su ecosistema

 

 

 


Índice
  1. D3 y el DOM
    1. ¿Como funciona?
    2. Uniones de datos
  2. Bibliotecas D3
  3. Reaccionar y el DOM
    1. ¿Como funciona?
    2. Componentes secundarios dinámicos
  4. Reaccionar y D3.js
    1. Enfoques
  5. Bibliotecas React-D3.js
  6. Choosing An Approach Or Library

React y D3.js son excelentes herramientas para ayudarnos a lidiar con el DOM y sus desafíos. Seguramente pueden trabajar juntos y nosotros tenemos el poder de elegir dónde trazar la línea entre ellos. Ambos toman el control de los elementos de la interfaz de usuario y lo hacen de diferentes maneras. ¿Cómo podemos hacer que trabajen juntos mientras optimizamos sus distintas ventajas de acuerdo con su proyecto actual? En este artículo, Marcos Iglesias verá cómo podemos abordar la construcción de proyectos de React que necesitan la poderosa bondad de gráficos de D3.

 

Desde su creación en 2011, D3.js se ha convertido en el estándar de facto para crear visualizaciones de datos complejas en la web. React también está madurando rápidamente como la biblioteca elegida para crear interfaces de usuario basadas en componentes.

Tanto React como D3 son dos excelentes herramientas diseñadas con objetivos que a veces chocan. Ambos toman el control de los elementos de la interfaz de usuario y lo hacen de diferentes maneras. ¿Cómo podemos hacer que trabajen juntos mientras optimizamos sus distintas ventajas de acuerdo con su proyecto actual?

En esta publicación, veremos cómo podemos abordar la construcción de proyectos de React que necesitan la poderosa bondad de gráficos de D3. Descubriremos diferentes técnicas y cómo elegir la mejor biblioteca para sus necesidades en su trabajo principal y proyectos paralelos.

D3 y el DOM

El D3 en D3.js significa documentos basados ​​en datos. D3.js es una biblioteca de bajo nivel que proporciona los componentes básicos necesarios para crear visualizaciones interactivas. Utiliza estándares web como SVG, HTML, lienzo y CSS para ensamblar una caja de herramientas de interfaz con una amplia API y un control casi ilimitado sobre la apariencia y el comportamiento de las visualizaciones. También proporciona varias funciones matemáticas que ayudan a los usuarios a calcular rutas SVG complejas.

¿Como funciona?

En pocas palabras, D3.js carga datos y los adjunta al DOM. Luego, vincula esos datos a elementos DOM y transforma esos elementos, realizando transiciones entre estados si es necesario.

Las selecciones de D3.js son similares a los objetos jQuery porque nos ayudan a lidiar con la complejidad de SVG. La forma en que se hace esto es comparable a la forma en que jQuery trata con elementos HTML DOM. Ambas bibliotecas también comparten una API basada en cadena similar y el uso del DOM como almacenamiento de datos.

Uniones de datos

Las uniones de datos, como se explica en el artículo de Mike Bostocks " Pensar con uniones ", son el proceso mediante el cual D3 vincula datos a elementos DOM mediante el uso de selecciones.

Las uniones de datos nos ayudan a hacer coincidir los datos que proporcionamos con elementos ya creados, agregar elementos que faltan y eliminar elementos que ya no son necesarios. Utilizan selecciones de D3.js que, cuando se combinan con datos, dividen los elementos seleccionados en tres grupos diferentes: elementos que deben crearse (el grupo de entrada), elementos que deben actualizarse (el grupo de actualización) y elementos que necesitan que se eliminará (el grupo de salida).

En la práctica, un objeto JavaScript con dos matrices representa una unión de datos. Podemos activar operaciones en los grupos de entrada y salida llamando a los métodos de entrada y salida de la selección, mientras que podemos operar directamente en el grupo de actualización en la última versión de D3.js.

Como lo describe Bostock, con las uniones de datos, "puede visualizar datos en tiempo real, permitir la exploración interactiva y realizar una transición fluida entre conjuntos de datos". Son efectivamente un algoritmo de diferenciación, similar a la forma en que React gestiona la representación de elementos secundarios, como veremos en las siguientes secciones.

Bibliotecas D3

La comunidad D3 no ha encontrado una forma estándar de crear componentes a partir de código D3, lo cual es una necesidad frecuente porque D3.js tiene un nivel notablemente bajo. Podríamos decir que existen casi tantos patrones de encapsulación como bibliotecas basadas en D3, aunque voy a clasificarlas -a través de su API- en cuatro grupos: orientadas a objetos, declarativas, funcionales y encadenadas (o tipo D3).

Investigué un poco sobre el ecosistema D3.js y seleccioné un subconjunto pequeño y de alta calidad. Son bibliotecas actualizadas con D3.js versión 4 y con buena cobertura de pruebas. Se diferencian en el tipo de API y la granularidad de sus abstracciones.

 

Trazable

Plottable es una popular biblioteca de gráficos orientada a objetos que presenta una baja granularidad; por lo tanto, necesitamos configurar ejes, escalas y gráficos manualmente para componer gráficos. Puedes ver un ejemplo aquí .

(Fuente de la imagen: Trazable )

Cartelera

Billboard es un fork de la famosa biblioteca C3.js , actualizado con compatibilidad con D3.js versión 4 y destinado a darle continuidad a esta biblioteca clásica. Está escrito utilizando ECMAScript 6 y nuevas herramientas modernas como Webpack. Su API se basa en objetos de configuración pasados ​​a gráficos, por lo que podríamos decir que es una API declarativa.

(Fuente de la imagen: cartelera )

vega

Vega lleva la ruta declarativa un poco más allá, evolucionando las configuraciones de objetos JavaScript a archivos JSON puros. Su objetivo es implementar una gramática de visualización inspirada en The Grammar of Graphics , un libro de Leland Wilkinson que formaliza los componentes básicos de las visualizaciones de datos y que también fue una inspiración para D3.js. Puedes jugar con su editor , seleccionando uno de los ejemplos como punto de partida.

(Fuente de la imagen: Vega )

D3FC

D3FC utiliza D3.js y bloques de construcción personalizados para ayudarle a crear potentes gráficos interactivos tanto en SVG como en lienzo. Cuenta con una interfaz funcional de baja granularidad y una gran cantidad de código D3.js, por lo que, aunque es potente, probablemente requiera algo de aprendizaje. Mira sus ejemplos .

(Fuente de la imagen: D3FC )

britecharts

Britecharts , una biblioteca creada por Eventbrite, de la cual soy colaborador principal, utiliza la API de gráficos reutilizables, un patrón de encapsulación popularizado por Mike Bostock en su publicación " Hacia gráficos reutilizables " y empleado en otras bibliotecas como NVD3 . Britecharts crea una abstracción de alto nivel, lo que facilita la creación de gráficos, manteniendo al mismo tiempo una baja complejidad interna, lo que permite a los desarrolladores de D3 personalizar Britecharts para su uso. Dedicamos mucho tiempo a crear una interfaz de usuario pulida y muchas demostraciones accesibles.

(Fuente de la imagen: Britecharts )

Resumiendo las bibliotecas por sus API, podríamos representarlas así:

Reaccionar y el DOM

React es una biblioteca de JavaScript que nos ayuda a construir interfaces de usuario componiendo componentes . Estos componentes realizan un seguimiento de su estado y pasan propiedades para volver a renderizarse de manera efectiva, optimizando el rendimiento de la aplicación.

¿Como funciona?

El DOM virtual , que es una representación del estado actual del DOM, es la tecnología que permite las optimizaciones de renderizado de React. La biblioteca utiliza un algoritmo de diferenciación complejo para comprender qué partes de la aplicación deben volver a renderizarse cuando cambian las condiciones. Este algoritmo de diferenciación se denomina " algoritmo de reconciliación ".

 

Componentes secundarios dinámicos

Al renderizar componentes que contienen una lista de elementos, los desarrolladores deben utilizar una propiedad "clave" única adjunta a los componentes secundarios. Este valor ayuda al algoritmo de diferenciación a determinar si es necesario volver a representar el elemento cuando se pasan nuevos datos (o estado, como se llama en el mundo React) al componente. El algoritmo de conciliación verifica los valores de las claves para ver si es necesario agregar o eliminar el elemento. ¿Le resulta familiar esto después de conocer las uniones de datos de D3.js?

Desde la versión 0.14, React también mantiene el renderizador en un módulo separado. De esta manera, podemos usar los mismos componentes para renderizar en diferentes medios, como aplicaciones nativas ( React Native ), realidad virtual ( React VR ) y el DOM ( react-dom ). Esta flexibilidad es similar a la forma en que el código D3.js se puede representar en diferentes contextos, como SVG y lienzo.

Reaccionar y D3.js

Tanto React como D3 comparten el objetivo de ayudarnos a lidiar con el DOM y su complejidad de una manera altamente optimizada. También comparten una preferencia por las funciones puras (código que, para una entrada determinada, siempre devuelve el mismo resultado sin incurrir en efectos secundarios) y los componentes sin estado.

Sin embargo, la preocupación compartida sobre el DOM hace que estas dos bibliotecas obstinadas entren en conflicto al determinar cuál debe representar y animar los elementos de la interfaz de usuario. Vamos a ver diferentes formas de solucionar esta disputa, y que no hay una respuesta fácil. Sin embargo, podríamos establecer una regla estricta: nunca deberían compartir el control DOM . Esa sería una receta para el desastre.

Enfoques

Al integrar React y D3.js, podemos hacerlo en diferentes niveles, inclinándonos más por el lado de D3.js o el lado de React. Veamos nuestras cuatro opciones principales.

D3.js dentro de reaccionar

El primer enfoque que podemos seguir es darle a nuestro código D3 tanto control DOM como sea posible. Emplea un componente React para representar un elemento SVG vacío que funciona como elemento raíz de nuestra visualización de datos. Luego usa el componentDidUpdatemétodo del ciclo de vida para, usando ese elemento raíz, crear el gráfico usando el código D3.js que emplearíamos en un escenario básico de JavaScript. También podríamos bloquear cualquier actualización adicional de componentes haciendo que el shouldComponentUpdatemétodo regrese siempre false.

class Line extends React.Component { static propTypes = {...} componentDidMount() { // D3 Code to create the chart // using this._rootNode as container } shouldComponentUpdate() { // Prevents component re-rendering return false; } _setRef(componentNode) { this._rootNode = componentNode; } render() { div className="line-container" ref={this._setRef.bind(this)} / }}

Al evaluar este enfoque, reconocemos que ofrece algunos beneficios e inconvenientes. Entre los beneficios, se trata de una solución sencilla que funciona bien la mayor parte del tiempo. También es la solución más natural cuando se traslada código existente a React o cuando se utilizan gráficos D3.js que ya estaban funcionando en otro lugar.

 

En el lado negativo, mezclar código React y código D3.js dentro de un componente React podría verse como un poco asqueroso, incorporando demasiadas dependencias y haciendo que el archivo sea demasiado largo para ser considerado código de calidad. Además, esta implementación no parece en absoluto idiomática de React. Por último, debido a que el servidor de renderizado de React no llama al componentDidUpdatemétodo, no podemos enviar una versión renderizada del gráfico en el HTML inicial.

Reaccionar DOM falso

Implementado por Oliver Caldwell, React Faux DOM "es una forma de utilizar herramientas D3 existentes pero renderizarlas a través de React en el espíritu de React". Utiliza una implementación DOM falsa para engañar a D3.js haciéndole creer que se trata de un DOM real. De esta manera, mantenemos el árbol DOM de React mientras usamos D3.js en, casi, todo su potencial.

import {withFauxDOM} from 'react-faux-dom'class Line extends React.Component { static propTypes = {...} componentDidMount() { const faux = this.props.connectFauxDOM('div', 'chart'); // D3 Code to create the chart // using faux as container d3.select(faux) .append('svg') {...} } render() { div className="line-container" {this.props.chart} /div }}export default withFauxDOM(Line);

Una ventaja de este enfoque es que le permite utilizar la mayoría de las API de D3.js, lo que facilita la integración con el código D3.js ya creado. También permite la renderización del lado del servidor. Una desventaja de esta estrategia es que tiene menos rendimiento, porque estamos colocando otra implementación de DOM falsa antes del DOM virtual de React, virtualizando el DOM dos veces. Este problema limita su uso a visualizaciones de datos pequeñas y medianas.

Envoltura de métodos de ciclo de vida

Este enfoque, expuesto por primera vez por Nicolas Hery , utiliza los métodos de ciclo de vida presentes en los componentes de React basados ​​en clases. Envuelve elegantemente la creación, actualización y eliminación de gráficos D3.js, estableciendo un límite claro entre el código React y D3.js.

import D3Line from './D3Line'class Line extends React.Component { static propTypes = {...} componentDidMount() { // D3 Code to create the chart this._chart = D3Line.create( this._rootNode, this.props.data, this.props.config ); } componentDidUpdate() { // D3 Code to update the chart D3Line.update( this._rootNode, this.props.data, this.props.config, this._chart ); } componentWillUnmount() { D3Line.destroy(this._rootNode); } _setRef(componentNode) { this._rootNode = componentNode; } render() { div className="line-container" ref={this._setRef.bind(this)} / }}

El D3Line es algo como esto: Código P0300: Solución y Causas | Actualizado 2023

const D3Line = {};D3Line.create = (el, data, configuration) = { // D3 Code to create the chart};D3Line.update = (el, data, configuration, chart) = { // D3 Code to update the chart};D3Line.destroy = () = { // Cleaning code here};export default D3Line;

Codificar de esta manera produce un componente React liviano que se comunica con una instancia de gráfico basada en D3.js a través de una API simple (crear, actualizar y eliminar), empujando hacia abajo cualquier método de devolución de llamada que queramos escuchar.

 

Esta estrategia promueve una clara separación de preocupaciones, utilizando una fachada para ocultar los detalles de implementación del gráfico. Podría encapsular cualquier gráfico y la interfaz generada es simple. Otro beneficio es que es fácil de integrar con cualquier código D3.js ya escrito y nos permite utilizar las excelentes transiciones de D3.js. El principal inconveniente de este método es que no es posible la renderización del lado del servidor.

Reaccionar para el DOM, D3 para matemáticas

En esta estrategia, limitamos el uso de D3.js al mínimo. Esto significa realizar cálculos para rutas, escalas, diseños y cualquier transformación de SVG que tome datos del usuario y los transforme en algo que podamos dibujar con React.

Usar D3.js solo para matemáticas es posible gracias a una gran cantidad de submódulos de D3.js que no se relacionan con el DOM. Esta ruta es la más compatible con React y le da a la biblioteca de Facebook control total sobre el DOM, algo que hace notablemente bien.

Veamos un ejemplo simplificado:

class Line extends React.Component { static propTypes = {...} drawLine() { let xScale = d3.scaleTime() .domain(d3.extent(this.props.data, ({date}) = date)); .rangeRound([0, this.props.width]); let yScale = d3.scaleLinear() .domain(d3.extent(this.props.data, ({value}) = value)) .rangeRound([this.props.height, 0]); let line = d3.line() .x((d) = xScale(d.date)) .y((d) = yScale(d.value)); return ( path className="line" d={line(this.props.data)} / ); } render() { svg className="line-container" width={this.props.width} height={this.props.height} {this.drawLine()} /svg }}

Esta técnica es la favorita de los desarrolladores experimentados de React porque es consistente con la forma de React. Además, una vez implementado, crear gráficos con su código es fantástico. Otro beneficio sería el renderizado en el lado del servidor y posiblemente React Native o React VR.

Paradójicamente, este es el enfoque que requiere más conocimiento sobre cómo funciona D3.js, porque necesitamos integrarnos con sus submódulos en un nivel bajo. Debemos volver a implementar algunas funciones de D3.js (los ejes y las formas son los más comunes); Los pinceles, los zooms y el arrastre son probablemente los más difíciles, y esto implica una cantidad significativa de trabajo inicial.

También necesitaríamos implementar todas las animaciones. Tenemos excelentes herramientas en el ecosistema React que nos permiten administrar animaciones (ver reaccionar-transition-group , reaccionar-moción y reaccionar-move ), aunque ninguna de ellas nos permite crear interpolaciones complejas de rutas SVG. Una pregunta pendiente sería cómo se puede aprovechar este enfoque para representar gráficos utilizando el elemento canvas de HTML5.

 

En el siguiente diagrama podemos ver todos los enfoques descritos según el nivel de integración tanto con React como con D3.js:

Bibliotecas React-D3.js

He investigado un poco sobre las bibliotecas D3.js-React que espero le ayuden cuando se enfrente a la decisión de elegir una biblioteca con la que trabajar, contribuir o bifurcar. Contiene algunas métricas subjetivas, así que tómelo con cautela.

Esta investigación reveló que, aunque hay muchas bibliotecas, no muchas de ellas reciben mantenimiento. Como mantenedor, puedo entender lo difícil que es mantenerse al día con los cambios en una biblioteca importante y cómo tener que cuidar dos sería una tarea desalentadora.

Además, la cantidad de bibliotecas listas para producción (desde la versión 1.0.0 en adelante) sigue siendo bastante baja. Probablemente tenga que ver con la cantidad de trabajo necesario para enviar una biblioteca de este tipo.

Veamos algunos de mis favoritos.

Victoria

Victory , un proyecto de la empresa consultora Formidable Labs, es una biblioteca de componentes de bajo nivel de elementos gráficos. Debido a esa característica de bajo nivel, los componentes Victory se pueden combinar con diferentes configuraciones para crear visualizaciones de datos complejas. Debajo del capó, vuelve a implementar características de D3.js como el pincel y el zoom, aunque usa interpolación d3 para animaciones.

(Fuente de la imagen: Victoria )

Usarlo para un gráfico de líneas se vería así:

class LineChart extends React.Component { render() { return ( VictoryChart height={400} width={400} containerComponent={VictoryVoronoiContainer/} VictoryGroup labels={(d) = `y: ${d.y}`} labelComponent={ VictoryTooltip style={{ fontSize: 10 }} / } data={data} VictoryLine/ VictoryScatter size={(d, a) = {return a ? 8 : 3;}} / /VictoryGroup /VictoryChart ); }}

Eso produce un gráfico de líneas como este:

Comenzar con Victory es fácil y tiene algunas bonificaciones interesantes, como el zoom y el contenedor Voronoi para información sobre herramientas. Es una biblioteca de moda, aunque todavía se encuentra en estado de prelanzamiento y tiene una gran cantidad de errores pendientes. Victory es la única biblioteca en este momento que puedes usar con React Native .

Informes

Estéticamente pulida, con una experiencia de usuario agradable, animaciones fluidas y una información sobre herramientas de excelente apariencia, Recharts es una de mis bibliotecas React-D3.js favoritas. Recharts solo utiliza escala d3, interpolación d3 y forma d3. Ofrece un mayor nivel de granularidad que Victory, lo que limita la cantidad de visualizaciones de datos que podemos componer.

(Fuente de la imagen: Recarts )

El uso de Recharts se ve así:

class LineChart extends React.Component { render () { return ( LineChart width={600} height={300} data={data} margin={{top: 5, right: 30, left: 20, bottom: 5}} XAxis dataKey="name"/ YAxis/ CartesianGrid strokeDasharray="3 3"/ Tooltip/ Legend / Line type="monotone" dataKey="pv" stroke="#8884d8" activeDot={{r: 8}}/ Line type="monotone" dataKey="uv" stroke="#82ca9d" / /LineChart ); }}

Esta biblioteca también está muy bien probada y, aunque todavía está en versión beta, presenta algunos de los gráficos habituales, un gráfico de radar, mapas de árbol e incluso pinceles. Puedes consultar sus ejemplos para ver más. Los desarrolladores que contribuyeron a este proyecto trabajaron seriamente y lograron animaciones fluidas con su proyecto de animación reaccionar-smooth .

 

nivo

Nivo es una biblioteca de gráficos React-D3.js de alto nivel. Ofrece muchas opciones de renderizado: SVG, lienzo e incluso una versión HTML de los gráficos basada en API que es ideal para el renderizado del lado del servidor. Utiliza React Motion para animaciones.

(Fuente de la imagen: Nivo )

Su API es un poco diferente porque revela solo un componente configurable para cada gráfico. Veamos un ejemplo:

class LineChart extends React.Component { render () { return ( ResponsiveLine data={data} margin={{ "top": 50, "right": 110, "bottom": 50, "left": 60 }} minY="auto" stacked={true} axisBottom={{ "orient": "bottom", "tickSize": 5, "tickPadding": 5, "tickRotation": 0, "legend": "country code", "legendOffset": 36, "legendPosition": "center" }} axisLeft={{ "orient": "left", "tickSize": 5, "tickPadding": 5, "tickRotation": 0, "legend": "count", "legendOffset": -40, "legendPosition": "center" }} dotSize={10} dotColor="inherit:darker(0.3)" dotBorderWidth={2} dotBorderColor="#ffffff" enableDotLabel={true} dotLabel="y" dotLabelYOffset={-12} animate={true} motionStiffness={90} motionDamping={15} legends={[ { "anchor": "bottom-right", "direction": "column", "translateX": 100, "itemWidth": 80, "itemHeight": 20, "symbolSize": 12, "symbolShape": "circle" } ]} / ); }}

Raphael Benitte hizo un trabajo asombroso con Nivo. La documentación es encantadora y sus demostraciones configurables. Debido al mayor nivel de abstracción de esta biblioteca, es súper sencilla de usar y podríamos decir que ofrece menos potencial para la creación de visualizaciones. Una característica interesante de Nivo es la posibilidad de utilizar patrones y degradados SVG para completar sus gráficos.

 

VX

VX es una colección de componentes de visualización de bajo nivel para crear visualizaciones. No tiene opiniones y se supone que debe usarse para producir otras bibliotecas de gráficos o tal como está.

(Fuente de la imagen: VX )

Veamos algo de código:

class VXLineChart extends React.Component { render () { let {width, height, margin} = this.props; // bounds const xMax = width - margin.left - margin.right; const yMax = height - margin.top - margin.bottom; // scales const xScale = scaleTime({ range: [0, xMax], domain: extent(data, x), }); const yScale = scaleLinear({ range: [yMax, 0], domain: [0, max(data, y)], nice: true, }); return ( svg width={width} height={height} rect x={0} y={0} width={width} height={height} fill="white" rx={14} / Group top={margin.top} LinePath data={data} xScale={xScale} yScale={yScale} x={x} y={y} stroke='#32deaa' strokeWidth={2} / /Group /svg ); }};

Dada esta granularidad de bajo nivel, pienso en VX como un D3.js para el mundo React. Es independiente de la biblioteca de animaciones que el usuario quiera utilizar. En este momento, todavía se encuentra en la fase beta inicial, aunque Airbnb lo está utilizando en producción. Sus déficits en este momento son la falta de soporte para interacciones como cepillar y hacer zoom.

Britecharts reacciona

Britecharts React todavía está en versión beta y es la única de estas bibliotecas que utiliza el enfoque de ajuste del método del ciclo de vida. Su objetivo es permitir el uso de visualizaciones de Britecharts en React mediante la creación de un contenedor de código fácil de usar.

(Fuente de la imagen: Britecharts React )

Aquí hay un código simple para un gráfico de líneas:

class LineChart extends React.Component { render () { const margin = { top: 60, right: 30, bottom: 60, left: 70, }; return ( TooltipComponent data={lineData.oneSet()} topicLabel="topics" render={(props) = ( LineComponent margin={margin} lineCurve="basis" {...props} / )} / ); }}

I can’t be objective about this one. Britecharts React could be used as scaffold to render your D3.js charts as React components. It doesn’t support server-side rendering, although we have included loading states to overcome this in some way.

Feel free to check the online demos and play with the code.

Choosing An Approach Or Library

I have grouped the considerations in building applications with charts into four categories: quality, time, scope and cost. They are too many, so we should simplify.

Let’s say we fix quality. We could aim to have a code base that is well tested, up to date with D3.js version 4 and with comprehensive documentation.

If we think about time, a useful question to ask ourselves is, “Is this a long-term investment?” If the response is “yes,” then I would advise you to create a library based on D3.js and wrap it with React using the lifecycle methods approach. This approach separates our code by technologies and is more time-resistant.

If, on the contrary, the project has tight deadlines and the team does not need to maintain it for a long time, I would advise grabbing the React-D3.js or D3.js library closest to the specifications, fork it and use it, trying to contribute along the way.

When we deal with scope, we should think of whether what we need is a small number of basic charts, a one-off complex visualization or several highly customized graphics. In the first case, I would again choose the closest library to the specifications and fork it. For bespoke data visualizations that






Tal vez te puede interesar:

  1. ¿Deberían abrirse los enlaces en ventanas nuevas?
  2. 24 excelentes tutoriales de AJAX
  3. 70 técnicas nuevas y útiles de AJAX y JavaScript
  4. Más de 45 excelentes recursos y repositorios de fragmentos de código

Reuniendo a React, D3 y su ecosistema

Reuniendo a React, D3 y su ecosistema

Índice D3 y el DOM ¿Como funciona?

programar

es

https://pseint.es/static/images/programar-reuniendo-a-react-918-0.jpg

2024-04-04

 

Reuniendo a React, D3 y su ecosistema
Reuniendo a React, D3 y su ecosistema

Si crees que alguno de los contenidos (texto, imagenes o multimedia) en esta página infringe tus derechos relativos a propiedad intelectual, marcas registradas o cualquier otro de tus derechos, por favor ponte en contacto con nosotros en el mail [email protected] y retiraremos este contenido inmediatamente

 

 

Top 20