php array对象 string,详解JS中Array对象扩展与String对象扩展的方法

这篇文章主要介绍了详解JS中Array对象扩展与String对象扩展的相关资料,需要的朋友可以参考下

废话不多说了，直接给大家上array对象扩展代码了，具体代码如下所示：/**

* Created by laixiangran on 2016/01/07.

* Array扩展

*/

(function() {

// 遍历数组

if (typeof Array.prototype.forEach != "function") {

Array.prototype.forEach = function (fn, context) {

for (var i = 0; i < this.length; i++) {

if (typeof fn === "function" && Object.prototype.hasOwnProperty.call(this, i)) {

fn.call(context, this[i], i, this);

}

}

};

}

// 让数组中的每一个元素调用给定的函数，然后把得到的结果放到新数组中返回

if (typeof Array.prototype.map != "function") {

Array.prototype.map = function (fn, context) {

var arr = [];

if (typeof fn === "function") {

for (var k = 0, length = this.length; k < length; k++) {

arr.push(fn.call(context, this[k], k, this));

}

}

return arr;

};

}

// 把符合条件的元素放到一个新数组中返回

if (typeof Array.prototype.filter != "function") {

Array.prototype.filter = function (fn, context) {

var arr = [];

if (typeof fn === "function") {

for (var k = 0, length = this.length; k < length; k++) {

fn.call(context, this[k], k, this) && arr.push(this[k]);

}

}

return arr;

};

}

// 如果数组中的每个元素都能通过给定的函数的测试，则返回true，反之false

if (typeof Array.prototype.every != "function") {

Array.prototype.every = function (fn, context) {

var passed = true;

if (typeof fn === "function") {

for (var k = 0, length = this.length; k < length; k++) {

if (passed === false) break;

passed = !!fn.call(context, this[k], k, this);

}

}

return passed;

};

}

// 类似every函数，但只要有一个通过给定函数的测试就返回true

if (typeof Array.prototype.some != "function") {

Array.prototype.some = function (fn, context) {

var passed = false;

if (typeof fn === "function") {

for (var k = 0, length = this.length; k < length; k++) {

if (passed === true) break;

passed = !!fn.call(context, this[k], k, this);

}

}

return passed;

};

}

// 返回元素在数组的索引，没有则返回-1，从左到右

if (typeof Array.prototype.indexOf != "function") {

Array.prototype.indexOf = function (item, index) {

var n = this.length,

i = index == null ? 0 : index < 0 ? Math.max(0, n + index) : index;

for (; i < n; i++) {

if (i in this && this[i] === item) {

return i

}

}

return -1

};

}

// 返回元素在数组的索引，没有则返回-1，从右到左

if (typeof Array.prototype.lastIndexOf != "function") {

Array.prototype.lastIndexOf = function (item, index) {

var n = this.length,

i = index == null ? n-1 : index < 0 ? Math.max(0, n + index) : index;

for (; i >= 0; i--) {

if (i in this && this[i] === item) {

return i;

}

}

return -1;

};

}

// 让数组元素依次调用给定函数，最后返回一个值(从左到右)

if (typeof Array.prototype.reduce != "function") {

Array.prototype.reduce = function (callback, initialValue) {

var previous = initialValue, k = 0, length = this.length;

if (typeof initialValue === "undefined") {

previous = this[0];

k = 1;

}

if (typeof callback === "function") {

for (k; k < length; k++) {

this.hasOwnProperty(k) && (previous = callback(previous, this[k], k, this));

}

}

return previous;

};

}

// 让数组元素依次调用给定函数，最后返回一个值(从右到左)

if (typeof Array.prototype.reduceRight != "function") {

Array.prototype.reduceRight = function (callback, initialValue) {

var length = this.length, k = length - 1, previous = initialValue;

if (typeof initialValue === "undefined") {

previous = this[length - 1];

k--;

}

if (typeof callback === "function") {

for (k; k > -1; k-=1) {

this.hasOwnProperty(k) && (previous = callback(previous, this[k], k, this));

}

}

return previous;

};

}

// 去掉重复项(唯一性)，返回新数组

if (typeof Array.prototype.uniq != "function") {

Array.prototype.uniq = function() {

var arr = [];

arr[0] = this[0];

for (var i = 1; i < this.length; i++) {

if (arr.indexOf(this[i]) == -1) {

arr.push(this[i]);

}

}

return arr;

};

}

// 指定删除数组中某值

if (typeof Array.prototype.remove != "function") {

Array.prototype.remove = function(item) {

for (var i = this.length; i >= 0; i--) {

if (item === this[i]) {

this.splice(i, 1);

}

}

return this;

};

}

// 打乱数组顺序

if (typeof Array.prototype.shuffle != "function") {

Array.prototype.shuffle = function() {

var i = this.length;

while (i) {

var j = Math.floor(Math.random()*i);

var t = this[--i];

this[i] = this[j];

this[j] = t;

}

return this;

};

}

// 求数组的最大值

if (typeof Array.prototype.max != "function") {

Array.prototype.max = function() {

return Math.max.apply({}, this)

};

}

// 求数组的最小值

if (typeof Array.prototype.max != "function") {

Array.prototype.min = function() {

return Math.min.apply({}, this)

};

}

// 判断是否为数组

if (typeof Array.prototype.isArray != "function") {

Array.prototype.isArray = function() {

return Object.prototype.toString.apply(this) === "[object Array]";

};

}

}());

下面是string对象扩展代码如下所示：/**

* Created by laixiangran on 2015/12/12.

* String扩展

*/

(function() {

// 十六进制颜色值的正则表达式

var reg = /^#([0-9a-fA-f]{3}|[0-9a-fA-f]{6})$/;

// RGB颜色转换为16进制

if (typeof String.prototype.rgbToHex != "function") {

String.prototype.rgbToHex = function() {

var that = this;

if (/^(rgb|RGB)/.test(that)) {

var aColor = that.replace(/(?:\(|\)|rgb|RGB)*/g,"").split(",");

var strHex = "#";

for (var i=0; i

var hex = Number(aColor[i]).toString(16);

if (hex === "0") {

hex += hex;

}

strHex += hex;

}

if (strHex.length !== 7) {

strHex = that;

}

return strHex;

}else if (reg.test(that)) {

var aNum = that.replace(/#/,"").split("");

if (aNum.length === 6){

return that;

}else if (aNum.length === 3) {

var numHex = "#";

for (var j=0; j

numHex += (aNum[j]+aNum[j]);

}

return numHex;

}

}else{

return that;

}

};

}

// 16进制颜色转为RGB格式

if (typeof String.prototype.hexToRgb != "function") {

String.prototype.hexToRgb = function() {

var sColor = this.toLowerCase();

if (sColor && reg.test(sColor)) {

if (sColor.length === 4) {

var sColorNew = "#";

for (var i = 1; i < 4; i++) {

sColorNew += sColor.slice(i,i+1).concat(sColor.slice(i,i+1));

}

sColor = sColorNew;

}

// 处理六位的颜色值

var sColorChange = [];

for (var j=1; j<7; j+=2) {

sColorChange.push(parseInt("0x"+sColor.slice(j,j+2)));

}

return "RGB(" + sColorChange.join(",") + ")";

}else{

return sColor;

}

};

}

// 移除字符串首尾空白

if (typeof String.prototype.trim != "function") {

String.prototype.trim = function() {

return this.replace(/^\s+|\s+$/g, "");

};

}

}());