


In this tutorial, I will show you how to use JavaScript and the canvas to display numerical information in the form of pie charts and doughnut charts.
A chart is a statistical tool used to graphically represent numerical data. A pie chart displays that numerical data as a circle divided into slices. The size of each slice is proportional to the numeric value that it stands for.
To put it simply, a doughnut chart is a variation on a pie chart. The difference is that the slices are cut towards the center of the pie such that only the rim is visible. In this way, the chart looks like a doughnut, hence the name.
Before drawing the pie chart, we will take a look at drawing its parts. We will see how we can use the canvas component and JavaScript to draw:
To start drawing using the HTML5 canvas, we'll need to create a few things:
We'll keep things very simple and add the following code inside index.html:
<html>
<body>
<canvas id="myCanvas"></canvas>
<script type="text/javascript" src="script.js"></script>
</body>
</html>
We have the <canvas> element with the ID myCanvas so that we can reference it in our JS code. We then load the JS code via the <script> tag.
Inside script.js, the JS code will first get a reference to the canvas and then set its width and height. To draw on the canvas, we only need a reference to its 2D context, which contains all the drawing methods.
var myCanvas = document.getElementById("myCanvas");
myCanvas.width = 300;
myCanvas.height = 300;
var ctx = myCanvas.getContext("2d");
Now that we have the canvas set up and also a reference to the drawing canvas, let's define a few JavaScript functions that we will be able to reuse when drawing the pie chart. 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's starting pointstartY: the Y coordinate of the line's starting pointendX: the X coordinate of the line's end pointendY: the Y coordinate of the line's end pointcolor: the color of the lineThe first thing we do inside the function is save the current context. After that, we start drawing 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().
Let's now see how we can draw a part of a circle, also called an arc.
function drawArc(ctx, centerX, centerY, radius, startAngle, endAngle, color){
ctx.save();
ctx.strokeStyle = color;
ctx.beginPath();
ctx.arc(centerX, centerY, radius, startAngle, endAngle);
ctx.stroke();
ctx.restore();
}
The drawArc function takes seven parameters:
ctx: reference to the drawing contextcenterX: the X coordinate of the circle's centercenterY: the Y coordinate of the circle's centerradius: the X coordinate of the line's end pointstartAngle: the start angle in radians where the portion of the circle startsendAngle: the end angle in radians where the portion of the circle endscolor: the color of the arcWe've seen how to draw a line and how to draw an arc, so now let's see how to draw a colored shape. Since our goal is to draw a pie chart that is made up of slices, let's create a function that draws a pie slice.
function drawPieSlice(ctx,centerX, centerY, radius, startAngle, endAngle, fillColor, strokeColor) {
ctx.save();
ctx.fillStyle = fillColor;
ctx.strokeStyle = strokeColor;
ctx.beginPath();
ctx.moveTo(centerX, centerY);
ctx.arc(centerX, centerY, radius, startAngle, endAngle, strokeColor);
ctx.closePath();
ctx.fill();
ctx.restore();
}
The drawPieSlice function takes seven parameters:
ctx: reference to the drawing contextcenterX: the X coordinate of the circle's centercenterY: the Y coordinate of the circle's centerradius: the X coordinate of the line's end pointstartAngle: the start angle in radians where the portion of the circle startsendAngle: the end angle in radians where the portion of the circle endsfillColor: the color used to fill the slicestrokeColor: the color used to draw the perimeter of the sliceHere is an example for calling three functions:
drawLine(ctx, 200, 200, 300, 300, "#000"); drawArc(ctx, 250, 250, 150, 0, Math.PI/3, "#000"); drawPieSlice(ctx, 250, 250, 150, Math.PI/2, Math.PI/2 + Math.PI/3, "#F00", "#000");
It will produce this result:
Now we have all the tools necessary to draw a pie chart, so let's see how we use them together.
Conceptually, any chart has two main parts:
The most common way to structure the data model for pie charts is a series of categories and corresponding values, where each category and value is associated with a slice of the pie.
As an example, the data model of a pie chart displaying the number of vinyls I have grouped by genre would look something like:
This data can be passed to our pie chart drawing class in the form of an object. We will be passing it to our PieChart object later:
{
"Classical Music": 16,
"Alternative Rock": 12,
"Pop": 18,
"Jazz": 32,
}
The pie chart uses a circle to display the information in the data model by dividing it into slices. Each slice corresponds to a category from the data model, and the size of the slice is proportional to the category value.
My small collection of 88 vinyls has four categories. Each category will get a slice of the pie chart proportional to the number of vinyls in that category.
But how do we measure the size of a slice? That's easy—we do that by the angle at the tip of the slice. All we have to know is that the full circle corresponds to an angle of 360 degrees or 2 * PI. So half a circle would be 180 deg or PI, a quarter 90 deg or PI/2, and so on.
To determine the angle for each category slice, we use the formula:
slice angle = 2 * PI * category value / total value
According to this formula, the 16 classical music vinyls will get a slice angle of approximately 0.36 * PI or 64.8 deg.
Let's get to drawing. For this, we will use a JavaScript class which we will name Piechart. The constructor will receive one options argument, an object containing the following:
canvas: reference to the canvas where we want to draw the pie chartdata: reference to an object holding the data modelcolors: an array holding the colors we want to use for each sliceseriesName: a string that holds the chart titlepadding: to tell us how much padding should be added to the chartdonutHoleSize: specifies the fraction that should be cut out of the pie chart.titleOptions: an object that contains information about the title's font, size, alignment, color, etc.The Piechart class also contains one method, draw(), which does the actual drawing of the chart.
var Piechart = function(options){
constructor(options) {
this.options = options;
this.canvas = options.canvas;
this.ctx = this.canvas.getContext("2d");
this.colors = options.colors;
this.titleOptions = options.titleOptions;
this.totalValue = [...Object.values(this.options.data)].reduce((a, b) => a + b, 0);
this.radius = Math.min(this.canvas.width / 2, this.canvas.height / 2) - options.padding;
}
drawSlices() {
var colorIndex = 0;
var startAngle = -Math.PI / 2;
for (var categ in this.options.data) {
var val = this.options.data[categ];
var sliceAngle = (2 * Math.PI * val) / this.totalValue;
drawPieSlice(
this.ctx,
this.canvas.width / 2,
this.canvas.height / 2,
this.radius,
startAngle,
startAngle + sliceAngle,
this.colors[colorIndex % this.colors.length]
);
startAngle += sliceAngle;
colorIndex++;
}
}
}
The class starts by storing the passed options in different properties inside the constructor() method. 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.
We convert our object values into an array inside the constructor and then use the reduce() method to get the total of all data points. This value is later used to calculate the angle of different slices. We also calculate the radius of our pie chart within the constructor method by taking the minimum value between half of the canvas width and half of the canvas height and then subtracting the padding. Subtracting the padding to calculate the radius helps introduce some space between different chart elements.
The drawSlices() method does all the actual drawing of the pie chart. For each category in the data model, we apply the formula mentioned above to calculate the pie slice angle. Finally, we use the drawPieSlice() function, using the center of the canvas as the center of the slice. We also offset the start and end angle of the slices each time we draw a category, otherwise the slices would overlap.
To use the class, we have to create an instance and then call the drawSlices() method on the created object.
var myPiechart = new Piechart(
{
canvas: myCanvas,
data: {
"Classical Music": 16,
"Alternative Rock": 12,
"Pop": 18,
"Jazz": 32
},
colors: ["#80DEEA", "#FFE082", "#FFAB91", "#CE93D8"]
}
);
myPiechart.drawSlices();
And the result looks like this:



