Preparation code

<script>
  var SAFE_MODE = 0
  function EMPTY(args){
    return SAFE_MODE ? [] : Array(args.length)
  }

  function arrayProtoSlice() {
    return Array.prototype.slice.apply(arguments);
  }

  function arrayProtoSliceExceptOne() {
    return Array.prototype.slice.call(arguments,1);
  }

  function arrayProtoSliceExceptMany(many) {
    return Array.prototype.slice.call(arguments,many);
  }

  function arrayLiteralSlice() {
    return EMPTY(arguments).slice.apply(arguments);
  }

  function arrayLiteralSliceExceptOne() {
    return [].slice.call(arguments,1);
  }

  function arrayLiteralSliceExceptMany(many) {
    return [].slice.call(arguments,many);
  }

  var _slice = [].slice;

  function closureSlice() {
    return _slice.call(arguments);
  }

  function closureSliceExceptOne() {
    return _slice.call(arguments,1);
  }

  function closureSliceExceptMany(many) {
    return _slice.call(arguments,many);
  }

  var _splice = [].splice;

  function closureSplice() {
    return _splice.call(arguments);
  }

  function closureSpliceExceptOne() {
    return _splice.call(arguments,1);
  }

  function closureSpliceExceptMany(many) {
    return _splice.call(arguments,many);
  }

  function slice() {
    return [].splice.call(arguments, 0);
  }

  function sliceExceptOne() {
    return [].splice.call(arguments, 1);
  }

  function sliceExceptMany(many) {
    return [].splice.call(arguments, many);
  }

  function splice() {
    return [].splice.call(arguments, 0);
  }

  function spliceExceptOne() {
    return [].splice.call(arguments, 1);
  }

  function spliceExceptMany(many) {
    return [].splice.call(arguments, many);
  }

  function push() {
    var x = [];
    x.push.apply(x, arguments);
    return x;
  }

  function pushLoop() {
    var x = [], len= arguments.length;
    for(var i= 0; i< len; ++i)
      x.push(arguments[i])
    return x;
  }

  function pushLoopExceptOne() {
    var x = [], len= arguments.length;
    for(var i= 1; i< len; ++i)
      x.push(arguments[i])
    return x;
  }

  function pushLoopExceptMany(many) {
    var x = [], len= arguments.length;
    for(var i= many; i< len; ++i)
      x.push(arguments[i])
    return x;
  }

  function unshift() {
    var x = [];
    x.unshift.apply(x, arguments);
    return x;
  }

  function unshiftExceptOne() {
    var x = [];
    x.unshift.apply(x, arguments);
    x.shift();
    return x;
  }

  function unshiftExceptMany(many) {
    var x = [];
    x.unshift.apply(x, arguments);
    x= x.splice(many)
    return x;
  }

  function whileDecPostfix() {
    var arr = EMPTY(arguments),
        i = arguments.length;
    while (i--) {
      arr[i] = arguments[i];
    }
    return arr;
  }

  function whileDecPostfixExceptOne() {
    var arr = EMPTY(arguments),
        i = arguments.length-1;
    while (i) {
      arr[i] = arguments[--i];
    }
    return arr;
  }

  function whileDecPostfixExceptMany(many) {
    var arr = EMPTY(arguments),
        i = arguments.length,
        j = arguments.length - many;
    while (j > 0) {
      arr[--j] = arguments[--i]
    }
    return arr;
  }

  function whileInc() {
    var arr = EMPTY(arguments),
        i = 0,
        len = arguments.length;
    while (++i <= len) {
      arr[i] = arguments[i];
    }
    return arr;
  }

  function whileIncExceptOne() {
    var arr = [],
        i = 0,
        j,
        len = arguments.length;
    while ((j = i++) <= len) {
      arr[j] = arguments[i];
    }
    return arr;
  }

  function whileIncExceptMany(many) {
    var arr = [],
        i = many-1,
        j = -1,
        len = arguments.length;
    while (i < len) {
      arr[++j] = arguments[++i];
    }
    return arr;
  }

  function byConstructor() {
    return Array.apply(Array, arguments);
  }

  var bigArray = new Array(1001).join("a").split("");
  var smallArray = new Array(6).join("a").split("");

  var manyArray = new Array(1001+44).join("a").split(""), many = 88;
  manyArray.unshift(many); 
  var smallManyArray = new Array(7).join("a").split("");
  smallManyArray.unshift(1);

  SAFE_MODE = 0;

  arrayProtoSlice.apply(null, bigArray).length === bigArray.length || alert('arrayProtoSlice broken');
  arrayProtoSliceExceptOne.apply(null, bigArray).length + 1 === bigArray.length || alert('arrayProtoSliceExceptOne broken');
  arrayProtoSliceExceptMany.apply(null, manyArray).length + many === bigArray.length || alert('arrayProtoSliceExceptMany broken');
  arrayLiteralSlice.apply(null, bigArray).length === bigArray.length || alert('arrayLiteralSlice broken');
  arrayLiteralSliceExceptOne.apply(null, bigArray).length + 1 === bigArray.length || alert('arrayLiteralSliceExceptOne broken');
  arrayLiteralSliceExceptMany.apply(null, manyArray).length + many === bigArray.length || alert('arrayLiteralSliceExceptMany broken');
  closureSlice.apply(null, bigArray).length === bigArray.length || alert('closureSlice broken');
  closureSliceExceptOne.apply(null, bigArray).length + 1 === bigArray.length || alert('closureSliceExceptOne broken');
  closureSliceExceptMany.apply(null, manyArray).length + many === bigArray.length || alert('closureSliceExceptMany broken');
  closureSplice.apply(null, bigArray).length === bigArray.length || alert('closureSplice broken');
  closureSpliceExceptOne.apply(null, bigArray).length + 1 === bigArray.length || alert('closureSpliceExceptOne broken');
  closureSpliceExceptMany.apply(null, manyArray).length + many === bigArray.length || alert('closureSpliceExceptMany broken');
  slice.apply(null, bigArray).length === bigArray.length || alert('slice broken');
  sliceExceptOne.apply(null, bigArray).length + 1 === bigArray.length || alert('sliceExceptOne broken');
  sliceExceptMany.apply(null, manyArray).length + many === bigArray.length || alert('sliceExceptMany broken');
  splice.apply(null, bigArray).length === bigArray.length || alert('splice broken');
  spliceExceptOne.apply(null, bigArray).length + 1 === bigArray.length || alert('spliceExceptOne broken');
  spliceExceptMany.apply(null, manyArray).length + many === bigArray.length || alert('spliceExceptMany broken');
  push.apply(null, bigArray).length === bigArray.length || alert('push broken');
  pushLoop.apply(null, bigArray).length === bigArray.length || alert('pushLoop broken');
  pushLoopExceptOne.apply(null, bigArray).length + 1 === bigArray.length || alert('pushLoopExceptOne broken');
  pushLoopExceptMany.apply(null, manyArray).length + many === bigArray.length || alert('pushLoopExceptMany broken');
  unshift.apply(null, bigArray).length === bigArray.length || alert('unshift broken');
  unshiftExceptOne.apply(null, bigArray).length + 1 === bigArray.length || alert('unshiftExceptOne broken');
  unshiftExceptMany.apply(null, manyArray).length + many === bigArray.length || alert('unshiftExceptMany broken');
  whileDecPostfix.apply(null, bigArray).length === bigArray.length || alert('whileDecPostfix broken');
  whileDecPostfixExceptOne.apply(null, bigArray).length + 1 === bigArray.length || alert('whileDecPostfixExceptOne broken');
  whileDecPostfixExceptMany.apply(null, manyArray).length + many === bigArray.length || alert('whileDecPostfixExceptMany broken');
  whileInc.apply(null, bigArray).length === bigArray.length || alert('whileInc broken');
  whileIncExceptOne.apply(null, bigArray).length + 1 === bigArray.length || alert('whileIncExceptOne broken');
  whileIncExceptMany.apply(null, manyArray).length + many === bigArray.length || alert('whileIncExceptMany broken');
  byConstructor.apply(null, bigArray).length === bigArray.length || alert('byConstructor broken');

  if(console && console.log) console.log("gtg")
