A modern JavaScript utility library delivering modularity, performance, & extras.

Overview

lodash

Site | Docs | FP Guide | Contributing | Wiki | Code of Conduct | Twitter | Chat

The Lodash library exported as a UMD module.

Generated using lodash-cli:

$ npm run build
$ lodash -o ./dist/lodash.js
$ lodash core -o ./dist/lodash.core.js

Download

Lodash is released under the MIT license & supports modern environments.
Review the build differences & pick one that’s right for you.

Installation

In a browser:

<script src="lodash.js"></script>

Using npm:

$ npm i -g npm
$ npm i lodash

Note: add --save if you are using npm < 5.0.0

In Node.js:

// Load the full build.
var _ = require('lodash');
// Load the core build.
var _ = require('lodash/core');
// Load the FP build for immutable auto-curried iteratee-first data-last methods.
var fp = require('lodash/fp');

// Load method categories.
var array = require('lodash/array');
var object = require('lodash/fp/object');

// Cherry-pick methods for smaller browserify/rollup/webpack bundles.
var at = require('lodash/at');
var curryN = require('lodash/fp/curryN');

Looking for Lodash modules written in ES6 or smaller bundle sizes? Check out lodash-es.

Why Lodash?

Lodash makes JavaScript easier by taking the hassle out of working with arrays,
numbers, objects, strings, etc. Lodash’s modular methods are great for:

  • Iterating arrays, objects, & strings
  • Manipulating & testing values
  • Creating composite functions

Module Formats

Lodash is available in a variety of builds & module formats.

