The core-js npm package is a modular standard library for JavaScript, which includes polyfills for ECMAScript features. It provides reliable polyfills to ensure that code behaves consistently across different environments, including older browsers.
Polyfilling ECMAScript features
This feature allows developers to use the latest ECMAScript features while ensuring backward compatibility with older environments that do not support these features natively.
require('core-js/stable');
// Now you can use ES6 features like Promise in environments that do not support them natively.Polyfilling Web Standards
Core-js can also polyfill web standards, allowing developers to use modern web APIs in environments that have not implemented them.
require('core-js/web');
// This includes polyfills for web standards like DOM collections (e.g., NodeList), timers, and more.Polyfilling Proposals
Developers can experiment with proposed ECMAScript features before they are finalized and adopted into the standard, ensuring forward compatibility.
require('core-js/proposals');
// This will include polyfills for ECMAScript proposals that are not yet part of the standard.Babel-polyfill is a package that provides polyfills necessary for a full ES2015+ environment. It is similar to core-js but is more tightly coupled with Babel's transpilation process.
The es6-shim package provides polyfills for ECMAScript 6 (aka ECMAScript 2015) features. It is similar to core-js but focuses specifically on ES6 features and does not cover proposals or web standards.
The polyfill-service by Financial Times is an online service that provides polyfills based on the user's browser. It is different from core-js in that it is a service rather than a package you include in your project, but it serves a similar purpose in polyfilling features.
Modular compact standard library for JavaScript. Includes polyfills for ECMAScript 5, ECMAScript 6: symbols, collections, iterators, promises, ECMAScript 7 proposals; setImmediate, array generics. Some additional features such as dictionaries, extended partial application, console cap, date formatting. You can require only standardized features polyfills, use features without global namespace pollution or create a custom build.
Array.from(new Set([1, 2, 3, 2, 1])); // => [1, 2, 3]
'*'.repeat(10); // => '**********'
Promise.resolve(32).then(log); // => 32
setImmediate(log, 42); // => 42
Without global namespace pollution:
var core = require('core-js/library'); // With a modular system, otherwise use global `core`
core.Array.from(new core.Set([1, 2, 3, 2, 1])); // => [1, 2, 3]
core.String.repeat('*', 10); // => '**********'
core.Promise.resolve(32).then(core.log); // => 32
core.setImmediate(core.log, 42); // => 42
npm i core-js
bower install core.js
// Default
require('core-js');
// Without global namespace pollution
var core = require('core-js/library');
// Shim only
require('core-js/shim');
If you need complete build for browser, use builds from core-js/client path: default, without global namespace pollution, shim only.
Caveat: if you uses core-js with extension of native objects, require all needed core-js modules at the beginning of entry point of your application, otherwise possible conflicts.
You can require only needed modules.
require('core-js/es5'); // if you need support IE8-
require('core-js/fn/set');
require('core-js/fn/array/from');
Array.from(new Set([1, 2, 3, 2, 1])); // => [1, 2, 3]
// or, w/o global namespace pollution:
var core = require('core-js/library/es5'); // if you need support IE8-
var Set = require('core-js/library/fn/set');
var from = require('core-js/library/fn/array/from');
from(new Set([1, 2, 3, 2, 1])); // => [1, 2, 3]
Available entry points for methods / constructors, as above, excluding features from es5 module (this module requires fully in ES3 environment before all other modules).
Available namespaces: for example, core-js/es6/array (core-js/library/es6/array) contains all ES6 Array features, core-js/es6 (core-js/library/es6) contains all ES6 features.
Available (but not recommended - possible changing modules structure in future versions) inclusion by module name, for example, es6.object.statics-accept-primitives - core-js/modules/es6.object.statics-accept-primitives or core-js/library/modules/es6.object.statics-accept-primitives.
npm i core-js && cd node_modules/core-js && npm i
npm run grunt build:core.dict,es6 -- --blacklist=es6.promise,es6.math --library=on --path=custom uglify
Where core.dict and es6 are modules (namespaces) names, which will be added to the build, es6.promise and es6.math are modules (namespaces) names, which will be excluded from the build, --library=on is flag for build without global namespace pollution and custom is target file name.
Available namespaces: for example, es6.array contains ES6 Array features, es6 contains all modules whose names start with es6.
Available custom build from js code (required webpack):
require('core-js/build')({
modules: ['es6', 'core.dict'], // modules / namespaces
blacklist: ['es6.reflect'], // blacklist of modules / namespaces
library: false, // flag for build without global namespace pollution
}, function(err, code){ // callback
// ...
});
Module es5, nothing new - without examples.
Object
.create(proto | null, descriptors?) -> object
.getPrototypeOf(object) -> proto | null
.defineProperty(target, key, desc) -> target, cap for ie8-
.defineProperties(target, descriptors) -> target, cap for ie8-
.getOwnPropertyDescriptor(object, key) -> desc
.getOwnPropertyNames(object) -> array
.seal(object) -> object, cap for ie8-
.freeze(object) -> object, cap for ie8-
.preventExtensions(object) -> object, cap for ie8-
.isSealed(object) -> bool, cap for ie8-
.isFrozen(object) -> bool, cap for ie8-
.isExtensible(object) -> bool, cap for ie8-
.keys(object) -> array
Array
.isArray(var) -> bool
#slice(start?, end?) -> array, fix for ie7-
#join(string = ',') -> string, fix for ie7-
#indexOf(var, from?) -> int
#lastIndexOf(var, from?) -> int
#every(fn(val, index, @), that) -> bool
#some(fn(val, index, @), that) -> bool
#forEach(fn(val, index, @), that) -> void
#map(fn(val, index, @), that) -> array
#filter(fn(val, index, @), that) -> array
#reduce(fn(memo, val, index, @), memo?) -> var
#reduceRight(fn(memo, val, index, @), memo?) -> var
Function
#bind(object, ...args) -> boundFn(...args)
String
#trim() -> str
Date
.now() -> int
#toISOString() -> string
Modules es6.object.assign, es6.object.is, es6.object.set-prototype-of, es6.object.to-string, es6.function.name and es6.function.has-instance.
Object
.assign(target, ...src) -> target
.is(a, b) -> bool
.setPrototypeOf(target, proto | null) -> target, sham (required __proto__)
#toString() -> string, ES6 fix: @@toStringTag support
Function
#name -> string (IE9+)
#@@hasInstance(var) -> bool
var foo = {q: 1, w: 2}
, bar = {e: 3, r: 4}
, baz = {t: 5, y: 6};
Object.assign(foo, bar, baz); // => foo = {q: 1, w: 2, e: 3, r: 4, t: 5, y: 6}
Object.is(NaN, NaN); // => true
Object.is(0, -0); // => false
Object.is(42, 42); // => true
Object.is(42, '42'); // => false
function Parent(){}
function Child(){}
Object.setPrototypeOf(Child.prototype, Parent.prototype);
new Child instanceof Child; // => true
new Child instanceof Parent; // => true
var O = {};
O[Symbol.toStringTag] = 'Foo';
'' + O; // => '[object Foo]'
(function foo(){}).name // => 'foo'
Module es6.object.statics-accept-primitives. In ES6 most Object static methods should work with primitives. Example:
Object.keys('qwe'); // => ['0', '1', '2']
Object.getPrototypeOf('qwe') === String.prototype; // => true
Modules es6.array.from, es6.array.of, es6.array.copy-within, es6.array.fill, es6.array.find and es6.array.find-index.
Array
.from(iterable | array-like, mapFn(val, index)?, that) -> array
.of(...args) -> array
#copyWithin(target = 0, start = 0, end = @length) -> @
#fill(val, start = 0, end = @length) -> @
#find(fn(val, index, @), that) -> val
#findIndex(fn(val, index, @), that) -> index
#@@unscopables -> object (cap)
Array.from(new Set([1, 2, 3, 2, 1])); // => [1, 2, 3]
Array.from({0: 1, 1: 2, 2: 3, length: 3}); // => [1, 2, 3]
Array.from('123', Number); // => [1, 2, 3]
Array.from('123', function(it){
return it * it;
}); // => [1, 4, 9]
Array.of(1); // => [1]
Array.of(1, 2, 3); // => [1, 2, 3]
function isOdd(val){
return val % 2;
}
[4, 8, 15, 16, 23, 42].find(isOdd); // => 15
[4, 8, 15, 16, 23, 42].findIndex(isOdd); // => 2
[4, 8, 15, 16, 23, 42].find(isNaN); // => undefined
[4, 8, 15, 16, 23, 42].findIndex(isNaN); // => -1
Array(5).fill(42); // => [42, 42, 42, 42, 42]
[1, 2, 3, 4, 5].copyWithin(0, 3); // => [4, 5, 3, 4, 5]
Modules es6.string.from-code-point, es6.string.raw, es6.string.code-point-at, es6.string.ends-with, es6.string.includes, es6.string.repeat, es6.string.starts-with and es6.regexp.
String
.fromCodePoint(...codePoints) -> str
.raw({raw}, ...substitutions) -> str
#includes(str, from?) -> bool
#startsWith(str, from?) -> bool
#endsWith(str, from?) -> bool
#repeat(num) -> str
#codePointAt(pos) -> uint
[new] RegExp(pattern, flags?) -> regexp, ES6 fix: can alter flags (IE9+)
#flags -> str (IE9+)
'foobarbaz'.includes('bar'); // => true
'foobarbaz'.includes('bar', 4); // => false
'foobarbaz'.startsWith('foo'); // => true
'foobarbaz'.startsWith('bar', 3); // => true
'foobarbaz'.endsWith('baz'); // => true
'foobarbaz'.endsWith('bar', 6); // => true
'string'.repeat(3); // => 'stringstringstring'
'𠮷'.codePointAt(0); // => 134071
String.fromCodePoint(97, 134071, 98); // => 'a𠮷b'
var name = 'Bob';
String.raw`Hi\n${name}!`; // => 'Hi\\nBob!' (ES6 template string syntax)
String.raw({raw: 'test'}, 0, 1, 2); // => 't0e1s2t'
RegExp(/./g, 'm'); // => /./m
/foo/.flags; // => ''
/foo/gim.flags; // => 'gim'
Module es6.number.constructor. Number constructor support binary and octal literals, example:
Number('0b1010101'); // => 85
Number('0o7654321'); // => 2054353
Modules es6.number.statics and es6.math.
Number
.EPSILON -> num
.isFinite(num) -> bool
.isInteger(num) -> bool
.isNaN(num) -> bool
.isSafeInteger(num) -> bool
.MAX_SAFE_INTEGER -> int
.MIN_SAFE_INTEGER -> int
.parseFloat(str) -> num
.parseInt(str) -> int
Math
.acosh(num) -> num
.asinh(num) -> num
.atanh(num) -> num
.cbrt(num) -> num
.clz32(num) -> uint
.cosh(num) -> num
.expm1(num) -> num
.fround(num) -> num
.hypot(...args) -> num
.imul(num, num) -> int
.log1p(num) -> num
.log10(num) -> num
.log2(num) -> num
.sign(num) -> 1 | -1 | 0 | -0 | NaN
.sinh(num) -> num
.tanh(num) -> num
.trunc(num) -> num
Module es6.symbol.
Symbol(description?) -> symbol
.hasInstance -> @@hasInstance
.isConcatSpreadable -> @@isConcatSpreadable
.iterator -> @@iterator
.match -> @@match
.replace -> @@replace
.search -> @@search
.species -> @@species
.split -> @@split
.toPrimitive -> @@toPrimitive
.toStringTag -> @@toStringTag
.unscopables -> @@unscopables
.for(key) -> symbol
.keyFor(symbol) -> key
.useSimple() -> void
.useSetter() -> void
Object
.getOwnPropertySymbols(object) -> array
Also wrapped some Object methods for correct work with Symbol polyfill.
var Person = (function(){
var NAME = Symbol('name');
function Person(name){
this[NAME] = name;
}
Person.prototype.getName = function(){
return this[NAME];
};
return Person;
})();
var person = new Person('Vasya');
log(person.getName()); // => 'Vasya'
log(person['name']); // => undefined
log(person[Symbol('name')]); // => undefined, symbols are uniq
for(var key in person)log(key); // => only 'getName', symbols are not enumerable
Symbol.for & Symbol.keyFor example:
var symbol = Symbol.for('key');
symbol === Symbol.for('key'); // true
Symbol.keyFor(symbol); // 'key'
Example with methods for getting own object keys:
var O = {a: 1};
Object.defineProperty(O, 'b', {value: 2});
O[Symbol('c')] = 3;
Object.keys(O); // => ['a']
Object.getOwnPropertyNames(O); // => ['a', 'b']
Object.getOwnPropertySymbols(O); // => [Symbol(c)]
Reflect.ownKeys(O); // => ['a', 'b', Symbol(c)]
Symbol polyfill:Symbol returns object.Symbol polyfill defines setter in Object.prototype. For this reason, the in operator is not working correctly with Symbol polyfill: Symbol() in {} // => true.You can disable defining setter in Object.prototype. Example:
Symbol.useSimple();
var s1 = Symbol('s1')
, o1 = {};
o1[s1] = true;
for(var key in o1)log(key); // => 'Symbol(s1)_t.qamkg9f3q', w/o native Symbol
Symbol.useSetter();
var s2 = Symbol('s2')
, o2 = {};
o2[s2] = true;
for(var key in o2)log(key); // nothing
core-js uses native collections in most case, just fixes methods / constructor, if it's required, and in old environment uses fast polyfill (O(1) lookup).
Module es6.map. About iterators from this module here.
new Map(iterable (entries) ?) -> map
#clear() -> void
#delete(key) -> bool
#forEach(fn(val, key, @), that) -> void
#get(key) -> val
#has(key) -> bool
#set(key, val) -> @
#size -> uint
var a = [1];
var map = new Map([['a', 1], [42, 2]]);
map.set(a, 3).set(true, 4);
log(map.size); // => 4
log(map.has(a)); // => true
log(map.has([1])); // => false
log(map.get(a)); // => 3
map.forEach(function(val, key){
log(val); // => 1, 2, 3, 4
log(key); // => 'a', 42, [1], true
});
map.delete(a);
log(map.size); // => 3
log(map.get(a)); // => undefined
log(Array.from(map)); // => [['a', 1], [42, 2], [true, 4]]
Module es6.set. About iterators from this module here.
new Set(iterable?) -> set
#add(key) -> @
#clear() -> void
#delete(key) -> bool
#forEach(fn(el, el, @), that) -> void
#has(key) -> bool
#size -> uint
var set = new Set(['a', 'b', 'a', 'c']);
set.add('d').add('b').add('e');
log(set.size); // => 5
log(set.has('b')); // => true
set.forEach(function(it){
log(it); // => 'a', 'b', 'c', 'd', 'e'
});
set.delete('b');
log(set.size); // => 4
log(set.has('b')); // => false
log(Array.from(set)); // => ['a', 'c', 'd', 'e']
Module es6.weak-map.
new WeakMap(iterable (entries) ?) -> weakmap
#delete(key) -> bool
#get(key) -> val
#has(key) -> bool
#set(key, val) -> @
var a = [1]
, b = [2]
, c = [3];
var wmap = new WeakMap([[a, 1], [b, 2]]);
wmap.set(c, 3).set(b, 4);
log(wmap.has(a)); // => true
log(wmap.has([1])); // => false
log(wmap.get(a)); // => 1
wmap.delete(a);
log(wmap.get(a)); // => undefined
// Private properties store:
var Person = (function(){
var names = new WeakMap;
function Person(name){
names.set(this, name);
}
Person.prototype.getName = function(){
return names.get(this);
};
return Person;
})();
var person = new Person('Vasya');
log(person.getName()); // => 'Vasya'
for(var key in person)log(key); // => only 'getName'
Module es6.weak-set.
new WeakSet(iterable?) -> weakset
#add(key) -> @
#delete(key) -> bool
#has(key) -> bool
var a = [1]
, b = [2]
, c = [3];
var wset = new WeakSet([a, b, a]);
wset.add(c).add(b).add(c);
log(wset.has(b)); // => true
log(wset.has([2])); // => false
wset.delete(b);
log(wset.has(b)); // => false
Modules es6.string.iterator and es6.array.iterator:
String
#@@iterator() -> iterator
Array
#values() -> iterator
#keys() -> iterator
#entries() -> iterator (entries)
#@@iterator() -> iterator
Arguments
#@@iterator() -> iterator (sham, available only in core-js methods)
Modules es6.map and es6.set:
Map
#values() -> iterator
#keys() -> iterator
#entries() -> iterator (entries)
#@@iterator() -> iterator (entries)
Set
#values() -> iterator
#keys() -> iterator
#entries() -> iterator (entries)
#@@iterator() -> iterator
Module web.dom.iterable:
NodeList
#@@iterator() -> iterator
var string = 'a𠮷b';
for(var val of string)log(val); // => 'a', '𠮷', 'b'
var array = ['a', 'b', 'c'];
for(var val of array)log(val); // => 'a', 'b', 'c'
for(var val of array.values())log(val); // => 'a', 'b', 'c'
for(var key of array.keys())log(key); // => 0, 1, 2
for(var [key, val] of array.entries()){
log(key); // => 0, 1, 2
log(val); // => 'a', 'b', 'c'
}
var map = new Map([['a', 1], ['b', 2], ['c', 3]]);
for(var [key, val] of map){
log(key); // => 'a', 'b', 'c'
log(val); // => 1, 2, 3
}
for(var val of map.values())log(val); // => 1, 2, 3
for(var key of map.keys())log(key); // => 'a', 'b', 'c'
for(var [key, val] of map.entries()){
log(key); // => 'a', 'b', 'c'
log(val); // => 1, 2, 3
}
var set = new Set([1, 2, 3, 2, 1]);
for(var val of set)log(val); // => 1, 2, 3
for(var val of set.values())log(val); // => 1, 2, 3
for(var key of set.keys())log(key); // => 1, 2, 3
for(var [key, val] of set.entries()){
log(key); // => 1, 2, 3
log(val); // => 1, 2, 3
}
for(var x of document.querySelectorAll('*')){
log(x.id);
}
Module core.iter-helpers - helpers for check iterable / get iterator in library version or, for example, for arguments object:
core
.isIterable(var) -> bool
.getIterator(iterable) -> iterator
var list = (function(){
return arguments;
})(1, 2, 3);
log(core.isIterable(list)); // true;
var iter = core.getIterator(list);
log(iter.next().value); // 1
log(iter.next().value); // 2
log(iter.next().value); // 3
log(iter.next().value); // undefined
Module core.$for - iterators chaining - for-of and array / generator comprehensions helpers for ES5- syntax.
$for(iterable, entries) -> iterator ($for)
#of(fn(value, key?), that) -> void
#array(mapFn(value, key?)?, that) -> array
#filter(fn(value, key?), that) -> iterator ($for)
#map(fn(value, key?), that) -> iterator ($for)
$for(new Set([1, 2, 3, 2, 1])).of(function(it){
log(it); // => 1, 2, 3
});
$for([1, 2, 3].entries(), true).of(function(key, value){
log(key); // => 0, 1, 2
log(value); // => 1, 2, 3
});
$for('abc').of(console.log, console); // => 'a', 'b', 'c'
$for([1, 2, 3, 4, 5]).of(function(it){
log(it); // => 1, 2, 3
if(it == 3)return false;
});
var ar1 = $for([1, 2, 3]).array(function(v){
return v * v;
}); // => [1, 4, 9]
var set = new Set([1, 2, 3, 2, 1]);
var ar1 = $for(set).filter(function(v){
return v % 2;
}).array(function(v){
return v * v;
}); // => [1, 9]
var iter = $for(set).filter(function(v){
return v % 2;
}).map(function(v){
return v * v;
});
iter.next(); // => {value: 1, done: false}
iter.next(); // => {value: 9, done: false}
iter.next(); // => {value: undefined, done: true}
var map1 = new Map([['a', 1], ['b', 2], ['c', 3]]);
var map2 = new Map($for(map1, true).filter(function(k, v){
return v % 2;
}).map(function(k, v){
return [k + k, v * v];
})); // => Map {aa: 1, cc: 9}
Module es6.promise.
new Promise(executor(resolve(var), reject(var))) -> promise
#then(resolved(var), rejected(var)) -> promise
#catch(rejected(var)) -> promise
.resolve(var || promise) -> promise
.reject(var) -> promise
.all(iterable) -> promise
.race(iterable) -> promise
Basic example:
function sleepRandom(time){
return new Promise(function(resolve, reject){
setTimeout(resolve, time * 1e3, 0 | Math.random() * 1e3);
});
}
log('Run'); // => Run
sleepRandom(5).then(function(result){
log(result); // => 869, after 5 sec.
return sleepRandom(10);
}).then(function(result){
log(result); // => 202, after 10 sec.
}).then(function(){
log('immediately after'); // => immediately after
throw Error('Irror!');
}).then(function(){
log('will not be displayed');
}).catch(log); // => => Error: Irror!
Promise.resolve and Promise.reject example:
Promise.resolve(42).then(log); // => 42
Promise.reject(42).catch(log); // => 42
Promise.resolve($.getJSON('/data.json')); // => ES6 promise
Promise.all example:
Promise.all([
'foo',
sleepRandom(5),
sleepRandom(15),
sleepRandom(10) // after 15 sec:
]).then(log); // => ['foo', 956, 85, 382]
Promise.race example:
function timeLimit(promise, time){
return Promise.race([promise, new Promise(function(resolve, reject){
setTimeout(reject, time * 1e3, Error('Await > ' + time + ' sec'));
})]);
}
timeLimit(sleepRandom(5), 10).then(log); // => 853, after 5 sec.
timeLimit(sleepRandom(15), 10).catch(log); // Error: Await > 10 sec
ECMAScript 7 async functions example:
var delay = time => new Promise(resolve => setTimeout(resolve, time))
async function sleepRandom(time){
await delay(time * 1e3);
return 0 | Math.random() * 1e3;
};
async function sleepError(time, msg){
await delay(time * 1e3);
throw Error(msg);
};
(async () => {
try {
log('Run'); // => Run
log(await sleepRandom(5)); // => 936, after 5 sec.
var [a, b, c] = await Promise.all([
sleepRandom(5),
sleepRandom(15),
sleepRandom(10)
]);
log(a, b, c); // => 210 445 71, after 15 sec.
await sleepError(5, 'Irror!');
log('Will not be displayed');
} catch(e){
log(e); // => Error: 'Irror!', after 5 sec.
}
})();
Module es6.reflect.
Reflect
.apply(target, thisArgument, argumentsList) -> var
.construct(target, argumentsList, newTarget?) -> object
.defineProperty(target, propertyKey, attributes) -> bool
.deleteProperty(target, propertyKey) -> bool
.enumerate(target) -> iterator
.get(target, propertyKey, receiver?) -> var
.getOwnPropertyDescriptor(target, propertyKey) -> desc
.getPrototypeOf(target) -> object | null
.has(target, propertyKey) -> bool
.isExtensible(target) -> bool
.ownKeys(target) -> array
.preventExtensions(target) -> bool
.set(target, propertyKey, V, receiver?) -> bool
.setPrototypeOf(target, proto) -> bool, sham(ie11+)
var O = {a: 1};
Object.defineProperty(O, 'b', {value: 2});
O[Symbol('c')] = 3;
Reflect.ownKeys(O); // => ['a', 'b', Symbol(c)]
function C(a, b){
this.c = a + b;
}
var instance = Reflect.construct(C, [20, 22]);
instance.c; // => 42
Array#includes proposal - module es7.array.includesString#at proposal - module es7.string.atString#lpad, String#rpad proposal - modules es7.string.lpad, es7.string.rpadObject.values, Object.entries tc39 discuss - module es7.object.to-arrayObject.getOwnPropertyDescriptors proposal - module es7.object.get-own-property-descriptorsRegExp.escape proposal - module es7.regexp.escapeMap#toJSON, Set#toJSON proposal - modules es7.map.to-json, es7.set.to-jsonArray
#includes(var, from?) -> bool
String
#at(index) -> string
#lpad(length, fillStr = ' ') -> string
#rpad(length, fillStr = ' ') -> string
Object
.values(object) -> array
.entries(object) -> array
.getOwnPropertyDescriptors(object) -> object
RegExp
.escape(str) -> str
Map
#toJSON() -> array
Set
#toJSON() -> array
[1, 2, 3].includes(2); // => true
[1, 2, 3].includes(4); // => false
[1, 2, 3].includes(2, 2); // => false
[NaN].indexOf(NaN); // => -1
[NaN].includes(NaN); // => true
Array(1).indexOf(undefined); // => -1
Array(1).includes(undefined); // => true
'a𠮷b'.at(1); // => '𠮷'
'a𠮷b'.at(1).length; // => 2
'hello'.lpad(10); // => ' hello'
'hello'.lpad(10, '1234'); // => '41234hello'
'hello'.rpad(10); // => 'hello '
'hello'.rpad(10, '1234'); // => 'hello12341'
Object.values({a: 1, b: 2, c: 3}); // => [1, 2, 3]
Object.entries({a: 1, b: 2, c: 3}); // => [['a', 1], ['b', 2], ['c', 3]]
// Shallow object cloning with prototype and descriptors:
var copy = Object.create(Object.getPrototypeOf(O), Object.getOwnPropertyDescriptors(O));
// Mixin:
Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
RegExp.escape('Hello -[]{}()*+?.,\\^$|'); // => 'Hello \-\[\]\{\}\(\)\*\+\?\.\,\\\^\$\|'
JSON.stringify(new Map([['a', 'b'], ['c', 'd']])); // => '[["a","b"],["c","d"]]'
JSON.stringify(new Set([1, 2, 3, 2, 1])); // => '[1,2,3]'
Module js.array.statics.
Array
.{...ArrayPrototype methods}
Array.slice(arguments, 1);
Array.join('abcdef', '+'); // => 'a+b+c+d+e+f'
var form = document.getElementsByClassName('form__input');
Array.reduce(form, function(memo, it){
memo[it.name] = it.value;
return memo;
}, {}); // => {name: 'Vasya', age: '42', sex: 'yes, please'}
Module web.timers. Additional arguments fix for IE9-.
setTimeout(fn(...args), time, ...args) -> id
setInterval(fn(...args), time, ...args) -> id
// Before:
setTimeout(log.bind(null, 42), 1000);
// After:
setTimeout(log, 1000, 42);
Module web.immediate. setImmediate polyfill.
setImmediate(fn(...args), ...args) -> id
clearImmediate(id) -> void
setImmediate(function(arg1, arg2){
log(arg1, arg2); // => Message will be displayed with minimum delay
}, 'Message will be displayed', 'with minimum delay');
clearImmediate(setImmediate(function(){
log('Message will not be displayed');
}));
Module core.log. Console cap for old browsers and some additional functionality. In IE, Node.js / IO.js and Firebug console methods not require call from console object, but in Chromium and V8 this throws error. For some reason, we can't replace console methods by their bound versions. Add log object with bound console methods. Some more sugar: log is shortcut for log.log, we can disable output.
log ==== log.log
.{...console API}
.enable() -> void
.disable() -> void
// Before:
if(window.console && console.warn)console.warn(42);
// After:
log.warn(42);
// Before:
setTimeout(console.warn.bind(console, 42), 1000);
[1, 2, 3].forEach(console.warn, console);
// After:
setTimeout(log.warn, 1000, 42);
[1, 2, 3].forEach(log.warn);
// log is shortcut for log.log
setImmediate(log, 42); // => 42
log.disable();
log.warn('Console is disabled, you will not see this message.');
log.enable();
log.warn('Console is enabled again.');
Module core.object.
Object
.isObject(var) -> bool
.classof(var) -> string
.define(target, mixin) -> target
.make(proto | null, mixin?) -> object
Object classify examples:
Object.isObject({}); // => true
Object.isObject(isNaN); // => true
Object.isObject(null); // => false
var classof = Object.classof;
classof(null); // => 'Null'
classof(undefined); // => 'Undefined'
classof(1); // => 'Number'
classof(true); // => 'Boolean'
classof('string'); // => 'String'
classof(Symbol()); // => 'Symbol'
classof(new Number(1)); // => 'Number'
classof(new Boolean(true)); // => 'Boolean'
classof(new String('string')); // => 'String'
var fn = function(){}
, list = (function(){return arguments})(1, 2, 3);
classof({}); // => 'Object'
classof(fn); // => 'Function'
classof([]); // => 'Array'
classof(list); // => 'Arguments'
classof(/./); // => 'RegExp'
classof(new TypeError); // => 'Error'
classof(new Set); // => 'Set'
classof(new Map); // => 'Map'
classof(new WeakSet); // => 'WeakSet'
classof(new WeakMap); // => 'WeakMap'
classof(new Promise(fn)); // => 'Promise'
classof([].values()); // => 'Array Iterator'
classof(new Set().values()); // => 'Set Iterator'
classof(new Map().values()); // => 'Map Iterator'
classof(Math); // => 'Math'
classof(JSON); // => 'JSON'
function Example(){}
Example.prototype[Symbol.toStringTag] = 'Example';
classof(new Example); // => 'Example'
Object.define and Object.make examples:
// Before:
Object.defineProperty(target, 'c', {
enumerable: true,
configurable: true,
get: function(){
return this.a + this.b;
}
});
// After:
Object.define(target, {
get c(){
return this.a + this.b;
}
});
// Shallow object cloning with prototype and descriptors:
var copy = Object.make(Object.getPrototypeOf(src), src);
// Simple inheritance:
function Vector2D(x, y){
this.x = x;
this.y = y;
}
Object.define(Vector2D.prototype, {
get xy(){
return Math.hypot(this.x, this.y);
}
});
function Vector3D(x, y, z){
Vector2D.apply(this, arguments);
this.z = z;
}
Vector3D.prototype = Object.make(Vector2D.prototype, {
constructor: Vector3D,
get xyz(){
return Math.hypot(this.x, this.y, this.z);
}
});
var vector = new Vector3D(9, 12, 20);
log(vector.xy); // => 15
log(vector.xyz); // => 25
vector.y++;
log(vector.xy); // => 15.811388300841896
log(vector.xyz); // => 25.495097567963924
Module core.dict. Based on TC39 discuss / strawman.
[new] Dict(iterable (entries) | object ?) -> dict
.isDict(var) -> bool
.values(object) -> iterator
.keys(object) -> iterator
.entries(object) -> iterator (entries)
.has(object, key) -> bool
.get(object, key) -> val
.set(object, key, value) -> object
.forEach(object, fn(val, key, @), that) -> void
.map(object, fn(val, key, @), that) -> new @
.mapPairs(object, fn(val, key, @), that) -> new @
.filter(object, fn(val, key, @), that) -> new @
.some(object, fn(val, key, @), that) -> bool
.every(object, fn(val, key, @), that) -> bool
.find(object, fn(val, key, @), that) -> val
.findKey(object, fn(val, key, @), that) -> key
.keyOf(object, var) -> key
.includes(object, var) -> bool
.reduce(object, fn(memo, val, key, @), memo?) -> var
.turn(object, fn(memo, val, key, @), memo = new @) -> memo
Dict create object without prototype from iterable or simple object. Example:
var map = new Map([['a', 1], ['b', 2], ['c', 3]]);
Dict(); // => {__proto__: null}
Dict({a: 1, b: 2, c: 3}); // => {__proto__: null, a: 1, b: 2, c: 3}
Dict(map); // => {__proto__: null, a: 1, b: 2, c: 3}
Dict([1, 2, 3].entries()); // => {__proto__: null, 0: 1, 1: 2, 2: 3}
var dict = Dict({a: 42});
dict instanceof Object; // => false
dict.a; // => 42
dict.toString; // => undefined
'a' in dict; // => true
'hasOwnProperty' in dict; // => false
Dict.isDict({}); // => false
Dict.isDict(Dict()); // => true
Dict.keys, Dict.values and Dict.entries returns iterators for objects, examples:
var dict = {a: 1, b: 2, c: 3};
for(var key of Dict.keys(dict))log(key); // => 'a', 'b', 'c'
for(var val of Dict.values(dict))log(val); // => 1, 2, 3
for(var [key, val] of Dict.entries(dict)){
log(key); // => 'a', 'b', 'c'
log(val); // => 1, 2, 3
}
new Map(Dict.entries(dict)); // => Map {a: 1, b: 2, c: 3}
new Map((for([k, v] of Dict.entries(dict))if(v % 2)[k + k, v * v])); // => Map {aa: 1, cc: 9}
Basic dict operations for objects with prototype example:
'q' in {q: 1}; // => true
'toString' in {}; // => true
Dict.has({q: 1}, 'q'); // => true
Dict.has({}, 'toString'); // => false
({q: 1})['q']; // => 1
({}).toString; // => function toString(){ [native code] }
Dict.get({q: 1}, 'q'); // => 1
Dict.get({}, 'toString'); // => undefined
var O = {};
O['q'] = 1;
O['q']; // => 1
O['__proto__'] = {w: 2};
O['__proto__']; // => {w: 2}
O['w']; // => 2
var O = {};
Dict.set(O, 'q', 1);
O['q']; // => 1
Dict.set(O, '__proto__', {w: 2});
O['__proto__']; // => {w: 2}
O['w']; // => undefined
Other methods of Dict module are static equialents of Array.prototype methods for dictionaries, examples:
var dict = {a: 1, b: 2, c: 3};
Dict.forEach(dict, console.log, console);
// => 1, 'a', {a: 1, b: 2, c: 3}
// => 2, 'b', {a: 1, b: 2, c: 3}
// => 3, 'c', {a: 1, b: 2, c: 3}
Dict.map(dict, function(it){
return it * it;
}); // => {a: 1, b: 4, c: 9}
Dict.mapPairs(dict, function(val, key){
if(key != 'b')return [key + key, val * val];
}); // => {aa: 1, cc: 9}
Dict.filter(dict, function(it){
return it % 2;
}); // => {a: 1, c: 3}
Dict.some(dict, function(it){
return it === 2;
}); // => true
Dict.every(dict, function(it){
return it === 2;
}); // => false
Dict.find(dict, function(it){
return it > 2;
}); // => 3
Dict.find(dict, function(it){
return it > 4;
}); // => undefined
Dict.findKey(dict, function(it){
return it > 2;
}); // => 'c'
Dict.findKey(dict, function(it){
return it > 4;
}); // => undefined
Dict.keyOf(dict, 2); // => 'b'
Dict.keyOf(dict, 4); // => undefined
Dict.includes(dict, 2); // => true
Dict.includes(dict, 4); // => false
Dict.reduce(dict, function(memo, it){
return memo + it;
}); // => 6
Dict.reduce(dict, function(memo, it){
return memo + it;
}, ''); // => '123'
Dict.turn(dict, function(memo, it, key){
memo[key + key] = it;
}); // => {aa: 1, bb: 2, cc: 3}
Dict.turn(dict, function(memo, it, key){
it % 2 && memo.push(key + it);
}, []); // => ['a1', 'c3']
Module core.function.part.
Function
#part(...args | _) -> fn(...args)
Function#part partial apply function without this binding. Uses global variable _ (core._ for builds without global namespace pollution) as placeholder and not conflict with Underscore / LoDash. Examples:
var fn1 = log.part(1, 2);
fn1(3, 4); // => 1, 2, 3, 4
var fn2 = log.part(_, 2, _, 4);
fn2(1, 3); // => 1, 2, 3, 4
var fn3 = log.part(1, _, _, 4);
fn3(2, 3); // => 1, 2, 3, 4
fn2(1, 3, 5); // => 1, 2, 3, 4, 5
fn2(1); // => 1, 2, undefined, 4
Module core.date. Much more simple and compact (~60 lines with en & ru locales) than Intl or Moment.js. Use them if you need extended work with Date.
Date
#format(str, key?) -> str
#formatUTC(str, key?) -> str
core
.addLocale(key, object) -> core
.locale(key?) -> key
| Token | Unit | Sample |
|---|---|---|
| s | Seconds | 0-59 |
| ss | Seconds, 2 digits | 00-59 |
| m | Minutes | 0-59 |
| mm | Minutes, 2 digits | 00-59 |
| h | Hours | 0-23 |
| hh | Hours, 2 digits | 00-23 |
| D | Date | 1-31 |
| DD | Date, 2 digits | 01-31 |
| W | Weekday, string | Вторник |
| N | Month | 1-12 |
| NN | Month, 2 digits | 01-12 |
| M | Month, string | Ноябрь |
| MM | Of month, string | Ноября |
| Y | Year, full | 2014 |
| YY | Year, 2 digits | 14 |
| Examples: |
new Date().format('W, MM D, YY, h:mm:ss'); // => 'Friday, November 28, 14, 18:47:05'
new Date().formatUTC('W, MM D, YY, h:mm:ss'); // => 'Friday, November 28, 14, 12:47:05'
new Date().format('W, D MM Y г., h:mm:ss', 'ru'); // => 'Пятница, 28 Ноября 2014 г., 18:07:25'
core.locale('ru');
new Date().format('W, D MM Y г., h:mm:ss'); // => 'Пятница, 28 Ноября 2014 г., 18:07:25'
new Date().format('DD.NN.YY'); // => '28.11.14'
new Date().format('hh:mm:ss'); // => '18:47:05'
new Date().format('DD.NN.Y hh:mm:ss'); // => '28.11.2014 18:47:05'
new Date().format('W, D MM Y года'); // => 'Пятница, 28 Ноября 2014 года'
new Date().format('D MM, h:mm'); // => '28 Ноября, 16:47'
new Date().format('M Y'); // => 'Ноябрь 2014'
(typeof core != 'undefined' ? core : require('core-js/library')).addLocale('ru', {
weekdays: 'Воскресенье,Понедельник,Вторник,Среда,Четверг,Пятница,Суббота',
months: 'Январ:я|ь,Феврал:я|ь,Март:а|,Апрел:я|ь,Ма:я|й,Июн:я|ь,Июл:я|ь,Август:а|,Сентябр:я|ь,Октябр:я|ь,Ноябр:я|ь,Декабр:я|ь'
});
Module core.array.turn.
Array
#turn(fn(memo, val, index, @), memo = []) -> memo
Method Array#turn reduce array to object, example:
[1, 2, 3, 4, 5].turn(function(memo, it){
memo['key' + it] = !!(it % 2);
}, {}); // => {key1: true, key2: false, key3: true, key4: false, key5: true}
[1, 2, 3, 4, 5, 6, 7, 8, 9].turn(function(memo, it){
it % 2 && memo.push(it * it);
if(memo.length == 3)return false;
}); // => [1, 9, 25]
Modules core.number.iterator and core.number.math.
Number
#@@iterator() -> iterator
#random(lim = 0) -> num
#{...Math}
Number Iterator examples:
for(var i of 3)log(i); // => 0, 1, 2
Array.from(10, Math.random); // => [0.9817775336559862, 0.02720663254149258, ...]
Array.from(10); // => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Array.from(10, function(it){
return this + it * it;
}, .42); // => [0.42, 1.42, 4.42, 9.42, 16.42, 25.42, 36.42, 49.42, 64.42, 81.42]
// Comprehensions:
[for(i of 10)if(i % 2)i * i]; // => [1, 9, 25, 49, 81]
Dict((for(i of 3)['key' + i, !(i % 2)])); // => {key0: true, key1: false, key2: true}
Math methods in Number.prototype examples:
3..pow(3); // => 27
(-729).abs().sqrt(); // => 27
10..random(20); // => Random number (10, 20), for example, 16.818793776910752
10..random(20).floor(); // => Random integer [10, 19], for example, 16
var array = [1, 2, 3, 4, 5];
array[array.length.random().floor()]; // => Random element, for example, 4
Module core.string.escape-html.
String
#escapeHTML() -> str
#unescapeHTML() -> str
'<script>doSomething();</script>'.escapeHTML(); // => '<script>doSomething();</script>'
'<script>doSomething();</script>'.unescapeHTML(); // => '<script>doSomething();</script>'
Module core.delay. Promise-returning delay function, esdiscuss. Example:
delay(1e3).then(() => log('after 1 sec'));
(async () => {
await delay(3e3);
log('after 3 sec');
while(await delay(3e3))log('each 3 sec');
})();
library version return wrapped native instanceslibrary versionMath.hypotPromise.resolve behaviorObject.getOwnPropertyNames + iframeSymbol polyfill for old Androidcore-js should use / recognize the same symbolsgrunt-cli to devDependencies for npm run gruntFunction#toString for correct work wrapped methods / constructors with methods similar to the lodash isNativedefault version for consistency with library versionObject#propertyIsEnumerable for Symbol polyfilllibrary for ES7 bind syntaxMath.hypot with negative argumentsObject#toString.toString as fallback for lodash isNativeArray#sliceString#lpad, String#rpadFunction#@@hasInstanceRegExp constructorPromise unhandled rejection tracking and resolving / rejection priority__proto__-based Promise subclassing in some environmentsObject.{assign, create, defineProperty, defineProperties, getOwnPropertyDescriptor, getOwnPropertyDescriptors} with symbolsObject.{create, defineProperty, defineProperties}Map#toJSONObject#[_] and Function#only - they solves syntax problems, but now in compilers available arrows and Symbol.{pure, set}webpack instead of browserify for browser builds - more compression-friendly resultArray statics with single entry pointsMath.fround now also works in IE9-Set#toJSONSymbol.keyFor$for.isIterable -> core.isIterable, $for.getIterator -> core.getIterator, temporary available in old namespacePromise.all and Promise.raceObject.defineProperty with accessors on DOM elements on IE8iterator.return on abort iteration, if it existsPromise unhandled rejection tracking in shimObject.getOwnPropertyDescriptorsconsole cap - creates too many problems - you can use core.log module as thatNumber constructorDate#toISOStringes6 moduleconsole module: web.console - only cap for missing methods, core.log - bound methods & additional featuresdelay methodObject.getOwnPropertySymbols polyfill returns array of wrapped keysObject.getOwnPropertySymbolsNodeList.prototype[@@iterator]@@species logic - getter in native constructorsFunction#byFunction instances name property for IE9+Object static methods accept primitivesRegExp constructor can alter flags (IE9+)Array.prototype[Symbol.unscopables]es6.reflect module:
Reflect.applyReflect.constructReflect.definePropertyReflect.deletePropertyReflect.enumerateReflect.getReflect.getOwnPropertyDescriptorReflect.getPrototypeOfReflect.hasReflect.isExtensibleReflect.preventExtensionsReflect.setReflect.setPrototypeOfcore-js methods now can use external Symbol.iterator polyfillconsole bugMap & Set:
es6 and es6.collections modulesconsole no longer shortcut for console.log (compatibility problems)Math.fround (IE10+)Object.prototype for Symbol polyfill:
Symbol.useSimpleSymbol.useSetterSymbol.hasInstanceSymbol.isConcatSpreadableSymbol.matchSymbol.replaceSymbol.searchSymbol.speciesSymbol.splitSymbol.toPrimitiveSymbol.unscopablesRegExp#flags (December 2014 Draft Rev 29)String.rawes7.proposals and es7.abstract-refs modulesString#atString Iterator, older versions used Array IteratorSymbol.referenceGetSymbol.referenceSetSymbol.referenceDeleteFunction#@@referenceGetMap#@@referenceGetMap#@@referenceSetMap#@@referenceDeleteWeakMap#@@referenceGetWeakMap#@@referenceSetWeakMap#@@referenceDeleteDict.{...methods}[@@referenceGet].contains methodsArray#copyWithinString#codePointAtString.fromCodePointDict.mapPairs.contains -> .includes
String#contains -> String#includesArray#contains -> Array#includesDict.contains -> Dict.includesWeakMap#clearWeakSet#clearMap & Set bug fixlibrary version return wrapped native instanceslibrary versionMath.hypotFAQs
Standard library
The npm package core-js receives a total of 14,987,800 weekly downloads. As such, core-js popularity was classified as popular.
We found that core-js demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Research
A malicious npm package disguised as a WhatsApp client is exploiting authentication flows with a remote kill switch to exfiltrate data and destroy files.
Security News
PyPI now supports digital attestations, enhancing security and trust by allowing package maintainers to verify the authenticity of Python packages.
Security News
GitHub removed 27 malicious pull requests attempting to inject harmful code across multiple open source repositories, in another round of low-effort attacks.