En un tutorial anterior, explicamos cómo dibujar un gráfico circular o un gráfico de anillos usando un lienzo HTML5. En este tutorial, le mostraré cómo usar JavaScript y el lienzo HTML5 como un medio para mostrar gráficamente los datos mediante gráficos de barras..
Hay formas más fáciles de crear gráficos que codificando uno desde cero, por ejemplo, esta completa biblioteca de gráficos de CodeCanyon.
Biblioteca de gráficos infográficos de CodeCanyonPero si desea saber qué se necesita para crear una biblioteca como esta, este tutorial es para usted..
Los gráficos de barras son herramientas muy comunes que se utilizan para representar datos numéricos. Desde los informes financieros hasta las presentaciones de PowerPoint y las infografías, los gráficos de barras se utilizan con mucha frecuencia, ya que ofrecen una vista de datos numéricos que es muy fácil de entender..
Los gráficos de barras representan datos numéricos utilizando barras, que son rectángulos con sus anchos o alturas proporcionales a los datos numéricos que representan.
Hay muchos tipos de gráficos de barras:
Echemos un vistazo a los componentes que forman un gráfico de barras independientemente de su tipo:
Ahora que conocemos los componentes de un gráfico de barras, veamos cómo podemos escribir el código JavaScript para dibujar un gráfico como este.
Para comenzar a dibujar usando JavaScript y el lienzo HTML5, necesitaremos configurar nuestro proyecto de esta manera:
gráfico de barras-tutorial
.index.html
. Esto contendrá nuestro código HTML.script.js
. Esto contendrá el código JavaScript para dibujar el gráfico de barras.Mantendremos las cosas muy simples y agregaremos el siguiente código dentro index.html
:
Tenemos el elemento con el ID
myCanvas
para que podamos referenciarlo en nuestro código JS. Luego cargamos el código JS a través de tag.
Add the following code in the script.js
file:
var myCanvas = document.getElementById("myCanvas"); myCanvas.width = 300; myCanvas.height = 300; var ctx = myCanvas.getContext("2d");
This gets a reference to the canvas element and then sets the width and height to 300px
. To draw on the canvas, we only need a reference to its 2D context, which contains all the drawing methods.
Drawing the bar chart only requires knowing how to draw two elements:
Let's create the helper JS functions for these two elements. We will add the functions in our script.js
file.
function drawLine(ctx, startX, startY, endX, endY,color) ctx.save(); ctx.strokeStyle = color; ctx.beginPath(); ctx.moveTo(startX,startY); ctx.lineTo(endX,endY); ctx.stroke(); ctx.restore();
The drawLine
function takes six parameters:
ctx
: reference to the drawing contextstartX
: the X coordinate of the line starting pointstartY
: the Y coordinate of the line starting pointendX
: the X coordinate of the line end pointendY
: the Y coordinate of the line end pointcolor
: the color of the lineWe are modifying the color settings for the strokeStyle
. This determines the color used to draw the line. We use ctx.save()
and ctx.restore()
so that we don't affect the colors used outside this function.
We draw the line by calling beginPath()
. This informs the drawing context that we are starting to draw something new on the canvas. We use moveTo()
to set the starting point, call lineTo()
to indicate the end point, and then do the actual drawing by calling stroke()
.
Another helper function that we need is a function to draw a bar-which is a color-filled rectangle. Let's add it to script.js
:
function drawBar(ctx, upperLeftCornerX, upperLeftCornerY, width, height,color) ctx.save(); ctx.fillStyle=color; ctx.fillRect(upperLeftCornerX,upperLeftCornerY,width,height); ctx.restore();
The drawBar
function takes six parameters:
ctx
: reference to the drawing contextupperLeftCornerX
: the X coordinate of the bar's upper left cornerupperLeftCornerY
: the X coordinate of the bar's upper left cornerwidth
: the width of the barheight
: the height of the barcolor
: the color of the barNow that we have the helper functions in place, let's move on to the chart's data model. All types of chart, including bar charts, have a data model behind them. The data model is a structured set of numerical data. For this tutorial we will use a data series of categories and their associated numerical values representing the number of vinyl records in my collection of records grouped by music genre:
We can represent this in JavaScript in the form of an object. Let's add it to our script.js
file:
var myVinyls = "Classical music": 10, "Alternative rock": 14, "Pop": 2, "Jazz": 12 ;
Let's implement the component that will do the actual drawing of our bar chart. We will do this by adding the following JavaScript object to our script.js
file:
var Barchart = function(options) this.options = options; this.canvas = options.canvas; this.ctx = this.canvas.getContext("2d"); this.colors = options.colors; this.draw = function() var maxValue = 0; for (var categ in this.options.data) maxValue = Math.max(maxValue,this.options.data[categ]); var canvasActualHeight = this.canvas.height - this.options.padding * 2; var canvasActualWidth = this.canvas.width - this.options.padding * 2; //drawing the grid lines var gridValue = 0; while (gridValue <= maxValue) var gridY = canvasActualHeight * (1 - gridValue/maxValue) + this.options.padding; drawLine( this.ctx, 0, gridY, this.canvas.width, gridY, this.options.gridColor ); //writing grid markers this.ctx.save(); this.ctx.fillStyle = this.options.gridColor; this.ctx.font = "bold 10px Arial"; this.ctx.fillText(gridValue, 10,gridY - 2); this.ctx.restore(); gridValue+=this.options.gridScale; //drawing the bars var barIndex = 0; var numberOfBars = Object.keys(this.options.data).length; var barSize = (canvasActualWidth)/numberOfBars; for (categ in this.options.data) var val = this.options.data[categ]; var barHeight = Math.round( canvasActualHeight * val/maxValue) ; drawBar( this.ctx, this.options.padding + barIndex * barSize, this.canvas.height - barHeight - this.options.padding, barSize, barHeight, this.colors[barIndex%this.colors.length] ); barIndex++;
The class starts by storing the options
passed as parameters. It stores the canvas
reference and creates a drawing context also stored as a class member. Then it stores the colors
array passed as options.
The next part is the most consistent, the draw()
function. This will draw the chart by first drawing the grid lines, the grid markers and then the bars using the parameters passed via the options
object.
Looking at the draw()
function, we can see that first we calculate the maximum value for our data model. We need this number because we will need to scale all the bars according to this value and according to the size of the canvas. Otherwise, our bars might go outside the display area, and we don't want that.
The canvasActualHeight
and canvasActualWidth
variables store the height and width of the canvas adjusted using the value of the padding passed via options
. The padding
variable indicates the number of pixels between the edge of the canvas and the chart inside.
We then draw the grid lines of the chart. The options.gridScale
variable sets the step used for drawing the lines. So a gridScale
of 10 will mean drawing grid lines every 10 units.
To draw the grid lines, we use the helper function drawLine()
; as for the color of the grid lines, we take it from the options.gridColor
variable. Please note that the canvas coordinates start from 0,0
in the top left corner and increase towards the right and bottom, while our grid values increase in value from the bottom towards the top. That is why we used 1 - gridValue/maxValue
in the formula calculating the gridY
value.
For every grid line, we also draw the value of the grid line 2 pixels above the grid line (that's why we have gridY - 2
for the Y coordinates of the text).
Next we draw the bars by using the helper function drawBar()
. The math for calculating the height and width of each bar is pretty straightforward; it takes into account the padding and the value and color for each category in the chart's data model.
Let's now see how to use the Barchart
class implemented above. We need to instantiate the class and call the draw()
function. Add the following code to the script.js
file:
var myBarchart = new Barchart( canvas:myCanvas, padding:10, gridScale:5, gridColor:"#eeeeee", data:myVinyls, colors:["#a55ca5","#67b6c7", "#bccd7a","#eb9743"] ); myBarchart.draw();
The code creates a new instance of the Barchart
class with the required options. Loading the index.html
in a browser should produce a result like this:
To add the data series name below the chart, we need to add the following code in the script.js
file after the for-loop
that draws the bar:
… //drawing series name this.ctx.save(); this.ctx.textBaseline="bottom"; this.ctx.textAlign="center"; this.ctx.fillStyle = "#000000"; this.ctx.font = "bold 14px Arial"; this.ctx.fillText(this.options.seriesName, this.canvas.width/2,this.canvas.height); this.ctx.restore();…
We also need to change the way we call the Barchart
component like this:
var myBarchart = new Barchart( canvas:myCanvas, seriesName:"Vinyl records", padding:20, gridScale:5, gridColor:"#eeeeee", data:myVinyls, colors:["#a55ca5","#67b6c7", "#bccd7a","#eb9743"] ); myBarchart.draw();
And here is how the result looks:
To add the legend, we first need to modify index.html
to look like this:
los leyenda
La etiqueta se usará como un marcador de posición para la leyenda del gráfico. los para
el atributo vincula la leyenda al lienzo que contiene el gráfico. Ahora necesitamos agregar el código que crea la leyenda. Haremos esto en el index.js
Archivo después del código que dibuja el nombre de la serie de datos. El código identifica la leyenda
etiqueta correspondiente al gráfico, y agregará la lista de categorías del modelo de datos del gráfico junto con el color correspondiente. La resultante index.js
archivo se verá así:
var myCanvas = document.getElementById ("myCanvas"); myCanvas.width = 300; myCanvas.height = 300; var ctx = myCanvas.getContext ("2d"); función drawLine (ctx, startX, startY, endX, endY, color) ctx.save (); ctx.strokeStyle = color; ctx.beginPath (); ctx.moveTo (startX, startY); ctx.lineTo (endX, endY); ctx.stroke (); ctx.restore (); función drawBar (ctx, upperLeftCornerX, upperLeftCornerY, width, height, color) ctx.save (); ctx.fillStyle = color; ctx.fillRect (upperLeftCornerX, upperLeftCornerY, width, height); ctx.restore (); var myVinyls = "Música clásica": 10, "Rock alternativo": 14, "Pop": 2, "Jazz": 12; var Barchart = function (options) this.options = options; this.canvas = options.canvas; this.ctx = this.canvas.getContext ("2d"); this.colors = options.colors; this.draw = function () var maxValue = 0; para (var categ en this.options.data) maxValue = Math.max (maxValue, this.options.data [categ]); var canvasActualHeight = this.canvas.height - this.options.padding * 2; var canvasActualWidth = this.canvas.width - this.options.padding * 2; // dibujando las líneas de la cuadrícula var gridValue = 0; while (gridValue <= maxValue) var gridY = canvasActualHeight * (1 - gridValue/maxValue) + this.options.padding; drawLine( this.ctx, 0, gridY, this.canvas.width, gridY, this.options.gridColor ); //writing grid markers this.ctx.save(); this.ctx.fillStyle = this.options.gridColor; this.ctx.textBaseline="bottom"; this.ctx.font = "bold 10px Arial"; this.ctx.fillText(gridValue, 10,gridY - 2); this.ctx.restore(); gridValue+=this.options.gridScale; //drawing the bars var barIndex = 0; var numberOfBars = Object.keys(this.options.data).length; var barSize = (canvasActualWidth)/numberOfBars; for (categ in this.options.data) var val = this.options.data[categ]; var barHeight = Math.round( canvasActualHeight * val/maxValue) ; drawBar( this.ctx, this.options.padding + barIndex * barSize, this.canvas.height - barHeight - this.options.padding, barSize, barHeight, this.colors[barIndex%this.colors.length] ); barIndex++; //drawing series name this.ctx.save(); this.ctx.textBaseline="bottom"; this.ctx.textAlign="center"; this.ctx.fillStyle = "#000000"; this.ctx.font = "bold 14px Arial"; this.ctx.fillText(this.options.seriesName, this.canvas.width/2,this.canvas.height); this.ctx.restore(); //draw legend barIndex = 0; var legend = document.querySelector("legend[for='myCanvas']"); var ul = document.createElement("ul"); legend.append(ul); for (categ in this.options.data) var li = document.createElement("li"); li.style.listStyle = "none"; li.style.borderLeft = "20px solid "+this.colors[barIndex%this.colors.length]; li.style.padding = "5px"; li.textContent = categ; ul.append(li); barIndex++; var myBarchart = new Barchart( canvas:myCanvas, seriesName:"Vinyl records", padding:20, gridScale:5, gridColor:"#eeeeee", data:myVinyls, colors:["#a55ca5","#67b6c7", "#bccd7a","#eb9743"] );
Lo que producirá un resultado final con este aspecto:
Hemos visto que dibujar gráficos utilizando el lienzo HTML5 no es realmente tan difícil. Solo requiere un poco de matemática y un poco de conocimiento de JavaScript. Ahora tiene todo lo que necesita para dibujar sus propios gráficos de barras..
Si desea una solución rápida y fácil para crear no solo gráficos de barras, sino también muchos otros tipos de gráficos, puede descargar la Biblioteca de etiquetas HTML de gráficos infográficos y sus complementos del complemento de WordPress Gráficos y tablas de WordPress.
Biblioteca de gráficos infográficos de CodeCanyon