Comments
  • Feature Request: _.move() element in an array

    Feature Request: _.move() element in an array

    I needed this in the implementation of a drag and drop gallery and found it was not on the lodash docs. If this already exists or is implemented in a different way I apologize as I could not find it.

    A simple method to move an element inside of an array from one position to another.

    _.move = function(array,fromIndex,toIndex){
        array.splice(toIndex, 0, array.splice(fromIndex, 1)[0] );
    }
    

    Example usage

    _.move([1,2,3,4,5],0,2);
    // -> [2,3,1,4,5]
    

    Solution taken from (and more detail / verifications needed available at): http://stackoverflow.com/a/5306832/474883

    enhancement votes needed 
    opened by blindstuff 56
  • Feature Request: Add array `remove` method.

    Feature Request: Add array `remove` method.

    Would be useful to have a _.remove() method, which removes element(s) from an array by value (either using the identity operator ===, or a callback which returns a truthy value), but without copying the entire array.

    _.without() makes a copy of the array you're working on. Seems inefficient to continually copy an entire (and possibly long) array if just removing one, or a few items from it.

    enhancement 
    opened by gregjacobs 39
  • Ensure something is array

    Ensure something is array

    I think this is a feature request, but it's possible it already exists and I just can't find it.

    I often find myself writing the following:

    _.isArray(something) ? something : [something]
    

    It would be useful if there were a function called something like ensureArray that did this:

    _.ensureArray([1, 2]); // [1, 2]
    _.ensureArray(1); // [1]
    

    I'd be willing to write this if other people think it would be useful in the core. Also, not a fan of ensureArray—if anyone could think of a better name, that would be useful.

    enhancement 
    opened by callumacrae 35
  • How to use lodash-es using import in Node 14?

    How to use lodash-es using import in Node 14?

    I'm trying to use lodash-es in the latest Node 14, which has out of the box support for ES modules 🎉. This means it we do not need any transformation steps in order to load ES modules in a plain node.js application.

    When I create the following test file test.js:

    // test.js
    import { first } from 'lodash-es'
    
    console.log(first([1, 2, 3])) // should print 1
    

    And then run it using Node 14:

    $ node test.js
    

    It does not work but gives the following error:

    $ node test.js
    file:///.../test.js:1
    import { first } from 'lodash-es'
             ^^^^^
    SyntaxError: The requested module 'lodash-es' is expected to be of type CommonJS, which does not support named exports. CommonJS modules can be imported by importing the default export.
    

    This is because node.js treats the files in lodash-es as CommonJS instead of ES6 modules. To solve this, lodash-es must somehow explain to node.js that it's containing modules, which as far as I know can be done in two ways (see nodejs docs):

    • Add the field "type": "module" in package.json. I tested this and this works. However, in the past there was an issue with this field, see https://github.com/lodash/lodash/issues/4359, so I'm not sure if we can just do that.
    • Give all the files an extension *.mjs instead of *.js.
    change 
    opened by josdejong 32
  • possibility to add update method

    possibility to add update method

    What about having an update method as in clojure? Specially useful in functional programming. Something like this:

    function update(object, path, func, ...args) {
      set(object, path, func(get(object, path), ...args);
      return object;
    }
    
    enhancement 
    opened by hzamani 31
  • Please consider supporting _.isDefined

    Please consider supporting _.isDefined

    I know it can be done by:

    if( ! _.isUndefined(obj.key) ){ }
    

    but sometimes it is confusing and takes a few mental cycles to parse the code while it is straightforward and easy to read:

    if( _.isDefined(obj.key) ){ }
    
    enhancement votes needed 
    opened by niyazpk 30
  • iterators with null fail in 0.8.0

    iterators with null fail in 0.8.0

    In previous versions, you could attempt to iterate over a null

    var foo = null; _.each(foo, function(... ) { .. });

    In 0.8.0, it now throws this error.

    TypeError: Cannot read property 'length' of undefined

    I think it is related to this change.

    https://github.com/afeld/underscore/commit/30f0d323c7abea0b8e2a9f57e6861be916577339#L3R957

    question 
    opened by panthershark 30
  • mapValues for objects

    mapValues for objects

    Hello!

    Any chance of including mapValues into lodash? This would be a function that produces a new object by applying a function to each of the values contained in a source object.

    I'll reproduce the code from documentcloud/underscore#220 here:

    _.mixin({
      mapValues: function (input, mapper, context) {
        return _.reduce(input, function (obj, v, k) {
          obj[k] = mapper.call(context, v, k, input);
          return obj;
        }, {}, context);
      }
    });
    

    I don't have strong feelings about the idiomatic way to implement the function, but it should behave as this pseudocode:

    onSecond f (x, y) = (x, f y)
    _.mapValues f = _.object ∘ _.map (onSecond f)  ∘ _.pairs
    

    This would definitely fall under "consistency" and "extra features" relative to underscore. It is small but I don't want to copy it everywhere or maintain a fork of either project. There's plenty of discussion on the other ticket, if you like.

    -- Kenn

    enhancement 
    opened by kennknowles 29
  • _.bindAll + comparator causes breakage on function-based Backbone methods

    _.bindAll + comparator causes breakage on function-based Backbone methods

    Got caught on this today...

    If you extend a Backbone.Collection with a comparator method and use _.bindAll within the initialize function, it blows up the comparator. This does not happen when using Underscore.

    While I wasn't able to completely get down to the bottom of this, a key difference occurs in Backbone.sort, where this.comparator no longer has a length of 1 (as it does in Underscore.

    Wish I could easily link to the Backbone source to help identify the discrepancy. Thought I'd identify it.

    wontfix old: underscore compat 
    opened by brandoncarl 28
  • Sort order with multiple keys

    Sort order with multiple keys

    Hi, I am a in awe of the power of lodash. For my project it has been of invaluable help so far. However, now I am stuck with a problem with which lodash seems to fall a bit short.

    Here is the problem:

    I have an array of objects with the same properties, say

    [{name:"barney", age: 38},
     {name:"fred", age: 40},
     {name:"fred", age: 12}]
    

    I want to sort the array by name in descending order, but age should be in ascending order.

    lodash supports multiple sorting keys by the "pluck" syntax, but only can deal with ascending sorting this way. Is there a way that the sortBy function is altered that it also accepts an array of objects that define the property name (key) and the order direction? I would love to do:

    mySortedArr = _.sortby(
        unsortedArr, [
            {propertyName:"name", order:"desc"}, 
            {propertyName:"age", order:"asc"}
        ]);
    

    Any chance something like that enters the library?

    enhancement 
    opened by luksch 27
  • Lodash doesn't work in Browserify

    Lodash doesn't work in Browserify

    I installed lodash from npm (both 1.1.0 and 1.1.1 fail), and ran through Browserify v1.17.3, and I got an error about invoking an undefined function.

    The problem comes from the following line (in runInContext()):

    // Avoid issues with some ES3 environments that attempt to use values, named
    // after built-in constructors like `Object`, for the creation of literals.
    // ES5 clears this up by stating that literals must use built-in constructors.
    // See http://es5.github.com/#x11.1.5.
    context = context ? _.defaults(window.Object(), context, _.pick(window, contextProps)) : window;
    

    window is the outer this as passed to (function (window) { ... }(this)).
    In Browserify, this is module.exports (Browserify wraps lodash's source in its own function), which doesn't have any globals.
    Therefore, lines like context.Array() fail.

    bug 
    opened by SLaks 27
  • _get returns undefined if a nested path contains an array value

    _get returns undefined if a nested path contains an array value

    Hi,

    For example if I have the following object

    var object = {
      "ParentObject": {
        "/child|name": {
          "key": "/foobar"
        },
        "/child|flavour[0]": {
          "key": "/lime"
        }
      }
    }
    
    

    The following get function will return undefined

    _.get(object, "ParentObject./flavour[0]")

    If I do not include the [ character, the following function will work

    _.get(object, "ParentObject./child|name")

    However the following is valid

    var object = {
      "ParentObject": {
        "/child|name": {
          "key": "/foobar"
        },
        "/flavour[0]": {
          "key": "/lime"
        }
      }
    }
    
    const abc = _.get(object, "ParentObject")
    
    _.get(abc, "/flavour[0]")
    

    Is it possible to get this working without having to break down the object if it contains that character when it is not the parent object

    opened by MartynRobotham 3
  • Missing `concat.js`

    Missing `concat.js`

    in /test, there is concat.js Line 3: import concat from '../concat.js';

    but in the upper directory, there is no concat.js.

    Please know, thanks.

    Error is like the Error [ERR_MODULE_NOT_FOUND]: Cannot find module 'lodash/concat.js' imported from "/lodash/test/concat.js".


    opened by tzhangpccw 1
  • Adding compact object method

    Adding compact object method

    I was working with one of my backend projects so I was feeling this feature is needed for objects that are received from req.body either in frontend or backend.

    This method works very well with objects and safeties are also checked to prevent the app from crashing.

    I should note that this method gets inspired by the compact method which is used for arrays and works very similarly but it will validate both Keys and Value pairs in the object, and lastly, I was thinking about a flag that can be passed as a second arg to the method (which is optional btw!) to check if a developer wants to check Keys or Values or Both of them in the object.

    opened by amyrsaalehi 0
  • Missing https://github.com/lodash/lodash/wiki/build-differences

    Missing https://github.com/lodash/lodash/wiki/build-differences

    The page linked with https://github.com/lodash/lodash/wiki/build-differences at

    Review the build differences & pick one that’s right for you.

    in the README.md is missing.

    opened by Querela 1
Releases(4.0.0)
  • 4.0.0(Jan 12, 2016)

    lodash v4.0.0

    2015 was big year! Lodash became the most depended on npm package, passed 1 billion downloads, & its v3 release saw massive adoption!

    The year was also one of collaboration, as discussions began on merging Lodash & Underscore. Much of Lodash v4 is proofing out the ideas from those discussions. Lodash v4 would not be possible without the collaboration & contributions of the Underscore core team. In the spirit of merging our teams have blended with several members contributing to both libraries.

    For 2016 & lodash v4.0.0 we wanted to cut loose, push forward, & take things up a notch!

    Modern only

    With v4 we’re breaking free from old projects, old environments, & dropping old IE < 9 support!

    4 kB Core

    Lodash’s kitchen-sink size will continue to grow as new methods & functionality are added. However, we now offer a 4 kB (gzipped) core build that’s compatible with Backbone v1.2.4 for folks who want Lodash without lugging around the kitchen sink.

    More ES6

    We’ve continued to embrace ES6 with methods like _.isSymbol, added support for cloning & comparing array buffers, maps, sets, & symbols, converting iterators to arrays, & iterable _(…).

    In addition, we’ve published an es-build & pulled babel-plugin-lodash into core to make tree-shaking a breeze.

    More Modular

    Pop quiz! 📣

    What category path does the bindAll method belong to? Is it

    A) require('lodash/function/bindAll') B) require('lodash/utility/bindAll') C) require('lodash/util/bindAll')

    Don’t know? Well, with v4 it doesn’t matter because now module paths are as simple as

    var bindAll = require('lodash/bindAll');
    

    We’ve also reduced module complexity making it easier to create smaller bundles. This has helped Lodash adoption with libraries like Async & Redux!

    1st Class FP

    With v3 we introduced lodash-fp. We learned a lot & with v4 we decided to pull it into core.

    Now you can get immutable, auto-curried, iteratee-first, data-last methods as simply as

    var _ = require('lodash/fp');
    var object = { 'a': 1 };
    var source = { 'b': 2 };
    var newObject = _.assign(source)(object);
    
    console.log(newObject);
    // => { 'a': 1, 'b': 2 }
    
    console.log(object);
    // => { 'a': 1 }
    
    var convert = require('lodash/fp/convert');
    var assign = convert('assign', require('lodash.assign'));
    // works too!
    

    Chakra Optimized

    Well actually, while we’re excited about Chakra, Lodash is optimized for great performance across all engines. Unlike many libraries, we don’t favor a single engine so we can deliver solid performance & support regardless of engine.

    With v4 we’ve continued our commitment to performance; expanding support for lazy evaluation & improving the performance of core functionality like circular reference detection.

    Emojis

    Taking things up a notch Lodash v4 has added support for emojis! Includes things like astral symbols, unicode modifiers, variation selector characters, zero-width joiners, & regional indicator symbols.

    Breaking changes

    We’ve introduced more breaking changes in this release than any other so be sure to check out the changelog for a full rundown of changes & give lodash-migrate a spin to help migrate older Lodash code to the latest release.

    If you dig Lodash don’t forget to star the repo or npm star lodash!

    Source code(tar.gz)
    Source code(zip)
  • 3.0.0(Jan 26, 2015)

    lodash v3.0.0

    After a little over a year & more than 2,000 commits we’re excited to release lodash v3.0.0. lodash follows semantic versioning so with this major release we’ve taken the opportunity to clean house & make some back-compat breaking changes. We’ll get into that in a bit, but first lets talk about all the cool things this release has to offer.

    String methods

    By popular demand we surveyed the utility landscape for a cross-section of string APIs to add to lodash. We settled on 17 string methods: _.camelCase, _.capitalize, _.deburr, _.endsWith, _.escapeRegExp, _.kebabCase, _.pad, _.padLeft, _.padRight, _.repeat, _.snakeCase, _.startsWith, _.trim, _.trimLeft, _.trimRight, _.trunc, & _.words

    There’s familiar methods from ES5, like _.trim, & ES6, like _.endsWith, _.repeat, & _.startsWith, as well as some lesser known methods like _.deburr & _.kebabCase.

    // trims whitespace like `String#trim` but
    // also allows specifying characters to trim
    _.trim('  abc  ');
    // → 'abc'
    _.trim('-_-abc-_-', '_-');
    // → 'abc'
    
    // works great with `_.map` too
    _.map(['  foo  ', '  bar  '], _.trim);
    // → ['foo', 'bar']
    
    // deburr diacritical marks (http://en.wikipedia.org/wiki/Diacritic)
    _.deburr('déjà vu');
    // → 'deja vu'
    
    // similar to a `dasherize` or `slugify` method
    _.kebabCase('foo bar');
    // → 'foo-bar'
    

    Following casing rules with methods like _.camelCase, _.kebabCase, & _.snakeCase allows for strings to be transformed from say camel case, to kebab case, to snake case, & back again.

    _.camelCase(_.snakeCase(_.kebabCase('fooBar')));
    // → 'fooBar'
    

    ES is our jam

    Previous versions of lodash added _.assign, _.find, _.findIndex, & ES template delimiter support. In this release we’re taking our ES adoption up a notch by aligning _.includes, _.isFinite, & _.keys, supporting typed arrays in _.clone & _.isEqual, using Set & WeakMap for performance-gains, allowing Map & WeakMap to be used as _.memoize.Cache, & supporting ES modularized builds with lodash-cli.

    Functional goodies

    There’s lots of functional goodies in v3 like _.ary, _.curryRight, _.flow, _.rearg, & support for customizable argument placeholders in _.bind, _.bindKey, _.curry, _.curryRight, _.partial, & _.partialRight.

    // infomercial fail
    _.map(['6', '8', '10'], parseInt);
    // → [6, NaN, 2]
    
    // using a placeholder to pass over the
    // `string` parameter & specify a `radix` of `0`
    _.map(['6', '8', '10'], _.partial(parseInt, _, 0));
    // → [6, 8, 10]
    
    // is equivalent to
    _.map(['6', '8', '10'], function(value) {
      return parseInt(value, 0);
    });
    
    // customize `_.partial.placeholder`
    _.partial.placeholder = '_';
    _.map(['6', '8', '10'], _.partial(parseInt, '_', 0));
    // → [6, 8, 10]
    

    Also several methods now work out-of-the-box as iteratees for methods like _.map & _.reduce

    _.map(['6', '8', '10'], _.parseInt);
    // → [6, 8, 10]
    
    _.map(['a', 'a'], ['b', 'b'], _.uniq);
    // → [['a'], ['b']]
    
    _.reduce([{ 'b': 2 }, { 'c': 3 }], _.assign, { 'a': 1 });
    // → { 'a': 1, 'b': 2, 'c': 3}
    

    We’ve heard from some functional programming fans that lodash wasn’t functional enough, often citing our method signatures as an issue. To ease composition & currying they’d prefer methods like _.filter be predicate first & collection second instead of collection first & predicate second.

    Butter-side up

    It’d be a shame for those fans to lose out on lodash over something as little as method signatures so with v3 we’ve added _.ary & _.rearg. The _.ary method sets the argument cap of a function & _.rearg rearranges the arguments provided to a function.

    // cap the number arguments provided to `parseInt` at one
    _.map(['6', '8', '10'], _.ary(parseInt, 1));
    // → [6, 8, 10]
    
    // create a `filter` that’s predicate-first
    var filter = _.rearg(_.filter, 1, 0);
    filter('a', [{ 'a': 0 }, { 'a': 1 }]);
    // → [{ 'a': 1 }]
    
    // create an `includes` that’s auto-curried & needle-first
    var includes = _(_.includes).ary(2).rearg(1, 0).curry(2).value();
    includes(2)([1, 2, 3]);
    // → true
    

    You can also use individual packages like lodash.ary, lodash.curry, & lodash.rearg to convert functions.

    var ary = require('lodash.ary'),
        curry = require('lodash.curry'),
        rearg = require('lodash.rearg');
    
    var getobject = require('getobject'),
        get = curry(rearg(ary(getobject, 2), [1, 0]), 2);
    
    get('a.b.c')({ 'a': { 'b': { 'c': 'foo' } } });
    // → 'foo'
    

    Combined with _.runInContext you could easily create a version of lodash with auto-curried iteratee-first methods. In fact, that’s what we’ve done! Introducing lodash-fp.

    var items = [
      { 'value': _.constant(['a', 'b']) },
      { 'value': _.constant(['b', 'c']) }
    ];
    
    var getValues = _.flow(
      _.map(_.result('value')),
      _.flatten,
      _.uniq
    );
    
    getValues(items);
    // => ['a', 'b', 'c']
    
    _.map(parseInt)(['6', '08', '10']);
    // → [6, 8, 10]
    

    lodash reduces the cost of method wrapping produced by _.ary, _.curry, & _.rearg by using a WeakMap to store function metadata. In this way a function is only wrapped once even though it may have _.ary, _.curry, & _.rearg applied.

    Modules, modules, modules

    In lodash v2 we introduced npm packages per-method as well as bundles of modules for AMD & Node.js. With v3 we’ve improved lodash-cli’s ability to inline dependencies allowing us to easily customize inlining per method, enabling a better balance between deep dependency graphs & code duplication.

    v2 dep graph v3 dep graph

    In addition all modularized dependencies now use the ^ version range, instead of the ~, so they’ll update as needed without you having to worry about it. Moving forward all per-method packages will be independently updated, instead of in bulk, because lodash-cli will soon be able to detect changes in packages & automatically bump patch/minor version numbers.

    The lodash & lodash-compat npm packages now come with modules baked in too. Perfect for browserify and webpack!

    // load the modern build
    var _ = require('lodash');
    // or a method category
    var array = require('lodash/array');
    // or a method
    var chunk = require('lodash/array/chunk');
    

    The method modules are organized by category so they’re easy to find.

    lodash is available in a variety of other builds & module formats.

    Performance

    We’ve improved performance 20-40% overall in v3 by better utilizing the JIT in JavaScript engines, using internal helper functions that avoid optimization disqualifications & increase the likelihood of function inlining.

    performance comparison v3 vs v2

    In v3 we’ve also introduced lazily evaluated chaining for massive performance wins in certain scenarios.

    As mentioned above we’re using Set & WeakMap for performance-gains which all modern browsers, Node.js, & io.js can benefit from.

    Breaking changes

    lodash v3 is a major bump & we’ve introduced several back-compat breaking changes. One such change is that while we still test against Underscore/Backbone unit tests we’re no longer supporting an Underscore/Backbone build. Over the last year we’ve seen Underscore align more & more with lodash’s API so the need for a separate Underscore build has diminished. If you still need compatibility around some of the edges we recommend leveraging modules in lodash v3 to supplement your Underscore use.

    Be sure to check out the changelog for a full rundown of changes & give lodash-migrate a spin to help migrate older lodash code to the latest release.

    New Core Member

    In closing I want to welcome Benjamin Tan (bnjmnt4n) as an official core member. Without the efforts of contributors, like Benjamin, lodash v3 would not have happened.

    If you dig lodash v3 don't forget to star the repo or npm star lodash!

    Source code(tar.gz)
    Source code(zip)
