core-js
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 or extended partial application. You can require only standardized features polyfills, use features without global namespace pollution or create a custom build.
Example:
Array.from(new Set([1, 2, 3, 2, 1]));
'*'.repeat(10);
Promise.resolve(32).then(log);
setImmediate(log, 42);
Without global namespace pollution:
var core = require('core-js/library');
core.Array.from(new core.Set([1, 2, 3, 2, 1]));
core.String.repeat('*', 10);
core.Promise.resolve(32).then(core.log);
core.setImmediate(core.log, 42);
Usage
Basic
npm i core-js
bower install core.js
require('core-js');
var core = require('core-js/library');
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.
Warning: if you uses core-js
with the extension of native objects, require all needed core-js
modules at the beginning of entry point of your application, otherwise maybe conflicts.
CommonJS
You can require only needed modules.
require('core-js/es5');
require('core-js/fn/set');
require('core-js/fn/array/from');
require('core-js/fn/array/find-index');
Array.from(new Set([1, 2, 3, 2, 1]));
[1, 2, NaN, 3, 4].findIndex(isNaN);
var core = require('core-js/library/es5');
var Set = require('core-js/library/fn/set');
var from = require('core-js/library/fn/array/from');
var findIndex = require('core-js/library/fn/array/find-index');
from(new Set([1, 2, 3, 2, 1]));
findIndex([1, 2, NaN, 3, 4], isNaN);
Available entry points for methods / constructors, as above examples, excluding features from es5
module (this module requires completely 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.
Custom build
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'],
blacklist: ['es6.reflect'],
library: false,
}, function(err, code){
});
Features:
ECMAScript 5
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
.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)
Date
.now() -> int
#toISOString() -> string
Some features moved to another modules / namespaces, but available as part of es5
namespace too:
Object
.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-
String
#trim() -> str
ECMAScript 6
ECMAScript 6: Object
Modules es6.object.assign
, es6.object.is
, es6.object.set-prototype-of
and es6.object.to-string
.
Object
.assign(target, ...src) -> target
.is(a, b) -> bool
.setPrototypeOf(target, proto | null) -> target (required __proto__ - IE11+)
#toString() -> string, ES6 fix: @@toStringTag support
Example:
var foo = {q: 1, w: 2}
, bar = {e: 3, r: 4}
, baz = {t: 5, y: 6};
Object.assign(foo, bar, baz);
Object.is(NaN, NaN);
Object.is(0, -0);
Object.is(42, 42);
Object.is(42, '42');
function Parent(){}
function Child(){}
Object.setPrototypeOf(Child.prototype, Parent.prototype);
new Child instanceof Child;
new Child instanceof Parent;
var O = {};
O[Symbol.toStringTag] = 'Foo';
'' + O;
In ES6 most Object
static methods should work with primitives. Modules es6.object.freeze
, es6.object.seal
, es6.object.prevent-extensions
, es6.object.is-frozen
, es6.object.is-sealed
, es6.object.is-extensible
, es6.object.get-own-property-descriptor
, es6.object.get-prototype-of
, es6.object.keys
, es6.object.get-own-property-names
.
Object
.freeze(var) -> var
.seal(var) -> var
.preventExtensions(var) -> var
.isFrozen(var) -> bool
.isSealed(var) -> bool
.isExtensible(var) -> bool
.getOwnPropertyDescriptor(var, key) -> desc | undefined
.getPrototypeOf(var) -> object | null
.keys(var) -> array
.getOwnPropertyNames(var) -> array
Example:
Object.keys('qwe');
Object.getPrototypeOf('qwe') === String.prototype;
ECMAScript 6: Function
Modules es6.function.name
and es6.function.has-instance
.
Function
#name -> string (IE9+)
#@@hasInstance(var) -> bool
Example:
(function foo(){}).name
ECMAScript 6: Array
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)
Example:
Array.from(new Set([1, 2, 3, 2, 1]));
Array.from({0: 1, 1: 2, 2: 3, length: 3});
Array.from('123', Number);
Array.from('123', function(it){
return it * it;
});
Array.of(1);
Array.of(1, 2, 3);
function isOdd(val){
return val % 2;
}
[4, 8, 15, 16, 23, 42].find(isOdd);
[4, 8, 15, 16, 23, 42].findIndex(isOdd);
[4, 8, 15, 16, 23, 42].find(isNaN);
[4, 8, 15, 16, 23, 42].findIndex(isNaN);
Array(5).fill(42);
[1, 2, 3, 4, 5].copyWithin(0, 3);
ECMAScript 6: String
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.string.trim
.
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
#trim() -> str, ES6 fix
Examples:
'foobarbaz'.includes('bar');
'foobarbaz'.includes('bar', 4);
'foobarbaz'.startsWith('foo');
'foobarbaz'.startsWith('bar', 3);
'foobarbaz'.endsWith('baz');
'foobarbaz'.endsWith('bar', 6);
'string'.repeat(3);
'𠮷'.codePointAt(0);
String.fromCodePoint(97, 134071, 98);
var name = 'Bob';
String.raw`Hi\n${name}!`;
String.raw({raw: 'test'}, 0, 1, 2);
ECMAScript 6: RegExp
Modules es6.regexp.constructor
and es6.regexp.flags
.
Support well-known symbols @@match
, @@replace
, @@search
and @@split
, modules es6.regexp.match
, es6.regexp.replace
, es6.regexp.search
and es6.regexp.split
.
String
#match(tpl) -> var, ES6 fix for support @@match
#replace(tpl, replacer) -> var, ES6 fix for support @@replace
#search(tpl) -> var, ES6 fix for support @@search
#split(tpl, limit) -> var, ES6 fix for support @@split
[new] RegExp(pattern, flags?) -> regexp, ES6 fix: can alter flags (IE9+)
#flags -> str (IE9+)
#@@match(str) -> array | null
#@@replace(str, replacer) -> string
#@@search(str) -> index
#@@split(str, limit) -> array
Examples:
RegExp(/./g, 'm');
/foo/.flags;
/foo/gim.flags;
'foo'.match({[Symbol.match]: _ => 1});
'foo'.replace({[Symbol.replace]: _ => 2});
'foo'.search({[Symbol.search]: _ => 3});
'foo'.split({[Symbol.split]: _ => 4});
ECMAScript 6: Number
Module es6.number.constructor
. Number
constructor support binary and octal literals, example:
Number('0b1010101');
Number('0o7654321');
Number
: modules es6.number.epsilon
, es6.number.is-finite
, es6.number.is-integer
, es6.number.is-nan
, es6.number.is-safe-integer
, es6.number.max-safe-integer
, es6.number.min-safe-integer
, es6.number.parse-float
, es6.number.parse-int
.
[new] Number(var) -> number | number object
.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
ECMAScript 6: Math
Math
: modules es6.math.acosh
, es6.math.asinh
, es6.math.atanh
, es6.math.cbrt
, es6.math.clz32
, es6.math.cosh
, es6.math.expm1
, es6.math.fround
, es6.math.hypot
, es6.math.imul
, es6.math.log10
, es6.math.log1p
, es6.math.log2
, es6.math.sign
, es6.math.sinh
, es6.math.tanh
, es6.math.trunc
.
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
ECMAScript 6: Symbol
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.
Object
.create(proto | null, descriptors?) -> object
.defineProperty(target, key, desc) -> target
.defineProperties(target, descriptors) -> target
.getOwnPropertyDescriptor(var, key) -> desc | undefined
.getOwnPropertyNames(var) -> array
#propertyIsEnumerable(key) -> bool
Basic example:
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());
log(person['name']);
log(person[Symbol('name')]);
for(var key in person)log(key);
Symbol.for
& Symbol.keyFor
example:
var symbol = Symbol.for('key');
symbol === Symbol.for('key');
Symbol.keyFor(symbol);
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);
Object.getOwnPropertyNames(O);
Object.getOwnPropertySymbols(O);
Reflect.ownKeys(O);
Caveats when using Symbol
polyfill:
- We can't add new primitive type,
Symbol
returns object. Symbol.for
and Symbol.keyFor
can't be shimmed cross-realm.- By default, to hide the keys,
Symbol
polyfill defines setter in Object.prototype
. For this reason, uncontrolled creation of symbols can cause memory leak and the in
operator is not working correctly with Symbol
polyfill: Symbol() in {} // => true
.
You can disable defining setters in Object.prototype
. Example:
Symbol.useSimple();
var s1 = Symbol('s1')
, o1 = {};
o1[s1] = true;
for(var key in o1)log(key);
Symbol.useSetter();
var s2 = Symbol('s2')
, o2 = {};
o2[s2] = true;
for(var key in o2)log(key);
- Currently,
core-js
not adds setters to Object.prototype
for well-known symbols for correct work something like Symbol.iterator in foo
. It can cause problems with their enumerability.
ECMAScript 6: Collections
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).
Map
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
Example:
var a = [1];
var map = new Map([['a', 1], [42, 2]]);
map.set(a, 3).set(true, 4);
log(map.size);
log(map.has(a));
log(map.has([1]));
log(map.get(a));
map.forEach(function(val, key){
log(val);
log(key);
});
map.delete(a);
log(map.size);
log(map.get(a));
log(Array.from(map));
Set
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
Example:
var set = new Set(['a', 'b', 'a', 'c']);
set.add('d').add('b').add('e');
log(set.size);
log(set.has('b'));
set.forEach(function(it){
log(it);
});
set.delete('b');
log(set.size);
log(set.has('b'));
log(Array.from(set));
WeakMap
Module es6.weak-map
.
new WeakMap(iterable (entries) ?) -> weakmap
#delete(key) -> bool
#get(key) -> val
#has(key) -> bool
#set(key, val) -> @
Example:
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));
log(wmap.has([1]));
log(wmap.get(a));
wmap.delete(a);
log(wmap.get(a));
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());
for(var key in person)log(key);
WeakSet
Module es6.weak-set
.
new WeakSet(iterable?) -> weakset
#add(key) -> @
#delete(key) -> bool
#has(key) -> bool
Example:
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));
log(wset.has([2]));
wset.delete(b);
log(wset.has(b));
Caveats when using collections polyfill:
- Frozen objects as collection keys are supported, but not recomended - it's slow (O(n) instead of O(1)) and, for weak-collections, leak.
- Weak-collections polyfill stores values as hidden properties of keys. It works correct and not leak in most cases. However, it is desirable to store a collection longer than its keys.
ECMAScript 6: Iterators
Modules es6.string.iterator
and es6.array.iterator
:
String
#@@iterator() -> iterator
Array
#values() -> iterator
#keys() -> iterator
#entries() -> iterator (entries)
#@@iterator() -> iterator
Arguments
#@@iterator() -> iterator (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
Example:
var string = 'a𠮷b';
for(var val of string)log(val);
var array = ['a', 'b', 'c'];
for(var val of array)log(val);
for(var val of array.values())log(val);
for(var key of array.keys())log(key);
for(var [key, val] of array.entries()){
log(key);
log(val);
}
var map = new Map([['a', 1], ['b', 2], ['c', 3]]);
for(var [key, val] of map){
log(key);
log(val);
}
for(var val of map.values())log(val);
for(var key of map.keys())log(key);
for(var [key, val] of map.entries()){
log(key);
log(val);
}
var set = new Set([1, 2, 3, 2, 1]);
for(var val of set)log(val);
for(var val of set.values())log(val);
for(var key of set.keys())log(key);
for(var [key, val] of set.entries()){
log(key);
log(val);
}
for(var x of document.querySelectorAll('*')){
log(x.id);
}
Modules core.is-iterable
, core.get-iterator
, core.get-iterator-method
- helpers for check iterable / get iterator in library
version or, for example, for arguments
object:
core
.isIterable(var) -> bool
.getIterator(iterable) -> iterator
.getIteratorMethod(var) -> function | undefined
Example:
var list = (function(){
return arguments;
})(1, 2, 3);
log(core.isIterable(list));
var iter = core.getIterator(list);
log(iter.next().value);
log(iter.next().value);
log(iter.next().value);
log(iter.next().value);
core.getIterator({});
var iterFn = core.getIteratorMethod(list);
log(typeof iterFn);
var iter = iterFn.call(list);
log(iter.next().value);
log(iter.next().value);
log(iter.next().value);
log(iter.next().value);
log(core.getIteratorMethod({}));
ECMAScript 6: Promise
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');
sleepRandom(5).then(function(result){
log(result);
return sleepRandom(10);
}).then(function(result){
log(result);
}).then(function(){
log('immediately after');
throw Error('Irror!');
}).then(function(){
log('will not be displayed');
}).catch(log);
Promise.resolve
and Promise.reject
example:
Promise.resolve(42).then(log);
Promise.reject(42).catch(log);
Promise.resolve($.getJSON('/data.json'));
Promise.all
example:
Promise.all([
'foo',
sleepRandom(5),
sleepRandom(15),
sleepRandom(10)
]).then(log);
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);
timeLimit(sleepRandom(15), 10).catch(log);
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');
log(await sleepRandom(5));
var [a, b, c] = await Promise.all([
sleepRandom(5),
sleepRandom(15),
sleepRandom(10)
]);
log(a, b, c);
await sleepError(5, 'Irror!');
log('Will not be displayed');
} catch(e){
log(e);
}
})();
Unhandled rejection tracking
core-js
Promise
supports (but not adds to native implementations) unhandled rejection tracking.
Node.js:
process.on('unhandledRejection', (reason, promise) => console.log(reason, promise));
Promise.reject(42);
In a browser, by default, you will see notify in the console, or you can add a custom handler, example:
window.onunhandledrejection = e => log(e.reason, e.promise);
Promise.reject(42);
Warning: The problem here - we can't add it to native Promise
implementations, but by idea core-js
should use enough correct native implementation if it's available. Currently, most native implementations are buggy and core-js
uses polyfill, but the situation will be changed. If someone wanna use this hook everywhere - he should delete window.Promise
before inclusion core-js
.
ECMAScript 6: Reflect
Modules es6.reflect.apply
, es6.reflect.construct
, es6.reflect.define-property
, es6.reflect.delete-property
, es6.reflect.enumerate
, es6.reflect.get
, es6.reflect.get-own-property-descriptor
, es6.reflect.get-prototype-of
, es6.reflect.has
, es6.reflect.is-extensible
, es6.reflect.own-keys
, es6.reflect.prevent-extensions
, es6.reflect.set
, es6.reflect.set-prototype-of
.
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 (required __proto__ - IE11+)
Example:
var O = {a: 1};
Object.defineProperty(O, 'b', {value: 2});
O[Symbol('c')] = 3;
Reflect.ownKeys(O);
function C(a, b){
this.c = a + b;
}
var instance = Reflect.construct(C, [20, 22]);
instance.c;
ECMAScript 7
Array
#includes(var, from?) -> bool
String
#at(index) -> string
#padLeft(length, fillStr = ' ') -> string
#padRight(length, fillStr = ' ') -> string
#trimLeft() -> string
#trimRight() -> string
Object
.values(object) -> array
.entries(object) -> array
.getOwnPropertyDescriptors(object) -> object
RegExp
.escape(str) -> str
Map
#toJSON() -> array
Set
#toJSON() -> array
Examples:
[1, 2, 3].includes(2);
[1, 2, 3].includes(4);
[1, 2, 3].includes(2, 2);
[NaN].indexOf(NaN);
[NaN].includes(NaN);
Array(1).indexOf(undefined);
Array(1).includes(undefined);
'a𠮷b'.at(1);
'a𠮷b'.at(1).length;
'hello'.padLeft(10);
'hello'.padLeft(10, '1234');
'hello'.padRight(10);
'hello'.padRight(10, '1234');
' hello '.trimLeft();
' hello '.trimRight();
Object.values({a: 1, b: 2, c: 3});
Object.entries({a: 1, b: 2, c: 3});
var copy = Object.create(Object.getPrototypeOf(O), Object.getOwnPropertyDescriptors(O));
Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
RegExp.escape('Hello, []{}()*+?.\\^$|!');
JSON.stringify(new Map([['a', 'b'], ['c', 'd']]));
JSON.stringify(new Set([1, 2, 3, 2, 1]));
Mozilla JavaScript: Array generics
Module js.array.statics
.
Array
.{...ArrayPrototype methods}
Array.slice(arguments, 1);
Array.join('abcdef', '+');
var form = document.getElementsByClassName('form__input');
Array.reduce(form, function(memo, it){
memo[it.name] = it.value;
return memo;
}, {});
Web standards
setTimeout / setInterval
Module web.timers
. Additional arguments fix for IE9-.
setTimeout(fn(...args), time, ...args) -> id
setInterval(fn(...args), time, ...args) -> id
setTimeout(log.bind(null, 42), 1000);
setTimeout(log, 1000, 42);
setImmediate
Module web.immediate
. setImmediate
proposal polyfill.
setImmediate(fn(...args), ...args) -> id
clearImmediate(id) -> void
Example:
setImmediate(function(arg1, arg2){
log(arg1, arg2);
}, 'Message will be displayed', 'with minimum delay');
clearImmediate(setImmediate(function(){
log('Message will not be displayed');
}));
Non-standard
Object
Modules core.object.is-object
, core.object.classof
, core.object.define
, core.object.make
.
Object
.isObject(var) -> bool
.classof(var) -> string
.define(target, mixin) -> target
.make(proto | null, mixin?) -> object
Object classify examples:
Object.isObject({});
Object.isObject(isNaN);
Object.isObject(null);
var classof = Object.classof;
classof(null);
classof(undefined);
classof(1);
classof(true);
classof('string');
classof(Symbol());
classof(new Number(1));
classof(new Boolean(true));
classof(new String('string'));
var fn = function(){}
, list = (function(){return arguments})(1, 2, 3);
classof({});
classof(fn);
classof([]);
classof(list);
classof(/./);
classof(new TypeError);
classof(new Set);
classof(new Map);
classof(new WeakSet);
classof(new WeakMap);
classof(new Promise(fn));
classof([].values());
classof(new Set().values());
classof(new Map().values());
classof(Math);
classof(JSON);
function Example(){}
Example.prototype[Symbol.toStringTag] = 'Example';
classof(new Example);
Object.define
and Object.make
examples:
Object.defineProperty(target, 'c', {
enumerable: true,
configurable: true,
get: function(){
return this.a + this.b;
}
});
Object.define(target, {
get c(){
return this.a + this.b;
}
});
var copy = Object.make(Object.getPrototypeOf(src), src);
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);
log(vector.xyz);
vector.y++;
log(vector.xy);
log(vector.xyz);
Dict
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
Dict
create object without prototype from iterable or simple object. Example:
var map = new Map([['a', 1], ['b', 2], ['c', 3]]);
Dict();
Dict({a: 1, b: 2, c: 3});
Dict(map);
Dict([1, 2, 3].entries());
var dict = Dict({a: 42});
dict instanceof Object;
dict.a;
dict.toString;
'a' in dict;
'hasOwnProperty' in dict;
Dict.isDict({});
Dict.isDict(Dict());
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);
for(var val of Dict.values(dict))log(val);
for(var [key, val] of Dict.entries(dict)){
log(key);
log(val);
}
new Map(Dict.entries(dict));
new Map((for([k, v] of Dict.entries(dict))if(v % 2)[k + k, v * v]));
Basic dict operations for objects with prototype example:
'q' in {q: 1};
'toString' in {};
Dict.has({q: 1}, 'q');
Dict.has({}, 'toString');
({q: 1})['q'];
({}).toString;
Dict.get({q: 1}, 'q');
Dict.get({}, 'toString');
var O = {};
O['q'] = 1;
O['q'];
O['__proto__'] = {w: 2};
O['__proto__'];
O['w'];
var O = {};
Dict.set(O, 'q', 1);
O['q'];
Dict.set(O, '__proto__', {w: 2});
O['__proto__'];
O['w'];
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);
Dict.map(dict, function(it){
return it * it;
});
Dict.mapPairs(dict, function(val, key){
if(key != 'b')return [key + key, val * val];
});
Dict.filter(dict, function(it){
return it % 2;
});
Dict.some(dict, function(it){
return it === 2;
});
Dict.every(dict, function(it){
return it === 2;
});
Dict.find(dict, function(it){
return it > 2;
});
Dict.find(dict, function(it){
return it > 4;
});
Dict.findKey(dict, function(it){
return it > 2;
});
Dict.findKey(dict, function(it){
return it > 4;
});
Dict.keyOf(dict, 2);
Dict.keyOf(dict, 4);
Dict.includes(dict, 2);
Dict.includes(dict, 4);
Dict.reduce(dict, function(memo, it){
return memo + it;
});
Dict.reduce(dict, function(memo, it){
return memo + it;
}, '');
Partial application
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);
var fn2 = log.part(_, 2, _, 4);
fn2(1, 3);
var fn3 = log.part(1, _, _, 4);
fn3(2, 3);
fn2(1, 3, 5);
fn2(1);
Number Iterator
Modules core.number.iterator
.
Number
#@@iterator() -> iterator
Examples:
for(var i of 3)log(i);
Array.from(10, Math.random);
Array.from(10);
Array.from(10, function(it){
return this + it * it;
}, .42);
[for(i of 10)if(i % 2)i * i];
Dict((for(i of 3)['key' + i, !(i % 2)]));
Escaping HTML
Modules core.string.escape-html
and core.string.unescape-html
.
String
#escapeHTML() -> str
#unescapeHTML() -> str
Examples:
'<script>doSomething();</script>'.escapeHTML();
'<script>doSomething();</script>'.unescapeHTML();
delay
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');
})();
Console
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
if(window.console && console.warn)console.warn(42);
log.warn(42);
setTimeout(console.warn.bind(console, 42), 1000);
[1, 2, 3].forEach(console.warn, console);
setTimeout(log.warn, 1000, 42);
[1, 2, 3].forEach(log.warn);
setImmediate(log, 42);
log.disable();
log.warn('Console is disabled, you will not see this message.');
log.enable();
log.warn('Console is enabled again.');
Missing polyfills
- ES5
JSON
is missing now only in IE7- and never it will be added to core-js
, if you need it in these old browsers available many implementations, for example, json3. - ES6 Typed Arrays can be polyfilled without serious problems, but it will be slow - getter / setter for each element and they are missing completely only in IE9-. You can use this polyfill. Possible, it will be added to
core-js
in the future, completely or only missing methods of existing arrays. - ES6
String#normalize
is not very usefull feature, but this polyfill will be very large. If you need it, you can use unorm. - ES6
Proxy
can't be polyfilled, but for Node.js / Chromium with additional flags you can try harmony-reflect for adapt old style Proxy
API to final ES6 version. - ES7
Object.observe
can be polyfilled with many limitations, but it will be very slow - dirty checking on each tick. In nearest future it will not be added to core-js
- it will cause serious slowdown in applications which uses Object.observe
and fallback if it's missing. Possible it will be added as optional feature then most actual browsers will have this feature. Now you can use this polyfill. - ES7
SIMD
. core-js
doesn't adds polyfill of this feature because of large size and some other reasons. You can use this polyfill. window.fetch
is not crossplatform feature, in some environments it make no sense. For this reason I don't think it should be in core-js
. Looking at the large number of requests it maybe added in the future. Now you can use, for example, this polyfill.
Changelog
1.2.0 - 2015.09.27
1.1.4 - 2015.09.05
1.1.3 - 2015.08.29
1.1.2 - 2015.08.28
- added
toJSON
method to Symbol
polyfill and to MS Edge implementation for expected JSON.stringify
result w/o patching this method - replaced
Reflect.construct
implementations w/o correct support third argument - fixed
global
detection with changed document.domain
in ~IE8, #100
1.1.1 - 2015.08.20
- added more correct microtask implementation for
Promise
1.1.0 - 2015.08.17
1.0.1 - 2015.07.31
- some fixes for final MS Edge, replaced broken native
Reflect.defineProperty
- some minor fixes and optimizations
- changed compression
client/*.min.js
options for safe Function#name
and Function#length
, should be fixed #92
1.0.0 - 2015.07.22
- added logic for well-known symbols:
Symbol.match
Symbol.replace
Symbol.split
Symbol.search
- actualized and optimized work with iterables:
- uses enumerable properties in shimmed instances - collections, iterators, etc for optimize performance
- added support native constructors to
Reflect.construct
with 2 arguments - added support native constructors to
Function#bind
shim with new
- removed obsolete
.clear
methods native Weak
-collections - maximum modularity, reduced minimal custom build size, separated into submodules:
- many other optimizations
- final cleaning non-standard features
- moved
$for
to separate library. This work for syntax - for-of
loop and comprehensions - moved
Date#{format, formatUTC}
to separate library. Standard way for this - ECMA-402
- removed
Math
methods from Number.prototype
. Slight sugar for simple Math
methods calling - removed
{Array#, Array, Dict}.turn
- removed
core.global
- uses
ToNumber
instead of ToLength
in Number Iterator
, Array.from(2.5)
will be [0, 1, 2]
instead of [0, 1]
- fixed #85 - invalid
Promise
unhandled rejection message in nested setTimeout
- fixed #86 - support FF extensions
- fixed #89 - behavior
Number
constructor in strange case
0.9.18 - 2015.06.17
0.9.17 - 2015.06.14
0.9.16 - 2015.06.11
0.9.15 - 2015.06.09
- collections from
library
version return wrapped native instances - fixed collections prototype methods in
library
version - optimized
Math.hypot
0.9.14 - 2015.06.04
0.9.13 - 2015.05.25
0.9.12 - 2015.05.24
- different instances
core-js
should use / recognize the same symbols - some fixes
0.9.11 - 2015.05.18
- simplified custom build
- add custom build js api
- added
grunt-cli
to devDependencies
for npm run grunt
- some fixes
0.9.10 - 2015.05.16
- wrapped
Function#toString
for correct work wrapped methods / constructors with methods similar to the lodash
isNative
- added proto versions of methods to export object in
default
version for consistency with library
version
0.9.9 - 2015.05.14
0.9.8 - 2015.05.12
0.9.7 - 2015.05.07
0.9.6 - 2015.05.01
0.9.5 - 2015.04.30
- added cap for
Function#@@hasInstance
- some fixes and optimizations
0.9.4 - 2015.04.27
0.9.3 - 2015.04.26
- some fixes and optimizations
0.9.2 - 2015.04.25
- more correct
Promise
unhandled rejection tracking and resolving / rejection priority
0.9.1 - 2015.04.25
- fixed
__proto__
-based Promise
subclassing in some environments
0.9.0 - 2015.04.24
- added correct symbols descriptors
- fixed behavior
Object.{assign, create, defineProperty, defineProperties, getOwnPropertyDescriptor, getOwnPropertyDescriptors}
with symbols - added single entry points for
Object.{create, defineProperty, defineProperties}
- added
Map#toJSON
- removed non-standard methods
Object#[_]
and Function#only
- they solves syntax problems, but now in compilers available arrows and in near future will be available available bind syntax - removed non-standard undocumented methods
Symbol.{pure, set}
- some fixes and internal changes
0.8.4 - 2015.04.18
- uses
webpack
instead of browserify
for browser builds - more compression-friendly result
0.8.3 - 2015.04.14
- fixed
Array
statics with single entry points
0.8.2 - 2015.04.13
0.8.1 - 2015.04.03
0.8.0 - 2015.04.02
0.7.2 - 2015.03.09
0.7.1 - 2015.03.07
0.7.0 - 2015.03.06
0.6.1 - 2015.02.24
0.6.0 - 2015.02.23
- added support safe closing iteration - calling
iterator.return
on abort iteration, if it exists - added basic support
Promise
unhandled rejection tracking in shim - added
Object.getOwnPropertyDescriptors
- removed
console
cap - creates too many problems - you can use core.log
module as that - restructuring namespaces
- some fixes
0.5.4 - 2015.02.15
0.5.3 - 2015.02.14
0.5.2 - 2015.02.10
0.5.1 - 2015.02.09
0.5.0 - 2015.02.08
- systematization of modules
- splitted
es6
module - splitted
console
module: web.console
- only cap for missing methods, core.log
- bound methods & additional features - added
delay
method - some fixes
0.4.10 - 2015.01.28
0.4.9 - 2015.01.27
0.4.8 - 2015.01.25
0.4.7 - 2015.01.25
0.4.6 - 2015.01.21
0.4.5 - 2015.01.16
0.4.4 - 2015.01.11
0.4.3 - 2015.01.10
- added
Function
instances name
property for IE9+
0.4.2 - 2015.01.10
Object
static methods accept primitivesRegExp
constructor can alter flags (IE9+)- added
Array.prototype[Symbol.unscopables]
0.4.1 - 2015.01.05
0.4.0 - 2015.01.03
- added
es6.reflect
module:
- added
Reflect.apply
- added
Reflect.construct
- added
Reflect.defineProperty
- added
Reflect.deleteProperty
- added
Reflect.enumerate
- added
Reflect.get
- added
Reflect.getOwnPropertyDescriptor
- added
Reflect.getPrototypeOf
- added
Reflect.has
- added
Reflect.isExtensible
- added
Reflect.preventExtensions
- added
Reflect.set
- added
Reflect.setPrototypeOf
core-js
methods now can use external Symbol.iterator
polyfill- some fixes
0.3.3 - 2014.12.28
0.3.2 - 2014.12.25
- added cap for ES5 freeze-family methods
- fixed
console
bug
0.3.1 - 2014.12.23
0.3.0 - 2014.12.23
0.2.5 - 2014.12.20
console
no longer shortcut for console.log
(compatibility problems)- some fixes
0.2.4 - 2014.12.17
- better compliance of ES6
- added
Math.fround
(IE10+) - some fixes
0.2.3 - 2014.12.15
- Symbols:
- added option to disable addition setter to
Object.prototype
for Symbol polyfill:
- added
Symbol.useSimple
- added
Symbol.useSetter
- added cap for well-known Symbols:
- added
Symbol.hasInstance
- added
Symbol.isConcatSpreadable
- added
Symbol.match
- added
Symbol.replace
- added
Symbol.search
- added
Symbol.species
- added
Symbol.split
- added
Symbol.toPrimitive
- added
Symbol.unscopables
0.2.2 - 2014.12.13
0.2.1 - 2014.12.12
0.2.0 - 2014.12.06
- added
es7.proposals
and es7.abstract-refs
modules - added
String#at
- added real
String Iterator
, older versions used Array Iterator - added abstract references support:
- added
Symbol.referenceGet
- added
Symbol.referenceSet
- added
Symbol.referenceDelete
- added
Function#@@referenceGet
- added
Map#@@referenceGet
- added
Map#@@referenceSet
- added
Map#@@referenceDelete
- added
WeakMap#@@referenceGet
- added
WeakMap#@@referenceSet
- added
WeakMap#@@referenceDelete
- added
Dict.{...methods}[@@referenceGet]
- removed deprecated
.contains
methods - some fixes
0.1.5 - 2014.12.01
0.1.4 - 2014.11.27
0.1.3 - 2014.11.20
0.1.2 - 2014.11.19
0.1.1 - 2014.11.18