Prototype Array object learning_prototype

Array.from = $A;

(function () {
//Reference of Array prototype
var arrayProto = Array.prototype,
slice = arrayProto.slice,
//JS 1.6 will have the native forEach method
_each = arrayProto.forEach; // use native browser JS 1.6 implementation if available

function each(iterator) {
for (var i = 0, length = this.length; i < length; i )
iterator(this[i]);
}
//If it is not JS1.6, _each is set to the each method of the object
//The _each method here overrides the _each in Enuerable Method
if (!_each) _each = each;

function clear() {
this.length = 0;
return this;
}

function first() {
return this[0];
}

function last() {
return this[this.length - 1];
}

//Return all data in Array that are not null
function compact() {
return this.select(function(value) {
return value != null;
});
}

//Press a multi-dimensional array into a one-dimensional array
function flatten() {
return this.inject([], function(array, value) {
if (Object. isArray(value))
return array.concat(value.flatten()); //There is a recursive call here
array.push(value);
return array;
});
}

function without() {
var values ​​= slice.call(arguments, 0);
return this.select(function(value) {
return !values.include( value);
});
}

function reverse(inline) {
return (inline !== false ? this : this.toArray())._reverse();
}

//Return all non-repeating elements in the Array. If the array is ordered, passing in the true parameter will execute faster
function uniq(sorted) {
return this.inject([], function(array, value, index) {
if (0 == index || (sorted ? array.last() != value : !array.include(value)))
array.push(value);
return array;
});
}

//Get the intersection of two arrays
function intersect(array) {
return this.uniq().findAll(function(item) {
return array.detect(function(value) { return item === value });
});
}


function clone() {
return slice.call(this, 0);
}

function size() {
return this.length;
}

function inspect() {
return '[' this.map(Object.inspect).join(', ') ']';
}

function toJSON( ) {
var results = [];
this.each(function(object) {
var value = Object.toJSON(object);
if (!Object.isUndefined(value)) results .push(value);
});
return '[' results.join(', ') ']';
}

function indexOf(item, i) {
i || (i = 0);
var length = this.length;
if (i < 0) i = length i;
for (; i < length; i )
if (this[i] === item) return i;
return -1;
}

function lastIndexOf(item, i) {
i = isNaN(i) ? this.length : (i < 0 ? this.length i : i) 1;
var n = this.slice(0, i).reverse().indexOf(item);
return (n < 0) ? n : i - n - 1;
}

function concat() {
var array = slice.call(this, 0), item;
for ( var i = 0, length = arguments.length; i < length; i ) {
item = arguments[i];
//The second condition is to prevent the array elements of the calling method from also being concat up
if (Object.isArray(item) && !('callee' in item)) {
for (var j = 0, arrayLength = item.length; j < arrayLength; j )
array .push(item[j]);
} else {
array.push(item);
}
}
return array;
}

/ /mixin Methods in Enumerable
Object.extend(arrayProto, Enumerable);

if (!arrayProto._reverse)
arrayProto._reverse = arrayProto.reverse;

Object. extend(arrayProto, {
_each: _each,
clear: clear,
first: first,
last: last,
compact: compact,
flatten: flatten,
without: without,
reverse: reverse,
uniq: uniq,
intersect: intersect,
clone: ​​clone,
toArray: clone,
size: size,
inspect : inspect,
toJSON: toJSON
});

//I haven’t found this bug online. Does anyone know how to tell it?
var CONCAT_ARGUMENTS_BUGGY = (function() {
return [].concat(arguments)[0][0] !== 1;
})(1,2)

if (CONCAT_ARGUMENTS_BUGGY) arrayProto.concat = concat;

//Check whether JS natively supports the indexOf and lastIndexOf methods. If not, set them to methods within the object
if (!arrayProto.indexOf) arrayProto.indexOf = indexOf;
if (!arrayProto.lastIndexOf) arrayProto.lastIndexOf = lastIndexOf;
})();

['frank', ['bob', 'lisa'], ['jill', ['tom', 'sally']]].flatten()
// -> ['frank', 'bob', 'lisa' , 'jill', 'tom', 'sally']

[' Sam', 'Justin', 'Andrew', 'Dan', 'Sam'].uniq();
// -> ['Sam', 'Justin', 'Andrew', 'Dan']

['Prototype', 'prototype'].uniq();
// -> ['Prototype', 'prototype'] because String comparison is case-sensitive

[3, 5, 6, 1, 20].without(3)
// -> [5, 6, 1, 20]

[3, 5, 6, 1, 20].without( 20, 6)
// -> [3, 5, 1]