countup.js

What is countup.js?

countup.js is a lightweight JavaScript library that allows you to create animated counting numbers. It is useful for creating dynamic and engaging number displays in web applications, such as statistics, counters, and other numerical data visualizations.

What are countup.js's main functionalities?

Basic Count Up

This feature allows you to animate a number counting up from zero to a specified value. In this example, the number will count up to 1000 and display in the element with the ID 'targetElement'.

const countUp = new CountUp('targetElement', 1000);
if (!countUp.error) {
  countUp.start();
} else {
  console.error(countUp.error);
}

Custom Start and End Values

This feature allows you to specify custom start and end values for the count up animation. In this example, the number will count up from 500 to 2000.

const countUp = new CountUp('targetElement', 2000, { startVal: 500 });
if (!countUp.error) {
  countUp.start();
} else {
  console.error(countUp.error);
}

Formatting Options

This feature allows you to format the number with options such as decimal places, prefixes, and suffixes. In this example, the number will be formatted with two decimal places and display as currency (e.g., $1000.00 USD).

const countUp = new CountUp('targetElement', 1000, { decimalPlaces: 2, prefix: '$', suffix: ' USD' });
if (!countUp.error) {
  countUp.start();
} else {
  console.error(countUp.error);
}

Easing Functions

This feature allows you to apply custom easing functions to the count up animation. In this example, a quadratic easing function is used to create a smooth animation effect.

const countUp = new CountUp('targetElement', 1000, { easingFn: function (t, b, c, d) { return c * (t /= d) * t + b; } });
if (!countUp.error) {
  countUp.start();
} else {
  console.error(countUp.error);
}

Other packages similar to countup.js

odometer

Odometer is a smooth, themeable, and easy-to-use JavaScript library for transitioning numbers. It provides a more visually appealing way to animate numbers compared to countup.js, with various themes and styles that mimic the look of an odometer.

jquery.counterup

jquery.counterup is a jQuery plugin that animates a number from zero to a specified value. It is similar to countup.js but requires jQuery as a dependency, making it less lightweight. It is suitable for projects that already use jQuery.

README

CountUp.js

CountUp.js is a dependency-free, lightweight JavaScript "class" that can be used to quickly create animations that display numerical data in a more interesting way.

Despite its name, CountUp can count in either direction, depending on the startVal and endVal params that you pass.

CountUp.js supports all browsers.

##Try the demo

Installation

The only file you need is countUp.js.

If you want to get fancy with build systems, a gulpfile is included. Read more here.

Angular directive

Included is an angular module. Use the count-up attribute to quickly create an animation. It also integrates nicely with the angular-scroll-spy directive. The Angular directive only requires an end-val attribute, but will also accept start-val, duration, and decimals. id is not needed. You must include both countUp.js and the module to use the angular directive. Check out the angular demo.

WordPress plugin

If you want a quick and easy way to use this on your WordPress site, try this plugin by @4DMedia: https://wordpress.org/plugins/countup-js/

Usage:

Params:

• target = id of html element, input, svg text element, or var of previously selected element/input where counting occurs
• startVal = the value you want to begin at
• endVal = the value you want to arrive at
• decimals = (optional) number of decimal places in number, default 0
• duration = (optional) duration in seconds, default 2
• options = (see demo, optional) formatting/easing options object

Decimals, duration, and options can be left out to use the default values.

var numAnim = new CountUp("SomeElementYouWantToAnimate", 24.02, 99.99);
numAnim.start();

with optional callback:

numAnim.start(someMethodToCallOnComplete);

// or an anonymous function
numAnim.start(function() {
    // do something
})

For angular:

<h2 count-up end-val="873.4"></h2>

Width angular-scroll-spy:

<h2 count-up id="numberAnimation" end-val="873.4" scroll-spy-event="elementFirstScrolledIntoView" scroll-spy></h2>

Other methods:

Toggle pause/resume:

numAnim.pauseResume();

Reset an animation:

numAnim.reset();

Update the end value and animate:

var someValue = 1337;
numAnim.update(someValue);

Custom easing:

You can apply your custom easing function, which will receive standard 4 parameters necessary to calculate Bezier curve:

• t (the current time);
• b (the beginning value);
• c (the change between the beginning and destination value);
• d (the total time of the tween).

So, for instance, you could use bodies of easing functions from jQuery's easing plugin. Pass in the body of the function and you're good to go :)

Just don't use any "bouncy" functions, as they tend to cause issues and are controlled not to exceed max value by the library.

If you don't specify a custom easing closure function, the plugin will fall back to the default easeOutExpo.

Example:

var easeOutCubic = function(t, b, c, d) {
    var ts = (t /= d) * t;
    var tc = ts * t;
    return b + c * (1.77635683940025e-15 * tc * ts + 0.999999999999998 * tc + -3 * ts + 3 * t);
};
var options = {
  easingFn: easeOutCubic
};
var demo = new CountUp("myTargetElement", 24.02, 94.62, 2, 2.5, options);
demo.start();

License & Contributing

• Details on the license can be found here
• Details on running tests and contributing can be found here