Owner
Lodash Utilities
JavaScript utilities delivering consistency, modularity, performance, & extras.
Lodash Utilities
JavaScript's utility _ belt

__ /\ \ __ __ __ ___ \_\ \ __ _ __ ____ ___ ___ _ __

Jeremy Ashkenas 26.7k Jan 4, 2023
A Javascript library for working with native objects.

Sugar A Javascript library for working with native objects. Install Upgrading Getting Started Documentation Custom Builds Browser npm Modules Date Loc

Andrew Plummer 4.5k Dec 24, 2022
:ram: Practical functional Javascript

Ramda A practical functional library for JavaScript programmers. Why Ramda? There are already several excellent libraries with a functional flavor. Ty

Scott Sauyet 2 Jul 21, 2022
Modular JavaScript Utilities

http://moutjs.com/ All code is library agnostic and consist mostly of helper methods that aren't directly related with the DOM, the purpose of this li

Modular JavaScript Utilities 1.3k Dec 27, 2022
Hardcore Functional Programming for JavaScript

#Preλude-js A truly modular implementation of Haskell's Prelude library in ES6 check out the docs for modules details (WORK IN PROGRESS) install npm i

Alan Soares 96 Jan 1, 2023
a react-based framework that provides accessibility, modularity, responsiveness, and theming in a tidy package