</script>
 

Preparation code output

Test runner

Warning! For accurate results, please disable Firebug before running the tests. (Why?)

Java applet disabled.

arrayProtoSlice.apply(null, bigArray);
arrayProtoSlice.apply(null, smallArray);

arrayLiteralSlice.apply(null, bigArray);
arrayLiteralSlice.apply(null, smallArray);

push.apply(null, bigArray);
push.apply(null, smallArray);

splice.apply(null, bigArray);
splice.apply(null, smallArray);

unshift.apply(null, bigArray);
unshift.apply(null, smallArray);

closureSlice.apply(null, bigArray);
closureSlice.apply(null, smallArray);

whileDecPostfix.apply(null, bigArray);
whileDecPostfix.apply(null, smallArray);

byConstructor.apply(null, bigArray);
byConstructor.apply(null, smallArray);

arrayProtoSliceExceptOne.apply(null, bigArray);
arrayProtoSliceExceptOne.apply(null, smallArray);

arrayProtoSliceExceptMany.apply(null, manyArray);
arrayProtoSliceExceptMany.apply(null, smallManyArray);

arrayLiteralSliceExceptOne.apply(null, bigArray);
arrayLiteralSliceExceptOne.apply(null, smallArray);

arrayLiteralSliceExceptMany.apply(null, manyArray);
arrayLiteralSliceExceptMany.apply(null, smallManyArray);

