console.log(new Date(Date.parse("2011-06-15T21:40:05+06:00")));

Chrome native: Wed Jun 15 2011 21:40:05 GMT+0600 (YEKST) // right
Chrome with attached es5-shim script: Thu Jun 16 2011 09:40:05 GMT+0600 (YEKST) // wrong

expect(Date.parse('+033658-09-27T01:46:40.000Z')).toBe(1e15);

Line 16

fails in Safari 5.1.1 in windows 7.

It returns 999999913600000 instead of 1e15.

(Apologies, I added this unit test and should have caught it earlier!)

if (typeof target.apply != "function" || typeof target.call != "function")
            return new TypeError();

should change to:

if (typeof target.apply != "function" || typeof target.call != "function")
            throw new TypeError();

and I wonder why not just simplify to:

// If IsCallable(func) is false, throw a TypeError exception.
    if (typeof target !== 'function') {
      throw new TypeError('Bind must be called on a function');
    }

Another suggestion is:

if (result !== null && Object(result) === result) {
  return result;
}

can be reduced to:

if (Obect(result) === result) {
  return result;
}

because Object(null) !== null

My forked version:
https://github.com/seajs/dew/blob/master/src/es5-safe/es5-safe.js#L45

Best regards!

It seems like nobody tried to run tests in IE8, there are a lot of not passed tests.

Primary I spent a lot of time to figure out Date issue in IE8 after uglifying the code.

Browser reported issue here, .parse method couldn't be accessed:

https://github.com/kriskowal/es5-shim/blob/master/es5-shim.js#L945

I figured out that removing the function name here solves the problem.

https://github.com/kriskowal/es5-shim/blob/master/es5-shim.js#L940