Grommet: focus on the essential experience Documentation Visit the Grommet website for more information. Support / Contributing Before opening an issu

grommet 8.1k Jan 5, 2023
Component based MVC web framework for nodejs targeting good code structures & modularity.

Component based MVC web framework for nodejs targeting good code structures & modularity. Why fortjs Based on Fort architecture. MVC Framework and fol

Ujjwal Gupta 47 Sep 27, 2022
⏳ Modern JavaScript date utility library ⌛️

date-fns provides the most comprehensive, yet simple and consistent toolset for manipulating JavaScript dates in a browser & Node.js. ?? Documentation

date-fns 30.6k Dec 29, 2022
A utility for creating toggleable items with JavaScript. Inspired by bootstrap's toggle utility. Implemented in vanillaJS in a functional style.

LUX TOGGLE Demo: https://jesschampion.github.io/lux-toggle/ A utility for creating toggleable dom elements with JavaScript. Inspired by bootstrap's to

Jess Champion 2 Oct 3, 2020
This web application aim to produce an contest notifier utility and a modern open-source compiler.

This web application aim to produce an contest notifier utility and a modern open-source compiler. The current features of the application include : Code Runner , Upcoming and Ongoing Contests.

ABHAY GUPTA 6 Dec 3, 2022
A small javascript DOM manipulation library based on Jquery's syntax. Acts as a small utility library with the most common functions.

