forked from es-shims/es5-shim
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathREADME
148 lines (105 loc) · 4.14 KB
/
README
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
Provides compatibility shims so that legacy JavaScript
engines behave as closely as possible to ES5.
This package requires quite a bit more attention and
testing. It is not likely to behave as advertised in a
large cross-section of browsers.
"As closely as possible to ES5" is not very close. Many of
these shims are intended only to allow code to be written to
ES5 without causing run-time errors in older engines. In
many cases, this means that these shims cause many ES5
methods to silently fail. Decide carefully whether this is
what you want.
SAFE SHIMS
----------
Array.isArray
Array.prototype.forEach
Array.prototype.map
Array.prototype.filter
Array.prototype.every
Array.prototype.some
Array.prototype.reduce
Array.prototype.reduceRight
Array.prototype.indexOf
Array.prototype.lastIndexOf
Object.keys
Date.now
Date.parse (for ISO parsing)
Date.prototype.toISOString
Date.prototype.toJSON
Function.prototype.bind
String.prototype.trim
DUBIOUS SHIMS
-------------
/?\ Object.create
For the case of simply "begetting" an object that
inherits prototypically from another, this should work
fine across legacy engines.
/!\ Object.create(null) will work only in browsers that
support prototype assignment. This creates an object
that does not have any properties inherited from
Object.prototype. It will silently fail otherwise.
/!\ The second argument is passed to
Object.defineProperties which will probably fail
silently.
/?\ Object.getPrototypeOf
This will return "undefined" in some cases. It uses
__proto__ if it's available. Failing that, it uses
constructor.prototype, which depends on the constructor
property of the object's prototype having not been
replaced. If your object was created like this, it
won't work:
function Foo() {
}
Foo.prototype = {};
Because the prototype reassignment destroys the
constructor property.
This will work for all objects that were created using
`Object.create` implemented with this library.
/!\ Object.getOwnPropertyNames
This method uses Object.keys, so it will not be accurate
on legacy engines.
Object.isSealed
Returns "false" in all legacy engines for all objects,
which is conveniently guaranteed to be accurate.
Object.isFrozen
Returns "false" in all legacy engines for all objects,
which is conveniently guaranteed to be accurate.
SHIMS THAT FAIL SILENTLY
------------------------
/!\ Object.getOwnPropertyDescriptor
The behavior of this shim does not conform to ES5. It
should probably not be used at this time, until its
behavior has been reviewed and been confirmed to be
useful in legacy engines.
/!\ Object.defineProperty
This method will silently fail to set "writable",
"enumerable", and "configurable" properties.
Providing a getter or setter with "get" or "set" on a
descriptor will silently fail on engines that lack
"__defineGetter__" and "__defineSetter__", which include
all versions of IE up to version 8 so far.
IE 8 provides a version of this method but it only works
on DOM objects. Thus, the shim will not get installed
and attempts to set "value" properties will fail
silently on non-DOM objects.
https://github.com/kriskowal/es5-shim/issues#issue/5
/!\ Object.defineProperties
This uses the Object.defineProperty shim
Object.seal
Silently fails on all legacy engines. This should be
fine unless you are depending on the safty and security
provisions of this method, which you cannot possibly
obtain in legacy engines.
Object.freeze
Silently fails on all legacy engines. This should be
fine unless you are depending on the safty and security
provisions of this method, which you cannot possibly
obtain in legacy engines.
Object.preventExtensions
Silently fails on all legacy engines. This should be
fine unless you are depending on the safty and security
provisions of this method, which you cannot possibly
obtain in legacy engines.
/!\ Object.isExtensible
Returns "true". This is probably wildly innacurate.
This method should be reviewed before it's used.