closureSliceExceptOne.apply(null, bigArray);
closureSliceExceptOne.apply(null, smallArray);
 

closureSliceExceptMany.apply(null, manyArray);
closureSliceExceptMany.apply(null, smallManyArray);
 

closureSplice.apply(null, bigArray)
closureSplice.apply(null, smallArray)

closureSpliceExceptOne.apply(null, bigArray)
closureSpliceExceptOne.apply(null, smallArray)

closureSpliceExceptMany.apply(null, manyArray)
closureSpliceExceptMany.apply(null, smallManyArray)

slice.apply(null, bigArray)
slice.apply(null, smallArray)

sliceExceptOne.apply(null, bigArray)
sliceExceptOne.apply(null, smallArray)

sliceExceptMany.apply(null, manyArray)
sliceExceptMany.apply(null, smallManyArray)

spliceExceptOne.apply(null, manyArray)
spliceExceptOne.apply(null, smallManyArray)
 

pushLoop.apply(null, bigArray)
pushLoop.apply(null, smallArray)

pushLoopExceptOne.apply(null, bigArray)
pushLoopExceptOne.apply(null, smallArray)
 

pushLoopExceptMany.apply(null, manyArray)
pushLoopExceptMany.apply(null, smallManyArray)
 

unshiftExceptOne.apply(null, bigArray)
unshiftExceptOne.apply(null, smallArray)

unshiftExceptMany.apply(null, manyArray)
unshiftExceptMany.apply(null, smallManyArray)

whileDecPostfix.apply(null, bigArray)
whileDecPostfix.apply(null, smallArray)

whileDecPostfixExceptOne.apply(null, bigArray)
whileDecPostfixExceptOne.apply(null, smallArray)

whileDecPostfixExceptMany.apply(null, manyArray)
whileDecPostfixExceptMany.apply(null, smallManyArray)

whileInc.apply(null, bigArray)
whileInc.apply(null, smallArray)

whileIncExceptOne.apply(null, bigArray)
whileIncExceptOne.apply(null, smallArray)

whileIncExceptMany.apply(null, manyArray)
whileIncExceptMany.apply(null, smallManyArray)

Compare results of other browsers

Revisions

You can edit these tests or add even more tests to this page by appending /edit to the URL. Here’s a list of current revisions for this page:

• Revision 1: published on 21st September 2011
• Revision 2: published on 22nd September 2011
• Revision 3: published on 17th January 2012
• Revision 4: published by tj on 28th January 2012
• Revision 5: published on 28th January 2012
• Revision 6: published on 3rd March 2012
• Revision 7: published by damien maillard on 30th September 2012 and last updated on 6th December 2012
• Revision 8: published by rektide on 1st December 2012
• Revision 9: published on 31st December 2012
• Revision 11: published by Charmander on 13th January 2013
• Revision 14: published on 30th March 2013

0 comments