Quantdom JS Quantdom is a very small (about 600 bytes when ran through terser & gzipped) dom danipulation library that uuses a Jquery like syntax and

Sean McQuaid 7 Aug 16, 2022
danfo.js is an open source, JavaScript library providing high performance, intuitive, and easy to use data structures for manipulating and processing structured data.

Danfojs: powerful javascript data analysis toolkit What is it? Danfo.js is a javascript package that provides fast, flexible, and expressive data stru

JSdata 4k Dec 29, 2022
Seamless and lightweight parallax scrolling library implemented in pure JavaScript utilizing Hardware acceleration for extra performance.

parallax-vanilla.js Seamless and lightweight parallax scrolling library implemented in pure JavaScript utilizing Hardware acceleration for extra perfo

Erik Engervall 91 Dec 16, 2022
Animate Plus is a JavaScript animation library focusing on performance and authoring flexibility

Animate Plus Animate Plus is a JavaScript animation library focusing on performance and authoring flexibility. It aims to deliver a steady 60 FPS and

Benjamin De Cock 5.9k Jan 2, 2023
AppRun is a JavaScript library for developing high-performance and reliable web applications using the elm inspired architecture, events and components.

AppRun AppRun is a JavaScript library for building reliable, high-performance web applications using the Elm-inspired architecture, events, and compon

