Modulare Standardbibliothek für JavaScript. Enthält Polyfills für ECMAScript bis 2024: Versprechen, Symbole, Sammlungen, Iteratoren, typisierte Arrays, viele andere Funktionen, ECMAScript-Vorschläge, einige plattformübergreifende WHATWG/W3C-Funktionen und Vorschläge wie
URL
. Sie können nur erforderliche Funktionen laden oder sie ohne globale Namensraumverschmutzung verwenden.
Wenn Sie nach Dokumentation für veraltetes core-js@2
suchen, schauen Sie sich bitte diesen Zweig an.
core-js
wird nicht von einem Unternehmen unterstützt, daher hängt die Zukunft dieses Projekts von Ihnen ab. Werden Sie Sponsor oder Unterstützer, wenn Sie an core-js
interessiert sind: Open Collective , Patreon , Boosty , Bitcoin (bc1qlea7544qtsmj2rayg0lthvza9fau63ux0fstcz) , Alipay .
Anwendungsbeispiel :
import 'core-js/actual' ;
Promise . resolve ( 42 ) . then ( it => console . log ( it ) ) ; // => 42
Array . from ( new Set ( [ 1 , 2 , 3 ] ) . union ( new Set ( [ 3 , 4 , 5 ] ) ) ) ; // => [1, 2, 3, 4, 5]
[ 1 , 2 ] . flatMap ( it => [ it , it ] ) ; // => [1, 1, 2, 2]
( function * ( i ) { while ( true ) yield i ++ ; } ) ( 1 )
. drop ( 1 ) . take ( 5 )
. filter ( it => it % 2 )
. map ( it => it ** 2 )
. toArray ( ) ; // => [9, 25]
structuredClone ( new Set ( [ 1 , 2 , 3 ] ) ) ; // => new Set([1, 2, 3])
Sie können nur die erforderlichen Funktionen laden :
import 'core-js/actual/promise' ;
import 'core-js/actual/set' ;
import 'core-js/actual/iterator' ;
import 'core-js/actual/array/from' ;
import 'core-js/actual/array/flat-map' ;
import 'core-js/actual/structured-clone' ;
Promise . resolve ( 42 ) . then ( it => console . log ( it ) ) ; // => 42
Array . from ( new Set ( [ 1 , 2 , 3 ] ) . union ( new Set ( [ 3 , 4 , 5 ] ) ) ) ; // => [1, 2, 3, 4, 5]
[ 1 , 2 ] . flatMap ( it => [ it , it ] ) ; // => [1, 1, 2, 2]
( function * ( i ) { while ( true ) yield i ++ ; } ) ( 1 )
. drop ( 1 ) . take ( 5 )
. filter ( it => it % 2 )
. map ( it => it ** 2 )
. toArray ( ) ; // => [9, 25]
structuredClone ( new Set ( [ 1 , 2 , 3 ] ) ) ; // => new Set([1, 2, 3])
Oder verwenden Sie es ohne globale Namensraumverschmutzung :
import Promise from 'core-js-pure/actual/promise' ;
import Set from 'core-js-pure/actual/set' ;
import Iterator from 'core-js-pure/actual/iterator' ;
import from from 'core-js-pure/actual/array/from' ;
import flatMap from 'core-js-pure/actual/array/flat-map' ;
import structuredClone from 'core-js-pure/actual/structured-clone' ;
Promise . resolve ( 42 ) . then ( it => console . log ( it ) ) ; // => 42
from ( new Set ( [ 1 , 2 , 3 ] ) . union ( new Set ( [ 3 , 4 , 5 ] ) ) ) ; // => [1, 2, 3, 4, 5]
flatMap ( [ 1 , 2 ] , it => [ it , it ] ) ; // => [1, 1, 2, 2]
Iterator . from ( function * ( i ) { while ( true ) yield i ++ ; } ( 1 ) )
. drop ( 1 ) . take ( 5 )
. filter ( it => it % 2 )
. map ( it => it ** 2 )
. toArray ( ) ; // => [9, 25]
structuredClone ( new Set ( [ 1 , 2 , 3 ] ) ) ; // => new Set([1, 2, 3])
postinstall
@babel/polyfill
@babel/preset-env
@babel/runtime
globalThis
Array.prototype.includes
Array.prototype.flat
/ Array.prototype.flatMap
Array
Suche vom letztenArray
durch KopierenArray
GruppierungArrayBuffer.prototype.transfer
und FreundeIterator
HelferObject.values
/ Object.entries
Object.fromEntries
Object.getOwnPropertyDescriptors
Object.prototype.hasOwnProperty
String
String.prototype.matchAll
String.prototype.replaceAll
String.prototype.trimStart
/ String.prototype.trimEnd
RegExp
s
( dotAll
)-FlagRegExp
benannte Capture-GruppenPromise.allSettled
Promise.any
Promise.prototype.finally
Promise.try
Promise.withResolvers
Symbol.asyncIterator
für asynchrone IterationSymbol.prototype.description
JSON.stringify
Set
-MethodenArray.fromAsync
JSON.parse
QuelltextzugriffFloat16
MethodenUint8Array
zu/von Base64 und HexRegExp
entkommtMath.sumPrecise
Symbol.metadata
für Dekorateur-MetadatenvorschlagIterator
SequenzierungAsyncIterator
HelferIterator.range
Map
Array.isTemplateObject
String.dedent
Symbol
Symbol.customMatcher
für ExtraktorenObservable
.of
und .from
Methoden für SammlungskonstruktorencompositeKey
und compositeSymbol
Array
FilterungArray
DeduplizierungDataView
ruft/setzt Uint8Clamped
-Methoden abNumber.fromString
String.cooked
String.prototype.codePoints
Symbol.customMatcher
für den MustervergleichFunction.prototype.demethodize
Function.{ isCallable, isConstructor }
Reflect
Metadatenself
structuredClone
setTimeout
und setInterval
setImmediate
queueMicrotask
URL
und URLSearchParams
DOMException
// global version
npm install --save [email protected]
// version without global namespace pollution
npm install --save [email protected]
// bundled global version
npm install --save [email protected]
Oder Sie können core-js
von CDN verwenden.
postinstall
Das core-js
-Projekt benötigt Ihre Hilfe, daher zeigt das Paket nach der Installation eine Meldung darüber an. Wenn es Ihnen Probleme bereitet, können Sie es deaktivieren:
ADBLOCK=true npm install
// or
DISABLE_OPENCOLLECTIVE=true npm install
// or
npm install --loglevel silent
Sie können nur Polyfills importieren, die Sie benötigen, wie in den Beispielen oben in README.md
. Verfügbare CommonJS-Einstiegspunkte für alle polygefüllten Methoden/Konstruktoren und Namespaces. Nur einige Beispiele:
// polyfill all `core-js` features, including early-stage proposals:
import "core-js" ;
// or:
import "core-js/full" ;
// polyfill all actual features - stable ES, web standards and stage 3 ES proposals:
import "core-js/actual" ;
// polyfill only stable features - ES and web standards:
import "core-js/stable" ;
// polyfill only stable ES features:
import "core-js/es" ;
// if you want to polyfill `Set`:
// all `Set`-related features, with early-stage ES proposals:
import "core-js/full/set" ;
// stable required for `Set` ES features, features from web standards and stage 3 ES proposals:
import "core-js/actual/set" ;
// stable required for `Set` ES features and features from web standards
// (DOM collections iterator in this case):
import "core-js/stable/set" ;
// only stable ES features required for `Set`:
import "core-js/es/set" ;
// the same without global namespace pollution:
import Set from "core-js-pure/full/set" ;
import Set from "core-js-pure/actual/set" ;
import Set from "core-js-pure/stable/set" ;
import Set from "core-js-pure/es/set" ;
// if you want to polyfill just the required methods:
import "core-js/full/set/intersection" ;
import "core-js/actual/array/find-last" ;
import "core-js/stable/queue-microtask" ;
import "core-js/es/array/from" ;
// polyfill iterator helpers proposal:
import "core-js/proposals/iterator-helpers" ;
// polyfill all stage 2+ proposals:
import "core-js/stage/2" ;
Tipp
Die Verwendung des Namensraums /actual/
wird empfohlen, da er alle tatsächlichen JavaScript-Funktionen enthält und keine instabilen Vorschläge im Frühstadium enthält, die hauptsächlich für Experimente verfügbar sind.
Warnung
modules
ist eine interne API, fügt nicht alle erforderlichen Abhängigkeiten ein und kann in Neben- oder Patch-Releases geändert werden. Verwenden Sie es nur für einen benutzerdefinierten Build und/oder wenn Sie wissen, was Sie tun.core-js
mit der Erweiterung nativer Objekte verwenden, wird empfohlen, alle core-js
-Module oben am Einstiegspunkt Ihrer Anwendung zu laden, da es sonst zu Konflikten kommen kann.Symbol.iterator
, der mit Array.from
, URLSearchParams
und/oder etwas anderem von core-js
in Konflikt steht, siehe verwandte Probleme.core-js
erkannt und manuell hinzugefügt wird.core-js
ist äußerst modular und verwendet viele sehr kleine Module. Aus diesem Grund bündeln Sie für die Verwendung in Browsern core-js
anstelle eines Nutzungsladeprogramms für jede Datei, andernfalls erhalten Sie Hunderte von Anfragen. In der pure
Version können wir Prototypen nativer Konstruktoren nicht verunreinigen. Aus diesem Grund wurden Prototypmethoden wie in den obigen Beispielen in statische Methoden umgewandelt. Aber bei Transpilern können wir noch einen weiteren Trick anwenden – Bind-Operator und virtuelle Methoden. Speziell dafür verfügbare /virtual/
Einstiegspunkte. Beispiel:
import fill from 'core-js-pure/actual/array/virtual/fill' ;
import findIndex from 'core-js-pure/actual/array/virtual/find-index' ;
Array ( 10 ) :: fill ( 0 ) . map ( ( a , b ) => b * b ) :: findIndex ( it => it && ! ( it % 8 ) ) ; // => 4
Warnung
Der Bind-Operator ist ein ECMAScript-Vorschlag im Frühstadium und die Verwendung dieser Syntax kann gefährlich sein.
core-js
ist in babel
integriert und bildet die Basis für Polyfilling-bezogene babel
-Funktionen:
@babel/polyfill
⬆ @babel/polyfill
IST lediglich der Import stabiler core-js
Funktionen und regenerator-runtime
für Generatoren und asynchrone Funktionen. Wenn Sie also @babel/polyfill
laden, laden Sie die globale Version von core-js
ohne ES-Vorschläge.
Jetzt ist es veraltet, da die erforderlichen Teile von core-js
und regenerator-runtime
separat eingebunden werden müssen, und um wichtige Änderungen zu verhindern, wird es auf core-js@2
belassen.
Als vollständiges Äquivalent zu @babel/polyfill
können Sie Folgendes verwenden:
import 'core-js/stable' ;
import 'regenerator-runtime/runtime' ;
@babel/preset-env
⬆ @babel/preset-env
verfügt über die Option useBuiltIns
, die die Arbeit mit der globalen Version von core-js
optimiert. Mit der Option useBuiltIns
sollten Sie auch die Option corejs
auf die verwendete Version von core-js
setzen, z. B. corejs: '3.39'
.
Wichtig
Es wird empfohlen, die verwendete kleinere core-js
Version anzugeben, z. B. corejs: '3.39'
anstelle von corejs: 3
, da mit corejs: 3
keine Module injiziert werden, die in kleineren core-js
Versionen hinzugefügt wurden.
useBuiltIns: 'entry'
ersetzt Importe von core-js
um nur für eine Zielumgebung erforderliche Module zu importieren. Also zum Beispiel import 'core-js/stable' ;
Durch chrome 71
wird das Ziel ersetzt, nur um:
import 'core-js/modules/es.array.unscopables.flat' ;
import 'core-js/modules/es.array.unscopables.flat-map' ;
import 'core-js/modules/es.object.from-entries' ;
import 'core-js/modules/web.immediate' ;
Es funktioniert für alle Einstiegspunkte der globalen Version von core-js
und deren Kombinationen, zum Beispiel für
import 'core-js/es' ;
import 'core-js/proposals/set-methods' ;
import 'core-js/full/set/map' ;
Mit chrome 71
Target erhalten Sie als Ergebnis:
import 'core-js/modules/es.array.unscopables.flat' ;
import 'core-js/modules/es.array.unscopables.flat-map' ;
import 'core-js/modules/es.object.from-entries' ;
import 'core-js/modules/esnext.set.difference' ;
import 'core-js/modules/esnext.set.intersection' ;
import 'core-js/modules/esnext.set.is-disjoint-from' ;
import 'core-js/modules/esnext.set.is-subset-of' ;
import 'core-js/modules/esnext.set.is-superset-of' ;
import 'core-js/modules/esnext.set.map' ;
import 'core-js/modules/esnext.set.symmetric-difference' ;
import 'core-js/modules/esnext.set.union' ;
useBuiltIns: 'usage'
fügt am Anfang jeder Datei den Import von Polyfills für Features hinzu, die in dieser Datei verwendet werden und von Zielumgebungen nicht unterstützt werden, also für: // first file:
let set = new Set ( [ 1 , 2 , 3 ] ) ;
// second file:
let array = Array . of ( 1 , 2 , 3 ) ;
Wenn das Ziel eine alte Umgebung wie IE 11
enthält, erhalten wir etwa Folgendes:
// first file:
import 'core-js/modules/es.array.iterator' ;
import 'core-js/modules/es.object.to-string' ;
import 'core-js/modules/es.set' ;
var set = new Set ( [ 1 , 2 , 3 ] ) ;
// second file:
import 'core-js/modules/es.array.of' ;
var array = Array . of ( 1 , 2 , 3 ) ;
Standardmäßig füllt @babel/preset-env
mit der Option useBuiltIns: 'usage'
nur stabile Features polyfilling, aber Sie können das polyfilling von Vorschlägen durch die Option proposals
aktivieren, wie corejs: { version: '3.39', proposals: true }
.
Wichtig
Im Fall von useBuiltIns: 'usage'
sollten Sie core-js
Importe nicht selbst hinzufügen, sie werden automatisch hinzugefügt.
@babel/runtime
⬆ Die Option @babel/runtime
mit corejs: 3
vereinfacht die Arbeit mit core-js-pure
. Es ersetzt automatisch die Verwendung moderner Funktionen aus der JS-Standardbibliothek durch Importe aus der Version von core-js
ohne globale Namensraumverschmutzung, also anstelle von:
import from from 'core-js-pure/stable/array/from' ;
import flat from 'core-js-pure/stable/array/flat' ;
import Set from 'core-js-pure/stable/set' ;
import Promise from 'core-js-pure/stable/promise' ;
from ( new Set ( [ 1 , 2 , 3 , 2 , 1 ] ) ) ;
flat ( [ 1 , [ 2 , 3 ] , [ 4 , [ 5 ] ] ] , 2 ) ;
Promise . resolve ( 32 ) . then ( x => console . log ( x ) ) ;
du kannst einfach schreiben:
Array . from ( new Set ( [ 1 , 2 , 3 , 2 , 1 ] ) ) ;
[ 1 , [ 2 , 3 ] , [ 4 , [ 5 ] ] ] . flat ( 2 ) ;
Promise . resolve ( 32 ) . then ( x => console . log ( x ) ) ;
Standardmäßig füllt @babel/runtime
nur stabile Funktionen mit Polyfills aus, aber wie in @babel/preset-env
können Sie das Polyfilling von Vorschlägen durch die Option proposals
aktivieren, wie corejs: { version: 3, proposals: true }
.
Warnung
Wenn Sie @babel/preset-env
und @babel/runtime
zusammen verwenden, verwenden Sie die Option corejs
nur an einer Stelle, da es sich um eine doppelte Funktionalität handelt und es zu Konflikten kommt.
Der schnelle JavaScript-Transpiler swc
enthält eine Integration mit core-js
, die die Arbeit mit der globalen Version von core-js
optimiert. Wie @babel/preset-env
verfügt es über zwei Modi: usage
und entry
, aber usage
funktioniert immer noch nicht so gut wie in babel
. Beispiel einer Konfiguration in .swcrc
:
{
"env" : {
"targets" : " > 0.25%, not dead " ,
"mode" : " entry " ,
"coreJs" : " 3.39 "
}
}
Standardmäßig legt core-js
Polyfills nur dann fest, wenn sie erforderlich sind. Das bedeutet, dass core-js
prüft, ob eine Funktion verfügbar ist und korrekt funktioniert oder nicht. Wenn keine Probleme auftreten, verwendet core-js
die native Implementierung.
Aber manchmal kann die Erkennung core-js
Funktionen für Ihren Fall zu streng sein. Beispielsweise erfordert Promise
-Konstruktor die Unterstützung der Verfolgung unbehandelter Ablehnungen und @@species
.
Manchmal könnten wir ein umgekehrtes Problem haben – eine wissentlich kaputte Umgebung mit Problemen, die nicht durch die Funktionserkennung von core-js
abgedeckt werden.
Für diese Fälle könnten wir dieses Verhalten für bestimmte Polyfills neu definieren:
const configurator = require ( 'core-js/configurator' ) ;
configurator ( {
useNative : [ 'Promise' ] , // polyfills will be used only if natives are completely unavailable
usePolyfill : [ 'Array.from' , 'String.prototype.padEnd' ] , // polyfills will be used anyway
useFeatureDetection : [ 'Map' , 'Set' ] , // default behavior
} ) ;
require ( 'core-js/actual' ) ;
Bei einigen Funktionen funktioniert es nicht. Wenn Sie das Standardverhalten ändern, funktionieren außerdem möglicherweise selbst core-js
-Interna nicht richtig.
In manchen Fällen könnte es nützlich sein, einige core-js
Funktionen auszuschließen oder eine Polyfüllung für Ziel-Engines zu generieren. Sie könnten dafür das Paket core-js-builder
verwenden.
core-js
versucht, alle möglichen JS-Engines und -Umgebungen mit ES3-Unterstützung zu unterstützen. Einige Funktionen haben eine höhere untere Messlatte – zum Beispiel können einige Zugriffsfunktionen nur von ES5 aus richtig funktionieren, Versprechen erfordern eine Möglichkeit, eine Mikroaufgabe oder eine Aufgabe festzulegen usw.
Allerdings habe ich keine Möglichkeit, core-js
absolut überall zu testen – zum Beispiel das Testen im IE7 – und einige andere alte wurden gestoppt. Die Liste der definitiv unterstützten Engines finden Sie in der Kompatibilitätstabelle unter dem folgenden Link. Schreiben Sie, wenn Sie Probleme oder Fragen mit der Unterstützung einer Engine haben.
core-js
-Projekt stellt (als core-js-compat
Paket) alle erforderlichen Daten über die Notwendigkeit von core-js
Modulen, Einstiegspunkten und Tools für die Arbeit damit bereit – es ist nützlich für die Integration mit Tools wie babel
oder swc
. Wenn Sie helfen möchten, schauen Sie sich den entsprechenden Abschnitt von CONTRIBUTING.md
an. Die Visualisierung der Kompatibilitätsdaten und des Browser-Test-Runners finden Sie hier, das Beispiel:
CommonJS-Einstiegspunkte:
core-js(-pure)
CommonJS-Einstiegspunkte:
core-js(-pure)/es
Module es.object.assign
, es.object.create
, es.object.define-getter
, es.object.define-property
, es.object.define-properties
, es.object.define-setter
, es.object.entries
, es.object.freeze
, es.object.from-entries
, es.object.get-own-property-descriptor
, es.object.get-own-property-descriptors
, es.object.get-own-property-names
, es.object.get-prototype-of
, es.object.group-by
, es.object.has-own
, es.object.is
, es.object.is-extensible
, es.object.is-frozen
, es.object.is-sealed
, es.object.keys
, es.object.lookup-setter
, es.object.lookup-getter
, es.object.prevent-extensions
, es.object.proto
, es.object.to-string
, es.object.seal
, es.object.set-prototype-of
, es.object.values
.
class Object {
toString ( ) : string ; // ES2015+ fix: @@toStringTag support
__defineGetter__ ( property : PropertyKey , getter : Function ) : void ;
__defineSetter__ ( property : PropertyKey , setter : Function ) : void ;
__lookupGetter__ ( property : PropertyKey ) : Function | void ;
__lookupSetter__ ( property : PropertyKey ) : Function | void ;
__proto__ : Object | null ; // required a way setting of prototype - will not in IE10-, it's for modern engines like Deno
static assign ( target : Object , ... sources : Array < Object > ) : Object ;
static create ( prototype : Object | null , properties ?: { [ property : PropertyKey ] : PropertyDescriptor } ) : Object ;
static defineProperties ( object : Object , properties : { [ property : PropertyKey ] : PropertyDescriptor } ) ) :