core js
3.39.0 - 2024.10.31
Biblioteca padrão modular para JavaScript. Inclui polyfills para ECMAScript até 2024: promessas, símbolos, coleções, iteradores, arrays digitados, muitos outros recursos, propostas de ECMAScript, alguns recursos de plataforma cruzada WHATWG/W3C e propostas como
URL. Você pode carregar apenas os recursos necessários ou usá-los sem poluição global do namespace.
Se você estiver procurando documentação para core-js@2 obsoleto, por favor, verifique este branch.
core-js não é apoiado por uma empresa, então o futuro deste projeto depende de você. Torne-se um patrocinador ou apoiador se estiver interessado em core-js : Open Collective , Patreon , Boosty , Bitcoin (bc1qlea7544qtsmj2rayg0lthvza9fau63ux0fstcz) , Alipay .
Exemplo de uso :
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])Você pode carregar apenas os recursos necessários :
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])Ou use-o sem poluição global do namespace :
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/runtimeglobalThisArray.prototype.includesArray.prototype.flat Array.prototype.flatMapArray encontrado desde o últimoArray por cópiaArrayArrayBuffer.prototype.transfer e amigosIteratorObject.values / Object.entriesObject.fromEntriesObject.getOwnPropertyDescriptorsObject.prototype.hasOwnProperty acessívelStringString.prototype.matchAllString.prototype.replaceAllString.prototype.trimStart String.prototype.trimEndRegExp s ( dotAll )RegExpPromise.allSettledPromise.anyPromise.prototype.finallyPromise.tryPromise.withResolversSymbol.asyncIterator para iteração assíncronaSymbol.prototype.descriptionJSON.stringify bem formadoSetArray.fromAsyncJSON.parseFloat16Uint8Array para/de base64 e hexadecimalRegExp escapandoMath.sumPreciseSymbol.metadata para proposta de metadados de decoradoresIteratorAsyncIteratorIterator.rangeMapArray.isTemplateObjectString.dedentSymbolSymbol.customMatcher para extratoresObservable.of e .from em construtores de coleçãocompositeKey e compositeSymbolArrayArrayDataView obter/definir métodos Uint8ClampedNumber.fromStringString.cookedString.prototype.codePointsSymbol.customMatcher para correspondência de padrõesFunction.prototype.demethodizeFunction.{ isCallable, isConstructor }Reflect metadadosselfstructuredClonesetTimeout e setIntervalsetImmediatequeueMicrotaskURL e URLSearchParamsDOMException// 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] Ou você pode usar core-js do CDN.
postinstall O projeto core-js precisa da sua ajuda, então o pacote mostra uma mensagem sobre ele após a instalação. Se isso causar problemas para você, você pode desativá-lo:
ADBLOCK=true npm install
// or
DISABLE_OPENCOLLECTIVE=true npm install
// or
npm install --loglevel silent Você pode importar polyfills apenas necessários para você, como nos exemplos na parte superior de README.md . Pontos de entrada CommonJS disponíveis para todos os métodos/construtores e namespaces polyfilled. Apenas alguns exemplos:
// 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" ; Dica
O uso do namespace /actual/ é recomendado, pois inclui todos os recursos reais do JavaScript e não inclui propostas instáveis em estágio inicial que estão disponíveis principalmente para experimentos.
Aviso
modules é uma API interna, não injeta todas as dependências necessárias e pode ser alterado em versões secundárias ou de patch. Use-o apenas para uma construção personalizada e/ou se você souber o que está fazendo.core-js com extensão de objetos nativos, é recomendado carregar todos os módulos core-js no topo do ponto de entrada da sua aplicação, caso contrário, poderá haver conflitos.Symbol.iterator , conflitando com Array.from , URLSearchParams e/ou algo mais de core-js , consulte problemas relacionados.core-js .core-js é extremamente modular e usa muitos módulos muito pequenos, por isso, para uso em navegadores, agrupe core-js em vez de um carregador de uso para cada arquivo, caso contrário, você terá centenas de solicitações. Na versão pure não podemos poluir protótipos de construtores nativos. Por causa disso, os métodos protótipo foram transformados em métodos estáticos como nos exemplos acima. Mas com transpilers, podemos usar mais um truque - operador de ligação e métodos virtuais. Especial para isso, pontos de entrada /virtual/ disponíveis. Exemplo:
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 Aviso
O operador bind é uma proposta ECMAScript em estágio inicial e o uso dessa sintaxe pode ser perigoso.
core-js está integrado ao babel e é a base para recursos babel relacionados ao polyfilling:
@babel/polyfill ⬆ @babel/polyfill É apenas a importação de recursos estáveis core-js e regenerator-runtime para geradores e funções assíncronas, portanto, se você carregar @babel/polyfill - você carrega a versão global do core-js sem propostas ES.
Agora ele está obsoleto em favor da inclusão separada de partes necessárias de core-js e regenerator-runtime e, para evitar alterações significativas, deixado em core-js@2 .
Como igual a @babel/polyfill , você pode usar isto:
import 'core-js/stable' ;
import 'regenerator-runtime/runtime' ; @babel/preset-env ⬆ @babel/preset-env possui a opção useBuiltIns , que otimiza o trabalho com a versão global do core-js . Com a opção useBuiltIns , você também deve definir a opção corejs para a versão usada de core-js , como corejs: '3.39' .
Importante
Recomendado para especificar a versão secundária core-js usada, como corejs: '3.39' , em vez de corejs: 3 , já que com corejs: 3 não serão injetados módulos que foram adicionados em versões secundárias core-js .
useBuiltIns: 'entry' substitui as importações de core-js para importar apenas os módulos necessários para um ambiente de destino. Então, por exemplo, import 'core-js/stable' ; com o destino chrome 71 será substituído apenas para:
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' ; Funciona para todos os pontos de entrada da versão global do core-js e suas combinações, por exemplo para
import 'core-js/es' ;
import 'core-js/proposals/set-methods' ;
import 'core-js/full/set/map' ; com o destino chrome 71 você terá como resultado:
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' adiciona ao topo de cada arquivo a importação de polyfills para recursos usados neste arquivo e não suportados pelos ambientes de destino, portanto, para: // first file:
let set = new Set ( [ 1 , 2 , 3 ] ) ; // second file:
let array = Array . of ( 1 , 2 , 3 ) ; se o destino contiver um ambiente antigo como IE 11 teremos algo como:
// 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 ) ; Por padrão, @babel/preset-env com a opção useBuiltIns: 'usage' apenas preenche recursos estáveis, mas você pode ativar o polyfilling de propostas pela opção proposals , como corejs: { version: '3.39', proposals: true } .
Importante
No caso de useBuiltIns: 'usage' , você não deve adicionar importações core-js sozinho, elas serão adicionadas automaticamente.
@babel/runtime ⬆ A opção @babel/runtime with corejs: 3 simplifica o trabalho com core-js-pure . Ele substitui automaticamente o uso de recursos modernos da biblioteca padrão JS para importações da versão core-js sem poluição global do namespace, portanto, em vez de:
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 ) ) ;você pode escrever apenas:
Array . from ( new Set ( [ 1 , 2 , 3 , 2 , 1 ] ) ) ;
[ 1 , [ 2 , 3 ] , [ 4 , [ 5 ] ] ] . flat ( 2 ) ;
Promise . resolve ( 32 ) . then ( x => console . log ( x ) ) ; Por padrão, @babel/runtime apenas polyfills recursos estáveis, mas como em @babel/preset-env , você pode habilitar o polyfilling de propostas por opção proposals , como corejs: { version: 3, proposals: true } .
Aviso
Se você usar @babel/preset-env e @babel/runtime juntos, use a opção corejs apenas em um lugar, pois é uma funcionalidade duplicada e causará conflitos.
O transpiler JavaScript rápido swc contém integração com core-js , que otimiza o trabalho com a versão global de core-js . Assim como @babel/preset-env , ele possui 2 modos: usage e entry , mas o modo usage ainda não funciona tão bem quanto em babel . Exemplo de configuração em .swcrc :
{
"env" : {
"targets" : " > 0.25%, not dead " ,
"mode" : " entry " ,
"coreJs" : " 3.39 "
}
} Por padrão, core-js define polyfills somente quando eles são necessários. Isso significa que core-js verifica se um recurso está disponível e funciona corretamente ou não e se não tiver problemas, core-js usa implementação nativa.
Mas às vezes a detecção de recursos core-js pode ser muito rigorosa para o seu caso. Por exemplo, o construtor Promise requer suporte para rastreamento de rejeição não tratada e @@species .
Às vezes, poderíamos ter um problema inverso - um ambiente deliberadamente quebrado com problemas não cobertos pela detecção de recursos core-js .
Para esses casos, poderíamos redefinir esse comportamento para determinados polyfills:
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' ) ; Não funciona com alguns recursos. Além disso, se você alterar o comportamento padrão, mesmo os componentes internos core-js poderão não funcionar corretamente.
Para alguns casos, pode ser útil excluir alguns recursos core-js ou gerar um polyfill para mecanismos de destino. Você poderia usar o pacote core-js-builder para isso.
core-js tenta oferecer suporte a todos os mecanismos e ambientes JS possíveis com suporte ES3. Alguns recursos têm uma barra inferior mais alta - por exemplo, alguns acessadores podem funcionar corretamente apenas no ES5, as promessas exigem uma maneira de definir uma microtarefa ou tarefa, etc.
No entanto, não tenho como testar core-js em absolutamente todos os lugares - por exemplo, testando no IE7 - e alguns outros antigos foram interrompidos. A lista de motores definitivamente suportados você pode ver na tabela de compatibilidade no link abaixo. Escreva se tiver problemas ou dúvidas com o suporte de qualquer mecanismo.
O projeto core-js fornece (como pacote core-js-compat ) todos os dados necessários sobre a necessidade de módulos core-js , pontos de entrada e ferramentas para trabalhar com ele - é útil para integração com ferramentas como babel ou swc . Se quiser ajudar, você pode dar uma olhada na seção relacionada de CONTRIBUTING.md . A visualização dos dados de compatibilidade e do executor de testes do navegador está disponível aqui, exemplo:
Pontos de entrada CommonJS:
core-js(-pure)
Pontos de entrada CommonJS:
core-js(-pure)/es
Módulos 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 } ) ) : 
