es6 shim

ES6垫片

提供兼容性垫片，以使传统的JavaScript引擎与Ecmascript 6（Harmony）尽可能紧密地表现。

HTML版本的最终ecmascript 6规格

安装

如果您想在浏览器中使用它：

• 只需在脚本之前包括es6-shim即可。
• 包括ES5-SHIM，尤其是如果您的浏览器不支持Ecmascript 5-但是每个JS引擎都要求es5-shim纠正损坏的实现，因此强烈建议始终包含它。另外，在es6-shim之前应加载es5-shim 。

对于node.js ， io.js或任何npm管理的工作流（这是推荐的方法）：

 npm install es6-shim

替代方法：

• component install paulmillr/es6-shim如果您使用的是组件（1）。
• 如果您使用的是bower bower install es6-shim 。

在浏览器和节点中，您可能还需要包括unorm ；有关详细信息，请参见String.prototype.normalize部分。

安全的垫片

• Map （需要ES5属性描述符支持）（也可以使用独立的垫片）
• Set （需要ES5属性描述符支持）（也可以使用独立的垫片）
• Promise
• String ：
  • fromCodePoint() （也可以使用独立的垫片）
  • raw() （也可以使用Stanadlone垫片）
• String.prototype ：
  • codePointAt() （也可以使用独立的垫片）
  • endsWith() （也可以使用独立的垫片）
  • includes() （也可以使用独立的垫片）
  • repeat() （也可以使用独立的垫片）
  • startsWith() （也可以使用独立的垫片）
• RegExp ：
  • 当给出“ fegexp”作为模式时， new RegExp将不再在给出“标志”字符串参数时投掷。 （需要ES5）
• RegExp.prototype ：
  • flags （需要ES5）（也可以使用独立的垫片）
  • [Symbol.match] （需要本机Symbol S）
  • [Symbol.replace] （需要本机Symbol S）
  • [Symbol.search] （需要本机Symbol S）
  • [Symbol.split] （需要本地Symbol S）
  • toString
• Number ：
  • 二进制和八分字母： Number('0b1')和Number('0o7')
  • EPSILON （也可以使用独立的垫片）
  • MAX_SAFE_INTEGER （也可以使用独立的垫片）
  • MIN_SAFE_INTEGER （也可以使用独立的垫片）
  • isNaN() （也可以使用独立的垫片）
  • isInteger() （也可以使用独立的垫片）
  • isSafeInteger() （也可以使用独立的垫片）
  • isFinite() （也可以使用独立的垫片）
  • parseInt() （也可以使用独立的垫片）
  • parseFloat()
• Array ：
  • from() （也可以使用独立的垫片）
  • of() （也有独立的垫片）
• Array.prototype ：
  • copyWithin() （也可以使用独立的垫片）
  • entries() （也可以使用独立的垫片）
  • fill()
  • find() （也可以使用独立的垫片）
  • findIndex() （也可以使用独立的垫片）
  • keys() （也可以使用独立的垫片）
  • values() （也可以使用独立的垫片）
  • indexOf() （es6 errata）（也可以使用独立的垫片）
• Object ：
  • assign() （也可以使用独立的垫片）
  • is() （也可以使用独立的垫片）
  • keys() （在ES5中，但不再对ES6中的非对象的非null/undefined值扔）（也可以使用独立的垫片
  • setPrototypeOf() （ie> = 11）
• Function.prototype ：
  • name （ES6-SHAM，覆盖IE 9-11）（也可以使用独立的垫片
• Math ：
  • acosh() （也可以使用独立的垫片）
  • asinh()
  • atanh() （也可以使用独立的垫片）
  • cbrt() （也可以使用独立的垫片）
  • clz32() （也可以使用独立的垫片）
  • cosh()
  • expm1()
  • fround() （也可以使用独立的垫片）
  • hypot()
  • imul() （也可以使用独立的垫片）
  • log10() （也可以使用独立的垫片）
  • log1p() （也可以使用独立的垫片）
  • log2()
  • sign() （也可以使用独立的垫片）
  • sinh()
  • tanh()
  • trunc()

数学功能的精度为1E-11。

• Reflect

  • apply() （也可以使用独立的垫片）
  • construct()
  • defineProperty()
  • deleteProperty()
  • get()
  • getOwnPropertyDescriptor()
  • getPrototypeOf() （也可以使用独立的垫片）
  • has()
  • isExtensible()
  • ownKeys() （也可以使用独立的垫片）
  • preventExtensions()
  • set()
  • setPrototypeOf()

• Symbol （仅当它已经存在时）

  • match （以及对应的String#match ， String#startsWith ， String#endsWith ， String#includes ， RegExp支持）
  • replace （和对应的String#replace支持）
  • search （和对应的String#search支持）
  • split （和对应的String#split支持）

仅当引擎已经具有Symbol支持时，才能提供众所周知的符号。

• String.prototype附件B HTML方法（也可以使用独立的垫片）
  • anchor()
  • big()
  • blink()
  • bold()
  • fixed()
  • fontcolor()
  • fontsize()
  • italics()
  • link()
  • small()
  • strike()
  • sub()
  • sup()

这些方法是“附件B”的一部分，这意味着尽管它们是Defatso标准，但您不应该使用它们。尽管如此， es6-shim提供了它们，并在浏览器中将其行为归一化。

子类

Map ， Set和Promise实现是可划分的。您应该使用以下模式在ES5中创建一个子类，该子类将继续在ES6中工作：

 require ( 'es6-shim' ) ;