Yiyi Sun 1.1k Dec 20, 2022
A tiny, plugin extendable JavaScript utility library with a JQuery-like syntax.

Tiny Friggin' Utility Zapper What is it? A tiny ~7kb extendable JavaScript utility library with a JQuery like syntax for getting work done fast! If yo

Bret 4 Jun 25, 2022
Boiler is a utility library that makes every day tasks in JavaScript easier by providing over 115 methods

Boiler is a utility library that makes every day tasks in JavaScript easier by providing over 115 methods that work on arrays, collections, functions, numbers, objects, and strings. It's the JavaScript equivalent of a Swiss Army Knife.

Wil 42 Nov 1, 2022
A simple javascript utility library to include partial html (iframe alternate) without a framework or jQuery.

alt-iframe A simple javascript utility library to include partial html (iframe alternate) without a framework or jQuery. <!doctype html> <html lang="e

FrontEndNeo 17 Dec 30, 2022
A high-performance, dependency-free library for animated filtering, sorting, insertion, removal and more

MixItUp 3 MixItUp is a high-performance, dependency-free library for animated DOM manipulation, giving you the power to filter, sort, add and remove D

Patrick Kunka 4.5k Dec 24, 2022
:bird: :zap: Bluebird is a full featured promise library with unmatched performance.

Got a question? Join us on stackoverflow, the mailing list or chat on IRC Introduction Bluebird is a fully featured promise library with focus on inno

Petka Antonov 20.2k Jan 5, 2023