so:
var Date = function(Y, M, D, h, m, s, ms) {

Best,
Oleg

via @slevithan, we could fix String..split for regexen, bringing errant engines up to spec.

http://blog.stevenlevithan.com/archives/cross-browser-split

var Point = function (x, y) {
    this.x = x;
    this.y = y;
};

var ZeroPoint = Point.bind( null, 0, 0 );

var zeroPoint = new ZeroPoint();

zeroPoint instanceof ZeroPoint; // must be true, but return false with current 'bind' shim
zeroPoint instanceof Point    ; // true

Problem: zeroPoint not instance of ZeroPoint class

Original comment here(RUS)

My personal solution is:

Function.prototype.bind = function (object, var_args) {
    //If IsCallable(Target) is false, throw a TypeError exception.
    if (typeof this != "function") {
        throw new TypeError("Function.prototype.bind called on incompatible " + this);
    }
    var __method = this, args = Array.prototype.slice.call(arguments, 1),
        _result = function () {
            return __method.apply(
                this instanceof _result ?
                    this ://The `object` value is ignored if the bound function is constructed using the new operator.
                    object,
                args.concat(Array.prototype.slice.call(arguments)));
    };
    if(__method.prototype) {
        _result.prototype = Object.create(__method.prototype);
    }
    return _result;
};

es5-shim would be:

if (!Function.prototype.bind) {
    Function.prototype.bind = function bind(that) {
        var target = this;
        if (typeof target != "function") {
            throw new TypeError("Function.prototype.bind called on incompatible " + target);
        }

        var args = slice.call(arguments, 1);

        var bound = function () {

            if (this instanceof bound) {

                //delete lines, rename self to this
                //var F = function(){};
                //F.prototype = target.prototype;
                //var self = new F;

                var result = target.apply(
                    this,
                    args.concat(slice.call(arguments))
                );
                if (Object(result) === result) {
                    return result;
                }
                return this;

            } else {

                return target.apply(
                    that,
                    args.concat(slice.call(arguments))
                );

            }

        };

        //add
        if(target.prototype)
            bound.prototype = Object.create(target.prototype);

        return bound;
    };
}

What do you think about it?

Just reading: http://ejohn.org/blog/objectgetprototypeof/
and thought about:
// ES5 15.2.3.2
if (!Object.getPrototypeOf) {
Object.getPrototypeOf = function (object) {
return object.proto || object.constructor.prototype;
// or undefined if not available in this engine
};
}

f1db466

this breaks installing es5-shim via npm for me.

uglify-js is only a devDependency and so it wont be installed when installing es5-shim

https://gist.github.com/269dee83aa66cdeed487/3b15a72f4268d46ea2f0adaf7d72bf7b18ec46a1

https://gist.github.com/1120592

Fix bugs mentioned above.

if (typeof object !== "object" || object === null)
throw new TypeError(ERR_NON_OBJECT_DESCRIPTOR + descriptor);

should be

if (typeof descriptor !== "object" || descriptor === null)
throw new TypeError(ERR_NON_OBJECT_DESCRIPTOR + descriptor);

See https://github.com/kriskowal/es5-shim/blob/master/es5-shim.js#L495

The copyright message at the top of the es5-shim file is short and neat, which is great, but doesn't match the information provided in the LICENSE file.

LICENSE:

Copyright 2009, 2010 Kristopher Michael Kowal. All rights reserved.

es5-shim.js:

/*!
    Copyright (c) 2009, 280 North Inc. http://280north.com/
    MIT License. http://github.com/280north/narwhal/blob/master/README.md
*/

Additionally, the minified code has no copyright/license included at all. Is this the way it should be distributed?

What are your thoughts on starting to shim what seem like stable, accepted ES6 proposals? E.g., I created these versions of ES6's String.fromCodePoint and String.prototype.codePointAt: https://gist.github.com/2290602

https://gist.github.com/1672142

Since we emulate defineProperty and Object.keys we can keep a record of any non-enumerable properties defined through our defineProperty shim and then reference them in Object.keys.

This means that non-enumerable works for Object.keys but fails with for..in

Is this of value or do we just not want to support non-enumerability?

in ie8 calling splice for second time duplicates some of arrays elements
there is a workaround for it in http://docs.sencha.com/ext-js/4-1/source/Array2.html

In a recent commit, many functions have been changed to be defined as named function expressions, e.g. var bound = function bound(). One of the issues that arises from this is that in JScript (IE), var bound and function bound create two separate functions.

See http://kangax.github.com/nfe/ for more details about this.

Commit c8b5f18 introduced the following regression in browsers without native ISO date parsing support:

isNaN(Date.parse("2011-08-16T12:16:33Z")) === true

Before that commit, such strings successfully passed through Date.parse.

I tried writing unit tests for this, but I could not get it to fail in modern browsers in the same style as has been done for Array and Function, because we rely on the native implementation of Date.parse in implementing our own version, so if the native implementation successfully parses the string, the tests will always pass.

Essentially the problem is that the new isoDateExpression introduced in that commit does not match the above string.

http://code.google.com/p/vbclass/source/browse/trunk/src/VBClass.IE.js

It should be possible to emulate get/set in defineProperty for IE using visual basic through execScript.

Can we fix that in IE < 9 ?

I fix it (outdated)https://github.com/termi/es5-shim/blob/master/es5-shim.js#L198
But I am not sure, what my solution quite well. Can you check it out?

P.S. In my own lib I use Array.from instead of:

args = toObject(args);
var i = -1, arr = [], length = args.length >>> 0;

while (++i < length) {
    if (i in args) {
        arr.push(args[i])
    }
}

var prepareString = "a"[0] != "a"; fails to catch IE8's lack of accessing chars by index of String objects.

To catch IE8's issue it should be:

var prepareString = Object("a")[0] != "a";

https://github.com/kriskowal/es5-shim/blob/master/es5-shim.js#L1058
Native trim property of String.prototype replaced with enumerable property
for(var i in 'test') {
if (i === 'trim') throw "bug!";
}

Date is replaced by a custom one that is anonymous. It should be named like "function Date() {}".

Thanks.

expect(Date.parse('-000001-01-01T00:00:00Z')).toBe(-62198755200000);

The following line fails.

I've seen a lot of people using length >>> 0 on their code (including the MDN shims) but never really understood why, just want to clarify the reasoning behing it, I know what >>> does just don't understand why it's being used in this case..

if length is negative it will return Math.pow(2, 32) + length (that's what zero-fill right shift does with negative numbers..) if length is NaN it will return 0 and if value is positive it will do a Math.floor() (because bitwise operations works with integers..)

why not simply do ~~length?? it will take care of NaN and Math.floor() and negative lengths will be ignored since loops won't execute..

~~ 0.35;  // 0
~~ 9.75;  // 9
~~ -9.75; // -9
~~ '';    // 0
~~ 'foo'; // 0
~~ NaN;   // 0

in the current setup if self.length is negative (probably won't happen :P) it will cause an "infinite" loop.

http://es5.github.com/#x15.4.4.15
step 6
"if n >=0 then let k be min(n, len - 1)"

test case: (works very slowly with current implementation)
[1].lastIndexOf(1, 1e11)

As currently implemented, the Object.defineProperty shim will not install on IE8 because IE8 already has such a method. However, the built-in IE8 method only works when applied to DOM objects.

Because the shim does not get installed, the emulation of value: property descriptors on arbitrary objects is not available although it could be. (get: and set: descriptors are a lost cause). The shim installation needs better detection of IE8 (see http://blogs.msdn.com/b/ie/archive/2010/09/07/transitioning-existing-code-to-the-es5-getter-setter-apis.aspx) and should probably and the installed shim should first call the built-in method and then only call the the emulation if the built-in throws).

IE8 also has a DOM only getOwnPropertyDescriptor so the same issues apply to it.

You seem to have two sets of unit tests. This is rather confusing.

If I wanted to add more tests which should I expand upon?

Can we deprecate one of them?

A concern:

Since this package is getting a fair amount of twitter and blog visibility, I'm concerned that some false expectations are being created. In particular, it isn't clear from the description of the project that it while it provides an ES5 compatible API but that it does not and cannot provide ES5 semantic extensions that are not already present in the "older" browser.

This shows up in all legacy browsers for functions such as Object.freeze and the inability to set property attributes. For IE<9 browsers it will show up as an inability to define getter/setter properties. User's of this package really should be warned of these limitations.

It seems that the minifier makes code with bad varible names. On IE the the references to the function name fail.

Date=function(a){var c=function g(b,c,d,f,h,i,j){var k=arguments.length

should be

Date=function(a){var g=function(b,c,d,f,h,i,j){var k=arguments.length

or perhaps

change the source to

 // Date.length === 7
 function Date(Y, M, D, h, m, s, ms) {

I would expect a nested function declaration to be the best solution

Array#filter should store self[i] in a variable before calling the callback in case the callback modifies that value so it can push the stored value, not the modified one, to the result.

Using real ie8 (i.e. not ie9's "act as ie8" mode), 57 of the 156 tests are currently failing for me in ie8. Many of these issues are not mentioned under the "dubious shims" section in the README (e.g. tests for filter, indexOf fail).

Using ie9's emulate ie8 mode, I get 3 failures, all for Object.isExtensible.

The issue is the overloaded Date object does not provide any of the Date behaviors and returns NaN Number(new Date(1970, 0)) line 787. A fix is to use the NativeDate to construct this value.

But, I'm wondering why we replace the entire interface of Date. Why not just replace the parse method? That way the native impls will/should still work, like .toString() and .valueOf(). UPDATED: it looks like the native methods are exposed via "newDate.prototype.constructor = Date".

I will provide a pull request for the above mentioned fix.

Douglas Crockford's json2.js, for example, defines a Date.prototype.toJSON function that does not pad extended years with zeros as the es5-shim does in Date.prototype.toISOString does.

es5-shim can redefine a bad Date.prototype.toJSON by changing

if (!Date.prototype.toJSON) {

to

if (!Date.prototype.toJSON ||
    (new Date(-62198755200000).toJSON().indexOf('-000001') === -1)) {

This also means people using json2.js need to include json2.js in their environment before including es5-shim as defining Date.prototype.toJSON means other things will not be defined in json2.js

Date.prototype.toISOString outputs unpadded values, like '1970-1-1T22:30:00Z'.

A fix is below, from MDN:

if (!Date.prototype.toISOString) {
    function pad(n) {
      return n < 10 ? '0' + n : n;
    }
    Date.prototype.toISOString = function toISOString() {
        return (
            this.getUTCFullYear() + "-" +
            pad(this.getUTCMonth() + 1) + "-" +
            pad(this.getUTCDate()) + "T" +
            pad(this.getUTCHours()) + ":" +
            pad(this.getUTCMinutes()) + ":" +
            pad(this.getUTCSeconds()) + "Z"
        );
    }
}

Tested fine in IE7, but could use some performance tweaks.

new Date().toJSON not calls Date.prototype.toISOString in Opera 11.6x/12 (seems, it always uses native "toISOString")

new Date(NaN).toJSON() should return null according to spec (throws error in Opera 11.6/12, Safari 5.1.5 with both native and es5-shim version)

fix is here:
#110

So toObject(this) will return an array for string this values which cause problems for the array iteration callback's third arg which should be the this, the string object, and not an array.

1. Line 69 should be

var args = slice.call(arguments, 1);

2. Also the bound function should have a custom .call() and .apply() methods to avoid edge case issues when called passing an instanceof bound as the thisArg.

3. .call/.apply should still curry the bound args

Shims that cover only part of the primary function of an ES5 method are potentially dangerous because they provide a false sense of support.

Devs checking with truthy inferences may assume for example that if (Object.create) { ... } it is fully functional Object.create(null). We should remove all shims that cover only part of a methods functionality.

Safari 5.1.5

console.log(new Date(-1).toISOString()); // Safari 5.1.5 "1969-12-31T23:59:59.-01Z" - es5-shim not applyied, because of
// "if (!Date.prototype.toISOString || (new Date(-62198755200000).toISOString().indexOf('-000001') === -1)) {"

// console.log(new Date(-1).toISOString()); should be "1969-12-31T23:59:59.999Z"

Opera 11.61, Opera 12
(new Date(-3509827334573292)).getUTCMonth() === 12 // - 13 monthes in a year !

console.log(new Date(-3509827334573292).toISOString());
// Opera 11.61/Opera 12 (with es5-shim): -109253-13-01T10:37:06.708Z
// should be -109252-01-01T10:37:06.708Z

Please consider to replace regexp-based trim with trim27a from here:
http://jsperf.com/mega-trim-test/10

Speed improvement is 10-47x.

trim27 beats all 24 competitors here and beats native trim of Chrome and Chromium and is as fast as Safari's native trim:
http://jsperf.com/mega-trim-test/7

Hi!

Please, consider fixing despriptor typo at lines 389, 393

TIA,
--Vladimir

I'm getting this exception when using Serenade.js together with es5-shim:

https://github.com/kriskowal/es5-shim/blob/master/es5-shim.js#L691

Serenade.js will only use defineProperty if it is defined, but es5-shim will define it and throw an exception when used, so what is this useful for?

Please, take a look at this ticket:

http://bugs.jquery.com/ticket/10831

Add a tag for version v1.2.1

['1', '2'].indexOf('1') // returns -1, but should return 0 (testet in IE8)

The bug is here:

if (arguments.length > 0)
i = toInteger(arguments[1]);

I'm pretty sure you want to test, wether arguments.length is greater than 1. But in this case ['1', '2'].indexOf('1', undefined) would also return -1 although all browsers with native support do still return 0.

In which browsers do you test, before you tag a new release?

I just wonder: Did you just forget to mention indexOf in the list of safe shims or is there a reason why it is not safe to use? I guess when lastIndexOf is safe then there couldn't be a reason why indexOf couldn't be implemented in a safe way.

Your implementaion is not full compatible with ES!
see http://es5.github.com/#x15.9.1.15

when year < 0 or year > 9999
6 digits format with sign for year < 0 should be used

test case:
alert(new Date(-1,1,0).toISOString()); // alerts "0-1-01-30T18:00:00.000Z"

Hey,

Object.defineProperty doesn't fail silently on IE8, it throws errors instead. Docs indicate that it should merely have no effect. Intended behavior or a bug?

http://jsfiddle.net/PjEzh

I think QUnit will be good choice.

see
http://jsperf.com/usestrict

A number of people have suggested this idea to me, so I figure I'd bring it up here.

es5-shim is the leader of the pack in many regards. There are a number of other efforts that try to do the same thing:

• http://code.google.com/p/ddr-ecma5/
• http://augmentjs.com/
• All the polyfills listed amongst the MDN Javascript pages

But es5-shim seemingly has the most careful implementation and best tests. Also the most community and expert review.

It would be great to help solidify its status as the defacto es5 shim. Putting it under the guise of the Dojo Foundation would help do that, I think.

Do others think this is a worthwhile idea?