function MyPromise ( exec ) {
  var promise = new Promise ( exec ) ;
  Object . setPrototypeOf ( promise , MyPromise . prototype ) ;
  // ...
  return promise ;
}
Object . setPrototypeOf ( MyPromise , Promise ) ;
MyPromise . prototype = Object . create ( Promise . prototype , {
  constructor : { value : MyPromise }
} ) ; 

string.prototype.normalize

包括适合字符串的垫片String.prototype.normalize将该库的大小增加4个以上。因此，如果您需要String.prototype.normalize我们建议您将unorm软件包与es6-shim一起安装。有关更多讨论，请参见＃134。

弱图垫片

不可能在纯JavaScript中实现弱图。 ES6-Collections实现并不能持有强烈的值，这对于集合至关重要。 es6-shim决定不包括不正确的垫片。

WeakMap具有非常不寻常的用例，因此您可能根本不需要它（而是使用简单的Map ）。

入门

 require ( 'es6-shim' ) ;
var assert = require ( 'assert' ) ;

assert . equal ( true , 'abc' . startsWith ( 'a' ) ) ;
assert . equal ( false , 'abc' . endsWith ( 'a' ) ) ;
assert . equal ( true , 'john alice' . includes ( 'john' ) ) ;
assert . equal ( '123' . repeat ( 2 ) , '123123' ) ;

assert . equal ( false , NaN === NaN ) ;
assert . equal ( true , Object . is ( NaN , NaN ) ) ;
assert . equal ( true , - 0 === 0 ) ;
assert . equal ( false , Object . is ( - 0 , 0 ) ) ;

var result = Object . assign ( { a : 1 } , { b : 2 } ) ;
assert . deepEqual ( result , { a : 1 , b : 2 } ) ;

assert . equal ( true , isNaN ( 'a' ) ) ;
assert . equal ( false , Number . isNaN ( 'a' ) ) ;
assert . equal ( true , Number . isNaN ( NaN ) ) ;

assert . equal ( true , isFinite ( '123' ) ) ;
assert . equal ( false , Number . isFinite ( '123' ) ) ;
assert . equal ( false , Number . isFinite ( Infinity ) ) ;

// Tests if value is a number, finite,
// >= -9007199254740992 && <= 9007199254740992 and floor(value) === value
assert . equal ( false , Number . isInteger ( 2.4 ) ) ;

assert . equal ( 1 , Math . sign ( 400 ) ) ;
assert . equal ( 0 , Math . sign ( 0 ) ) ;
assert . equal ( - 1 , Math . sign ( - 400 ) ) ;

var found = [ 5 , 10 , 15 , 10 ] . find ( function ( item ) { return item / 2 === 5 ; } ) ;
assert . equal ( 10 , found ) ;

var foundIndex = [ 5 , 10 , 15 , 10 ] . findIndex ( function ( item ) { return item / 2 === 5 ; } ) ;
assert . equal ( 1 , foundIndex ) ;

// Replacement for `{}` key-value storage.
// Keys can be anything.
var map = new Map ( [ [ 'Bob' , 42 ] , [ 'Foo' , 'bar' ] ] ) ;
map . set ( 'John' , 25 ) ;
map . set ( 'Alice' , 400 ) ;
map . set ( [ 'meh' ] , 555 ) ;
assert . equal ( undefined , map . get ( [ 'meh' ] ) ) ; // undefined because you need to use exactly the same object.
map . delete ( 'Alice' ) ;
map . keys ( ) ;
map . values ( ) ;
assert . equal ( 4 , map . size ) ;

// Useful for storing unique items.
var set = new Set ( [ 0 , 1 ] ) ;
set . add ( 2 ) ;
set . add ( 5 ) ;
assert . equal ( true , set . has ( 0 ) ) ;
assert . equal ( true , set . has ( 1 ) ) ;
assert . equal ( true , set . has ( 2 ) ) ;
assert . equal ( false , set . has ( 4 ) ) ;
assert . equal ( true , set . has ( 5 ) ) ;
set . delete ( 5 ) ;
assert . equal ( false , set . has ( 5 ) ) ;

// Promises, see
// http://www.slideshare.net/domenicdenicola/callbacks-promises-and-coroutines-oh-my-the-evolution-of-asynchronicity-in-javascript
// https://github.com/petkaantonov/bluebird/#what-are-promises-and-why-should-i-use-them
Promise . resolve ( 5 ) . then ( function ( value ) {
  assert . equal ( value , 5 ) ;
  if ( value ) throw new Error ( 'whoops!' ) ;
  // do some stuff
  return anotherPromise ( ) ;
} ) . catch ( function ( e ) {
  assert . equal ( e . message , 'whoops!' ) ;
  assert . equal ( true , e instanceof Error ) ;
  // any errors thrown asynchronously end up here
} ) ; 

警告

• Object.setPrototypeOf / Reflect.setPrototypeOf
  • 请注意，null对象（ Object.create(null) ，例如，带有null对象，因为其[[Prototype]] ）无法更改其[[Prototype]] Object.setPrototypeOf
• 众所周知的Symbol s
  • 为了使它们可以通过Symbol.for进行全局Symbol注册表创建它们。这并不违反规格，但这确实意味着Symbol.for('Symbol.search') === Symbol.search是true ，默认情况下它不会在新鲜的综合领域中。

执照

该项目最初是基于Axel Rauschmayer的ES6-Shim。