We've seen how to draw the pie chart. We also know that a doughnut chart differs only by having a hole in the middle of the chart. How do we draw the hole? We can draw a white circle over the pie chart.
Let's modify the drawSlices() method of the Piechart class to do that.
drawSlices() {
var colorIndex = 0;
var startAngle = -Math.PI / 2;
for (var categ in this.options.data) {
var val = this.options.data[categ];
var sliceAngle = (2 * Math.PI * val) / this.totalValue;
drawPieSlice(
this.ctx,
this.canvas.width / 2,
this.canvas.height / 2,
this.radius,
startAngle,
startAngle + sliceAngle,
this.colors[colorIndex % this.colors.length]
);
startAngle += sliceAngle;
colorIndex++;
}
if (this.options.doughnutHoleSize) {
drawPieSlice(
this.ctx,
this.canvas.width / 2,
this.canvas.height / 2,
this.options.doughnutHoleSize * this.radius,
0,
2 * Math.PI,
"#FFF",
"#FFF"
);
drawArc(
this.ctx,
this.canvas.width / 2,
this.canvas.height / 2,
this.options.doughnutHoleSize * this.radius,
0,
2 * Math.PI,
"#000"
);
}
}
The added code looks in the options parameter for a member variable doughnutHoleSize. If this doesn't exist in the options, then the code will draw the pie chart as before, but if it does exist, then a white circle is drawn with the same center as the pie chart.
The radius of the circle is determined by multiplying the pie chart radius and the value of doughnutHoleSize. This should be a number between 0 and 1, where 0 will result in a pie chart, and any values higher than 0 would result in a doughnut with the hole larger and larger, 1 making the chart invisible.
To draw a doughnut chart with a hole half the size of the chart, we would need to use a doughnutHoleSize of 0.5 and make the following calls:
var myDougnutChart = new Piechart(
{
canvas:myCanvas,
data:myVinyls,
colors:["#fde23e","#f16e23", "#57d9ff","#937e88"],
doughnutHoleSize:0.5
}
);
myDougnutChart.drawSlices();
And here is the result:



Our pie chart and doughnut chart look pretty good, but we can make them even better by adding two things:
Usually, values associated with the slices are represented as percentage values calculated as 100 * value associated with a slice / total value, with the whole circle representing 100%.
For example, in the case of our sample data, vinyls with classical music would represent approximately 26%. It would be nice to be able to write that value right on the corresponding slice. To do that, we will use the fillText(text,x,y) function of the drawing context. This function takes three parameters: the text and the x and y coordinates.
How do we calculate the x and y coordinates at which to place the text? We have to make use of some geometry knowledge and something called polar coordinates. Basically, polar coordinates use a radius and an angle to define the position of a point. The two formulas we will use are:
x = R * cos(angle)
y = R * sin(angle)
We will apply these two formulas to place the text halfway along the pie chart radius and halfway around the angle for each pie slice. To do this, we need to add another method called drawLabels() to our Piechart class:
drawLabels() {
var colorIndex = 0;
var startAngle = -Math.PI / 2;
for (var categ in this.options.data) {
var val = this.options.data[categ];
var sliceAngle = (2 * Math.PI * val) / this.totalValue;
var labelX =
this.canvas.width / 2 +
(this.radius / 2) * Math.cos(startAngle + sliceAngle / 2);
var labelY =
this.canvas.height / 2 +
(this.radius / 2) * Math.sin(startAngle + sliceAngle / 2);
if (this.options.doughnutHoleSize) {
var offset = (this.radius * this.options.doughnutHoleSize) / 2;
labelX =
this.canvas.width / 2 +
(offset + this.radius / 2) * Math.cos(startAngle + sliceAngle / 2);
labelY =
this.canvas.height / 2 +
(offset + this.radius / 2) * Math.sin(startAngle + sliceAngle / 2);
}
var labelText = Math.round((100 * val) / this.totalValue);
this.ctx.fillStyle = "black";
this.ctx.font = "32px Khand";
this.ctx.fillText(labelText + "%", labelX, labelY);
startAngle += sliceAngle;
}
}
The code goes over each slice, calculates the percentage, calculates the position, and uses the fillText() method to draw it on the chart. We have used the fillStyle property to set the text color to black and the font property to set the size and font family of the label. It's also important to note that if the chart is a doughnut chart and the doughnutHoleSize is set, then the label will be pushed towards the edge of the chart to make it centered on the doughnut slice.
And here's how the resulting charts look with the value labels:



To complete our chart, the last thing we will add is the chart legend. Our chart legend will display the categories of our data model and the color used for the corresponding slice. First, we have to make some modifications to our index.html file by adding a <div> tag that will store our legend element.
<html>
<body>
<canvas id="myCanvas"></canvas>
<div for="myCanvas"></div>
<script type="text/javascript" src="script.js"></script>
</body>
</html>
Then in script.js we add the code that creates the content of the legend element. We do this inside the drawLegend() method of the Piechart class:
drawLegend() {
let pIndex = 0;
let legend = document.querySelector("div[for='myCanvas']");
let ul = document.createElement("ul");
legend.append(ul);
for (let ctg of Object.keys(this.options.data)) {
let li = document.createElement("li");
li.style.listStyle = "none";
li.style.borderLeft =
"20px solid " + this.colors[pIndex % this.colors.length];
li.style.padding = "5px";
li.textContent = ctg;
ul.append(li);
pIndex++;
}
}
The code looks for a legend element passed via the options parameter. If one is supplied, this element is filled in with the HTML code containing a colored box and the name of the data model category.
Our charts will also have a title to describe what the chart is supposed to show us. We can do that by adding another method called drawTitle() to our PieChart class. The configuration options for the chart title will be taken from the titleOptions object passed to the PieChart class.
drawTitle() {
this.ctx.save();
this.ctx.textBaseline = "bottom";
this.ctx.textAlign = this.titleOptions.align;
this.ctx.fillStyle = this.titleOptions.fill;
this.ctx.font = `${this.titleOptions.font.weight} ${this.titleOptions.font.size} ${this.titleOptions.font.family}`;
let xPos = this.canvas.width / 2;
if (this.titleOptions.align == "left") {
xPos = 10;
}
if (this.titleOptions.align == "right") {
xPos = this.canvas.width - 10;
}
this.ctx.fillText(this.options.seriesName, xPos, this.canvas.height);
this.ctx.restore();
}
One more thing that we can do for our own convenience is to define a draw() method that calls all other methods of the class to draw the whole chart.
draw() {
this.drawSlices();
this.drawLabels();
this.drawTitle();
this.drawLegend();
}
We also need to make a change to the way we call the drawing of our pie chart like this:
var myPiechart = new PieChart({
canvas: myCanvas,
seriesName: "Vinyl records",
padding: 40,
doughnutHoleSize: 0.4,
data: {
"Classical Music": 16,
"Alternative Rock": 12,
"Pop": 18,
"Jazz": 32
},
colors: ["#80DEEA", "#FFE082", "#FFAB91", "#CE93D8"],
titleOptions: {
align: "center",
fill: "black",
font: {
weight: "bold",
size: "18px",
family: "Lato"
}
}
});
myPiechart.draw();
And here is the resulting chart and chart legend:
We have seen that drawing charts using the HTML5 canvas is actually not that hard. It only requires a bit of math and a bit of JavaScript knowledge. You now have everything you need to draw your own pie charts and doughnut charts.
If you want a quick and easy solution for creating not only pie charts and doughnut charts but also loads of other types of charts, you can download the Infographic Charts and Graphics HTML Tags Library or its WordPress plugin counterpart Charts and Graphs WordPress Visual Designer.
Create Modern Vue Apps Using Create-Vue and Vite
/
5Pros and Cons of Using WordPress
/
-4How to Fix the “There Has Been a Critical Error in Your Website” Error in WordPress
/
1How To Fix The “There Has Been A Critical Error in Your Website” Error in WordPress
How to Create a Privacy Policy Page in WordPress
/
7WordPress Website Maintenance Guide For Beginners
/
6How Long Does It Take to Learn JavaScript?
/
-1How Long Does it Take to Learn JavaScript
/
1The Best Way to Deep Copy an Object in JavaScript
/
-2
4
-6Adding and Removing Elements From Arrays in JavaScript
/
-1Create a JavaScript AJAX Post Request: With and Without jQuery
/
95 Real-Life Uses for the JavaScript reduce() Method
/
-10How to Enable or Disable a Button With [removed] jQuery vs. Vanilla
/
2How to Enable or Disable a Button With [removed] jQuery vs Vanilla
/
-3Confirm Yes or No With JavaScript
/
-2How to Change the URL in [removed] Redirecting
/
-415+ Best WordPress Twitter Widgets
/
-227 Best Tab and Accordion Widget Plugins for WordPress (Free & Premium)
/
1021 Best Tab and Accordion Widget Plugins for WordPress (Free & Premium)
/
-1130 HTML Best Practices for Beginners
/
-831 Best WordPress Calendar Plugins and Widgets (With 5 Free Plugins)
/
625 Ridiculously Impressive HTML5 Canvas Experiments
/
-5How to Implement Email Verification for New Members
/
2How to Create a Simple Web-Based Chat Application
/
530 Popular WordPress User Interface Elements
/
-4Top 18 Best Practices for Writing Super Readable Code
/
3Best Affiliate WooCommerce Plugins Compared
/
-1018 Best WordPress Star Rating Plugins
/
1410+ Best WordPress Twitter Widgets
/
420+ Best WordPress Booking and Reservation Plugins
/
5Working With Tables in React: Part Two
/
-4Best CSS Animations and Effects on CodeCanyon
/
-1630 CSS Best Practices for Beginners
/
3How to Create a Custom WordPress Plugin From Scratch
/
510 Best Responsive HTML5 Sliders for Images and Text… and 3 Free Options
/
-516 Best Tab and Accordion Widget Plugins for WordPress
/
-418 Best WordPress Membership Plugins and 5 Free Plugins
/
325 Best WooCommerce Plugins for Products, Pricing, Payments and More
/
310 Best WordPress Twitter Widgets
1 /
1512 Best Contact Form PHP Scripts for 2020
/
-420 Popular WordPress User Interface Elements
/
-210 Best WordPress Star Rating Plugins
/
-412 Best CSS Animations on CodeCanyon
/
112 Best WordPress Booking and Reservation Plugins
/
120 Best WordPress Calendar Plugins and Widgets
/
-212 Elegant CSS Pricing Tables for Your Latest Web Project
/
724 Best WordPress Form Plugins for 2020
/
-214 Best PHP Event Calendar and Booking Scripts
/
-2Create a Blog for Each Category or Department in Your WooCommerce Store
/
28 Best WordPress Booking and Reservation Plugins
/
-17Best Exit Popups for WordPress Compared
/
20Best Exit Popups for WordPress Compared
/
-611 Best Tab & Accordion WordPress Widgets & Plugins
/
-1012 Best Tab & Accordion WordPress Widgets & Plugins
1New Course: Practical React Fundamentals
/
3Short Course: Better Angular App Architecture With Modules
/
2Preview Our New Course on Angular Material
/
4Object-Oriented PHP With Classes and Objects
/
3Best Practices for ARIA Implementation
/
-3Accessible Apps: Barriers to Access and Getting Started With Accessibility
/
-3Dramatically Speed Up Your React Front-End App Using Lazy Loading
/
1915 Best Modern JavaScript Admin Templates for React, Angular, and Vue.js
/
-1515 Best Modern JavaScript Admin Templates for React, Angular and Vue.js
/
219 Best JavaScript Admin Templates for React, Angular, and Vue.js
/
3New Course: Build an App With JavaScript and the MEAN Stack
/
12Hands-on With ARIA: Accessibility Recipes for Web Apps
/
910 Best WordPress Facebook Widgets
13 /
-5Hands-on With ARIA: Accessibility for eCommerce
/
6New eBooks Available for Subscribers
/
-5Hands-on With ARIA: Homepage Elements and Standard Navigation
/
10
-8Site Accessibility: Getting Started With ARIA
/
4How Secure Are Your JavaScript Open-Source Dependencies?
/
-1New Course: Secure Your WordPress Site With SSL
/
-3Testing Components in React Using Jest and Enzyme
/
-9Testing Components in React Using Jest: The Basics
/
-515 Best PHP Event Calendar and Booking Scripts
/
-1Create Interactive Gradient Animations Using Granim.js
/
10How to Build Complex, Large-Scale Vue.js Apps With Vuex
1Examples of Dependency Injection in PHP With Symfony Components
/
-6Set Up Routing in PHP Applications Using the Symfony Routing Component
1 /
10A Beginner’s Guide to Regular Expressions in JavaScript
/
13Introduction to Popmotion: Custom Animation Scrubber
/
-5Introduction to Popmotion: Pointers and Physics
/
-10New Course: Connect to a Database With Laravel’s Eloquent ORM
/
-5How to Create a Custom Settings Panel in WooCommerce
/
-12Building the DOM faster: speculative parsing, async, defer and preload
120 Useful PHP Scripts Available on CodeCanyon
3 /
51How to Find and Fix Poor Page Load Times With Raygun
/
1Introduction to the Stimulus Framework
/
-14Single-Page React Applications With the React-Router and React-Transition-Group Modules
/
2
712 Best Contact Form PHP Scripts
1 /
-4Getting Started With the Mojs Animation Library: The ShapeSwirl and Stagger Modules
/
2Getting Started With the Mojs Animation Library: The Shape Module
/
-4Getting Started With the Mojs Animation Library: The HTML Module
/
4Project Management Considerations for Your WordPress Project
/
-88 Things That Make Jest the Best React Testing Framework
/
4Creating an Image Editor Using CamanJS: Layers, Blend Modes, and Events
/
-2New Short Course: Code a Front-End App With GraphQL and React
Creating an Image Editor Using CamanJS: Applying Basic Filters
/
-13Creating an Image Editor Using CamanJS: Creating Custom Filters and Blend Modes
Challenge: Create a To-Do List in React
1 /
2Deploy PHP Web Applications Using Laravel Forge
/
-2Getting Started With the Mojs Animation Library: The Burst Module
/
6
-1010 Things Men Can Do to Support Women in Tech
/
1A Gentle Introduction to Higher-Order Components in React: Best Practices
/
-4Challenge: Build a React Component
/
-4A Gentle Introduction to HOC in React: Learn by Example
/
5A Gentle Introduction to Higher-Order Components in React
/
-6Creating Pretty Popup Messages Using SweetAlert2
/
4Creating Stylish and Responsive Progress Bars Using ProgressBar.js
/
1818 Best Contact Form PHP Scripts for 2022
/
-3How to Make a Real-Time Sports Application Using Node.js
/
-1Creating a Blogging App Using Angular & MongoDB: Delete Post
/
-16Set Up an OAuth2 Server Using Passport in Laravel
/
1Creating a Blogging App Using Angular & MongoDB: Edit Post
/
-2Creating a Blogging App Using Angular & MongoDB: Add Post
/
-1Creating a Blogging App Using Angular & MongoDB: Show Post
/
9Creating a Blogging App Using Angular & MongoDB: Home
/
8
3Creating a Blogging App Using Angular & MongoDB: Login
/
13Creating Your First Angular App: Implement Routing
/
12Persisted WordPress Admin Notices: Part 4
/
-4Creating Your First Angular App: Components, Part 2
/
4Persisted WordPress Admin Notices: Part 3
/
3How Laravel Broadcasting Works
/
1
8Persisted WordPress Admin Notices: Part 2
/
-3Create Your First Angular App: Storing and Accessing Data
/
2Persisted WordPress Admin Notices: Part 1
/
-3Error and Performance Monitoring for Web & Mobile Apps Using Raygun
/
7Using Luxon for Date and Time in JavaScript
7 /
-6How to Create an Audio Oscillator With the Web Audio API
/
-4How to Cache Using Redis in Django Applications
/
220 Essential WordPress Utilities to Manage Your Site
/
-5Introduction to API Calls With React and Axios
/
17Beginner’s Guide to Angular 4: HTTP
/
11Rapid Web Deployment for Laravel With GitHub, Linode, and RunCloud.io
/
9Beginners Guide to Angular 4: Routing
/
-9Beginner’s Guide to Angular 4: Components
/
1Creating a Drop-Down Menu for Mobile Pages
/
5Introduction to Forms in Angular 4: Writing Custom Form Validators
/
5Getting Started With Redux: Connecting Redux With React
/
15Getting Started With Redux: Learn by Example
/
16Getting Started With Redux: Why Redux?
/
9Understanding Recursion With JavaScript
/
-3How to Auto Update WordPress Salts
/
-7How to Download Files in Python
/
-3
-22Eloquent Mutators and Accessors in Laravel
1 /
18
-11
1310 Best HTML5 Sliders for Images and Text
/
6Site Authentication in Node.js: User Signup
/
-5Creating a Task Manager App Using Ionic: Part 2
/
2Creating a Task Manager App Using Ionic: Part 1
/
1
3Introduction to Forms in Angular 4: Template-Driven Forms
/
-224 Essential WordPress Utilities to Manage Your Site
/
-225 Essential WordPress Utilities to Manage Your Site
/
-11Get Rid of Bugs Quickly Using BugReplay
1 /
-15Manipulating HTML5 Canvas Using Konva: Part 1, Getting Started
/
610 Must-See Easy Digital Downloads Extensions for Your WordPress Site
/
-122 Best WordPress Booking and Reservation Plugins
/
-6Understanding ExpressJS Routing
/
-715 Best WordPress Star Rating Plugins
/
12Inheritance and Extending Objects With JavaScript
/
-9Introduction to the CSS Grid Layout With Examples
1 /
2
8Performant Animations Using KUTE.js: Part 5, Easing Functions and Attributes
/
-8Performant Animations Using KUTE.js: Part 4, Animating Text
/
-13Performant Animations Using KUTE.js: Part 3, Animating SVG
/
-10New Course: Code a Quiz App With Vue.js
/
-1Performant Animations Using KUTE.js: Part 2, Animating CSS Properties
/
3
8Performant Animations Using KUTE.js: Part 1, Getting Started
/
210 Best Responsive HTML5 Sliders for Images and Text (Plus 3 Free Options)
/
-3Single-Page Applications With ngRoute and ngAnimate in AngularJS
/
-12Deferring Tasks in Laravel Using Queues
/
-4
4Site Authentication in Node.js: User Signup and Login
/
12Working With Tables in React, Part Two
/
-16Working With Tables in React, Part One
/
6How to Set Up a Scalable, E-Commerce-Ready WordPress Site Using ClusterCS
/
-3New Course on WordPress Conditional Tags
/
3TypeScript for Beginners, Part 5: Generics
/
1
-11Building With Vue.js 2 and Firebase
6 /
11
-8
1Best Unique Bootstrap JavaScript Plugins
/
-9
-5Essential JavaScript Libraries and Frameworks You Should Know About
/
7
2Vue.js Crash Course: Create a Simple Blog Using Vue.js
/
-13Build a React App With a Laravel RESTful Back End: Part 1, Laravel 5.5 API
/
4API Authentication With Node.js
/
-4Beginner’s Guide to Angular: HTTP
/
7Beginner’s Guide to Angular: Routing
/
-4Beginners Guide to Angular: Routing
/
-5Beginner’s Guide to Angular: Services
/
4How to Create a Custom Authentication Guard in Laravel
/
6Learn Computer Science With [removed] Part 3, Loops
/
-3Build Web Applications Using Node.js
/
1Learn Computer Science With [removed] Part 4, Functions
/
4Learn Computer Science With [removed] Part 2, Conditionals
/
14Learn Computer Science With [removed] Part 1, The Basics
/
-4Create Interactive Charts Using Plotly.js, Part 5: Pie and Gauge Charts
/
-9Create Interactive Charts Using Plotly.js, Part 4: Bubble and Dot Charts
/
18Create Interactive Charts Using Plotly.js, Part 3: Bar Charts
/
-13Awesome JavaScript Libraries and Frameworks You Should Know About
/
-4Create Interactive Charts Using Plotly.js, Part 2: Line Charts
/
-8Bulk Import a CSV File Into MongoDB Using Mongoose With Node.js
/
-5Build a To-Do API With Node, Express, and MongoDB
/
-7Getting Started With End-to-End Testing in Angular Using Protractor
/
9TypeScript for Beginners, Part 4: Classes
/
-10Object-Oriented Programming With JavaScript
/
610 Best Affiliate WooCommerce Plugins Compared
/
8Stateful vs. Stateless Functional Components in React
/
10Make Your JavaScript Code Robust With Flow
/
-6Build a To-Do API With Node and Restify
/
7Testing Components in Angular Using Jasmine: Part 2, Services
/
2Testing Components in Angular Using Jasmine: Part 1
/
-2Creating a Blogging App Using React, Part 6: Tags
/
-11React Crash Course for Beginners, Part 3
/
1React Crash Course for Beginners, Part 2
/
10React Crash Course for Beginners, Part 1
/
2Set Up a React Environment, Part 4
1 /
8Set Up a React Environment, Part 3
/
-11New Course: Get Started With Phoenix
/
-10Set Up a React Environment, Part 2
/
2Set Up a React Environment, Part 1
/
1Command Line Basics and Useful Tricks With the Terminal
/
5How to Create a Real-Time Feed Using Phoenix and React
/
-8Build a React App With a Laravel Back End: Part 2, React
/
2Build a React App With a Laravel RESTful Back End: Part 1, Laravel 9 API
/
-7Creating a Blogging App Using React, Part 5: Profile Page
/
-5Pagination in CodeIgniter: The Complete Guide
/
23JavaScript-Based Animations Using Anime.js, Part 4: Callbacks, Easings, and SVG
/
-1JavaScript-Based Animations Using Anime.js, Part 3: Values, Timeline, and Playback
Learn to Code With [removed] Part 1, The Basics
/
510 Elegant CSS Pricing Tables for Your Latest Web Project
/
-7Getting Started With the Flux Architecture in React
/
-3Getting Started With Matter.js: The Composites and Composite Modules
/
4Getting Started With Matter.js: The Engine and World Modules
/
1310 More Popular HTML5 Projects for You to Use and Study
/
-24Understand the Basics of Laravel Middleware
/
-6Iterating Fast With Django & Heroku
/
8Creating a Blogging App Using React, Part 4: Update & Delete Posts
/
3Creating a jQuery Plugin for Long Shadow Design
/
-10How to Register & Use Laravel Service Providers
2 /
-13Unit Testing in React: Shallow vs. Static Testing
/
5Creating a Blogging App Using React, Part 3: Add & Display Post
/
16Creating a Blogging App Using React, Part 2: User Sign-Up
20 /
-6Creating a Blogging App Using React, Part 1: User Sign-In
/
99 More Popular HTML5 Projects for You to Use and Study
/
18Creating a Grocery List Manager Using Angular, Part 2: Managing Items
/
8Dynamic Page Templates in WordPress, Part 3
/
-1Angular vs. React: 7 Key Features Compared
/
5Creating a Grocery List Manager Using Angular, Part 1: Add & Display Items
/
3New eBooks Available for Subscribers in June 2017
/
7Create Interactive Charts Using Plotly.js, Part 1: Getting Started
/
11The 5 Best IDEs for WordPress Development (And Why)
/
133 Popular WordPress User Interface Elements
/
2New Course: How to Hack Your Own App
/
-10How to Install Yii on Windows or a Mac
/
5What Is a JavaScript Operator?
/
-5How to Register and Use Laravel Service Providers
/
7
waly Good blog post. I absolutely love this…