首页 文章 精选 留言 我的

精选列表

搜索[JavaScript],共9118篇文章
优秀的个人博客,低调大师

JavaScript常用数组操作方法,包含ES6方法

一、concat() concat() 方法用于连接两个或多个数组。该方法不会改变现有的数组,仅会返回被连接数组的一个副本。 var arr1 = [1,2,3]; var arr2 = [4,5]; var arr3 = arr1.concat(arr2); console.log(arr1); //[1, 2, 3] console.log(arr3); //[1, 2, 3, 4, 5] 二、join() join() 方法用于把数组中的所有元素放入一个字符串。元素是通过指定的分隔符进行分隔的,默认使用','号分割,不改变原数组。 var arr = [2,3,4]; console.log(arr.join()); //2,3,4 console.log(arr); //[2, 3, 4] 三、push() push() 方法可向数组的末尾添加一个或多个元素,并返回新的长度。末尾添加,返回的是长度,会改变原数组。 var a = [2,3,4]; var b = a.push(5); console.log(a); //[2,3,4,5] console.log(b); //4 push方法可以一次添加多个元素push(data1,data2....) 四、pop() pop() 方法用于删除并返回数组的最后一个元素。返回最后一个元素,会改变原数组。 var arr = [2,3,4]; console.log(arr.pop()); //4 console.log(arr); //[2,3] 五、shift() shift() 方法用于把数组的第一个元素从其中删除,并返回第一个元素的值。返回第一个元素,改变原数组。 var arr = [2,3,4]; console.log(arr.shift()); //2 console.log(arr); //[3,4] 六、unshift() unshift() 方法可向数组的开头添加一个或更多元素,并返回新的长度。返回新长度,改变原数组。 var arr = [2,3,4,5]; console.log(arr.unshift(3,6)); //6 console.log(arr); //[3, 6, 2, 3, 4, 5] tip:该方法可以不传参数,不传参数就是不增加元素。 七、slice() 返回一个新的数组,包含从 start 到 end (不包括该元素)的 arrayObject 中的元素。返回选定的元素,该方法不会修改原数组。 var arr = [2,3,4,5]; console.log(arr.slice(1,3)); //[3,4] console.log(arr); //[2,3,4,5] 八、splice() splice() 方法可删除从 index 处开始的零个或多个元素,并且用参数列表中声明的一个或多个值来替换那些被删除的元素。如果从 arrayObject 中删除了元素,则返回的是含有被删除的元素的数组。splice() 方法会直接对数组进行修改。 var a = [5,6,7,8]; console.log(a.splice(1,0,9)); //[] console.log(a); // [5, 9, 6, 7, 8] var b = [5,6,7,8]; console.log(b.splice(1,2,3)); //[6, 7] console.log(b); //[5, 3, 8] 九、substring() 和 substr() 相同点:如果只是写一个参数,两者的作用都一样:都是是截取字符串从当前下标以后直到字符串最后的字符串片段。 substr(startIndex); substring(startIndex); var str = '123456789'; console.log(str.substr(2)); // "3456789" console.log(str.substring(2)) ;// "3456789" 不同点:第二个参数 substr(startIndex,lenth): 第二个参数是截取字符串的长度(从起始点截取某个长度的字符串); substring(startIndex, endIndex): 第二个参数是截取字符串最终的下标 (截取2个位置之间的字符串,‘含头不含尾’)。 console.log("123456789".substr(2,5)); // "34567" console.log("123456789".substring(2,5)) ;// "345" 十、sort 排序 按照 Unicode code 位置排序,默认升序 var fruit = ['cherries', 'apples', 'bananas']; fruit.sort(); // ['apples', 'bananas', 'cherries'] var scores = [1, 10, 21, 2]; scores.sort(); // [1, 10, 2, 21] 十一、reverse() reverse() 方法用于颠倒数组中元素的顺序。返回的是颠倒后的数组,会改变原数组。 var arr = [2,3,4]; console.log(arr.reverse()); //[4, 3, 2] console.log(arr); //[4, 3, 2] 十二、indexOf 和 lastIndexOf 都接受两个参数:查找的值、查找起始位置 不存在,返回 -1 ;存在,返回位置。indexOf 是从前往后查找, lastIndexOf 是从后往前查找。indexOf var a = [2, 9, 9]; a.indexOf(2); // 0 a.indexOf(7); // -1 if (a.indexOf(7) === -1) { // element doesn't exist in array } lastIndexOf var numbers = [2, 5, 9, 2]; numbers.lastIndexOf(2); // 3 numbers.lastIndexOf(7); // -1 numbers.lastIndexOf(2, 3); // 3 numbers.lastIndexOf(2, 2); // 0 numbers.lastIndexOf(2, -2); // 0 numbers.lastIndexOf(2, -1); // 3 十三、every 对数组的每一项都运行给定的函数,每一项都返回 ture,则返回 true function isBigEnough(element, index, array) { return element < 10; } [2, 5, 8, 3, 4].every(isBigEnough); // true 十四、some 对数组的每一项都运行给定的函数,任意一项都返回 ture,则返回 true function compare(element, index, array) { return element > 10; } [2, 5, 8, 1, 4].some(compare); // false [12, 5, 8, 1, 4].some(compare); // true 十五、filter 对数组的每一项都运行给定的函数,返回 结果为 ture 的项组成的数组 var words = ["spray", "limit", "elite", "exuberant", "destruction", "present", "happy"]; var longWords = words.filter(function(word){ return word.length > 6; }); // Filtered array longWords is ["exuberant", "destruction", "present"] 十六、map 对数组的每一项都运行给定的函数,返回每次函数调用的结果组成一个新数组 var numbers = [1, 5, 10, 15]; var doubles = numbers.map(function(x) { return x * 2; }); // doubles is now [2, 10, 20, 30] // numbers is still [1, 5, 10, 15] 十七、forEach 数组遍历 const items = ['item1', 'item2', 'item3']; const copy = []; items.forEach(function(item){ copy.push(item) }); ES6新增新操作数组的方法 1、find(): 传入一个回调函数,找到数组中符合当前搜索规则的第一个元素,返回它,并且终止搜索。 const arr = [1, "2", 3, 3, "2"] console.log(arr.find(n => typeof n === "number")) // 1 2、findIndex(): 传入一个回调函数,找到数组中符合当前搜索规则的第一个元素,返回它的下标,终止搜索。 const arr = [1, "2", 3, 3, "2"] console.log(arr.findIndex(n => typeof n === "number")) // 0 3、fill(): 用新元素替换掉数组内的元素,可以指定替换下标范围。 arr.fill(value, start, end) 4、copyWithin(): 选择数组的某个下标,从该位置开始复制数组元素,默认从0开始复制。也可以指定要复制的元素范围。 arr.copyWithin(target, start, end) const arr = [1, 2, 3, 4, 5] console.log(arr.copyWithin(3)) // [1,2,3,1,2] 从下标为3的元素开始,复制数组,所以4, 5被替换成1, 2 const arr1 = [1, 2, 3, 4, 5] console.log(arr1.copyWithin(3, 1)) // [1,2,3,2,3] 从下标为3的元素开始,复制数组,指定复制的第一个元素下标为1,所以4, 5被替换成2, 3 const arr2 = [1, 2, 3, 4, 5] console.log(arr2.copyWithin(3, 1, 2)) // [1,2,3,2,5] 从下标为3的元素开始,复制数组,指定复制的第一个元素下标为1,结束位置为2,所以4被替换成2 5、from 将类似数组的对象(array-like object)和可遍历(iterable)的对象转为真正的数组 const bar = ["a", "b", "c"]; Array.from(bar); // ["a", "b", "c"] Array.from('foo'); // ["f", "o", "o"] 6、of 用于将一组值,转换为数组。这个方法的主要目的,是弥补数组构造函数 Array() 的不足。因为参数个数的不同,会导致 Array() 的行为有差异。 Array() // [] Array(3) // [, , ,] Array(3, 11, 8) // [3, 11, 8] Array.of(7); // [7] Array.of(1, 2, 3); // [1, 2, 3] Array(7); // [ , , , , , , ] Array(1, 2, 3); // [1, 2, 3] 7、entries() 返回迭代器:返回键值对 //数组 const arr = ['a', 'b', 'c']; for(let v of arr.entries()) { console.log(v) } // [0, 'a'] [1, 'b'] [2, 'c'] //Set const arr = new Set(['a', 'b', 'c']); for(let v of arr.entries()) { console.log(v) } // ['a', 'a'] ['b', 'b'] ['c', 'c'] //Map const arr = new Map(); arr.set('a', 'a'); arr.set('b', 'b'); for(let v of arr.entries()) { console.log(v) } // ['a', 'a'] ['b', 'b'] 8、values() 返回迭代器:返回键值对的value //数组 const arr = ['a', 'b', 'c']; for(let v of arr.values()) { console.log(v) } //'a' 'b' 'c' //Set const arr = new Set(['a', 'b', 'c']); for(let v of arr.values()) { console.log(v) } // 'a' 'b' 'c' //Map const arr = new Map(); arr.set('a', 'a'); arr.set('b', 'b'); for(let v of arr.values()) { console.log(v) } // 'a' 'b' 9、keys() 返回迭代器:返回键值对的key //数组 const arr = ['a', 'b', 'c']; for(let v of arr.keys()) { console.log(v) } // 0 1 2 //Set const arr = new Set(['a', 'b', 'c']); for(let v of arr.keys()) { console.log(v) } // 'a' 'b' 'c' //Map const arr = new Map(); arr.set('a', 'a'); arr.set('b', 'b'); for(let v of arr.keys()) { console.log(v) } // 'a' 'b' 10、includes 判断数组中是否存在该元素,参数:查找的值、起始位置,可以替换 ES5 时代的 indexOf 判断方式。indexOf 判断元素是否为 NaN,会判断错误。 var a = [1, 2, 3]; a.includes(2); // true a.includes(4); // false 原文发布时间为:2018-09-26 本文作者:沉静地闪光 本文来自云栖社区合作伙伴“ 前端大学”,了解相关信息可以关注“ 前端大学”

优秀的个人博客,低调大师

【JavaScript框架封装】使用Prototype给Array,String,Function对象的方法扩充

版权声明:本文为博主原创文章,未经博主允许不得转载。更多学习资料请访问我爱科技论坛:www.52tech.tech https://blog.csdn.net/m0_37981569/article/details/81055991 /* * @Author: 我爱科技论坛 * @Time: 20180705 * @Desc: 实现一个类似于JQuery功能的框架 * V 1.0: 实现了基础框架、事件框架、CSS框架、属性框架、内容框架、动画框架的搭建 * V 2.0:实现了框架的进一步优化,具有良好的扩展性, 可以支持链式访问 * V 3.0:种子模块:命名空间、对象扩展、数组化、类型的判定、domReady,无冲突处理 * V 4.0: 数据类型的检测、正则表达式的基本用法,数据绑定的知识(模板的使用) * */ /** * 用于给js中内置的对象进行扩充方法 */ (function () { // 为了使得下面定义的扩充函数执行,祥和里需要调用一下 stringExtend() arrayExtend() functionExtend() // String对象方法的扩充 function stringExtend() { // str = 'name: @(name), age:@(age)' // data = {name : 'xiugang', age : 18} /** * 实现一个简单的数据绑定 * @param str * @param data * @return {*} */ String.prototype.formateString = function (data) { return this.replace(/@\((\w+)\)/g, function (match, key) { // 注意这里找到的值必须返回出去(如果是undefined,就是没有数据) // 注意:判断一个值的类型是不是undefined,可以通过typeof判断 console.log(typeof data[key] === 'undefined'); return data[key] === 'undefined' ? '' : data[key]; }); } /** * 去掉坐标的空格 * @param str * @return {*} */ String.prototype.ltrim = function () { return this.replace(/^\s*/g, ''); } /** * 去掉右边的空格 * @param str * @return {*} */ String.prototype.rtrim = function () { return this.replace(/\s*$/g, ''); } /** * 去掉两边的空格 * @param str * @return {*} */ String.prototype.trim = function () { return this.replace(/(^\s*)|(\s*$)/g, ''); } // red===>Red /** * 将第一个字母小写,其他字母大写 * @param str * @return {*} */ String.prototype.camelCase = function () { // .*?是非贪婪的匹配,点可以匹配任意字符,星号是前边的字符有0-n个均匹配,问号是则是0-1; // (^\w{1}): 用于匹配第一个首字母 // (.*):用于匹配任意个的前面的字符 // - param 1: 匹配到的字符串 // - param 2: 匹配的的子字符串 // - param 3: 匹配的子字符串 // - param 4: 匹配到的字符串在字符串中的位置 // - param 5: 原始字符串 return this.replace(/(^\w{1})(.*)/g, function (match, g1, g2) { return g1.toUpperCase() + g2.toLowerCase(); }); } /** * 将一个字符串的下划线转换为中划线 * @param str * @return {*} */ String.prototype.dashString = function () { // 这里面的this实际上指向的就是我们自己定义的一个变量字符串 return this.replace(/\_/g, '-'); } /** * 检测一个字符串是不是为空 * @return {boolean} */ String.prototype.isEmpty = function () { return this.length === 0; } /** * 判断字符串是不是包含一个字符串 * @param target * @return {boolean} */ String.prototype.contains = function (target) { // 只要这个indexOf的下标不是-1的话,就说明包含这个目标字符串,否则的话就是不包含 // indexOf() 方法可返回某个指定的字符串值在字符串中首次出现的位置,如果没找到的话,就返回-1 return this.indexOf(target) !== -1; } /** * 对一个字符串中的特殊字符进行转义 * @return {string} */ String.prototype.escapeHTML = function () { /*显示结果 描述 实体名称 实体编号 空格 < 小于号 < < > 大于号 > > & 和号 & & " 引号 " " ' 撇号 ' (IE不支持) ' ¢ 分 ¢ ¢ �0�5 镑 £ £ �0�6 日圆 ¥ ¥ € 欧元 &euro * **/ // 先进行字符串分割, 得到一个数组 var strArr = this.split(''); for (var pos = 0, l = strArr.length, tmp; pos < l; pos++) { // 拿到数组中的每一个元素 tmp = strArr[pos]; // 对字符串中的每一个元素进行判断, 如果是特殊字符的话就进行处理 switch (tmp) { // pos始终为1, 表示要替换的项是1项 case '<': replaceArr(strArr, pos, '<'); break; case '>': replaceArr(strArr, pos, '>'); break; case '\'': replaceArr(strArr, pos, '''); break; case '\"': replaceArr(strArr, pos, '"'); break; case '&': replaceArr(strArr, pos, '&'); break; default: ; } } // join() 方法用于把数组中的所有元素放入一个字符串。 return strArr.join(''); // 专门用于替换掉数组中的元素 /** * 替换数组中指定的项 * @param arr * @param pos * @param item * @return {*} */ function replaceArr(arr, pos, item) { // Splice: splice主要用来对JS中的数组进行操作,包括删除,添加,替换等,原来的数组会被改变 // 删除数据:array.splice(index,num),返回值为删除内容,array为结果值。index为起始项,num为删除元素的的个数。 // 插入数据:array.splice(index,0,insertValue),index要插入的位置,insertValue要插入的项 // 替换数据:array.splice(index,num,insertValue),index起始位置,num要被替换的项数,insertValue要替换的值 return arr.splice(pos, 1, item); } } /** * 忽略HTML中的一些内置的特殊字符 * @return {string} */ String.prototype.escapeHTML = function () { return this.replace(/$/g, '&') .replace(/\</g, '<') .replace(/\>/g, '>') .replace(/\'/g, ''') .replace(/\"/g, '"'); } /** * 对字符串进行反转义 * @return {string} */ String.prototype.unescapeHTML = function () { return this.replace(/&/, '&') .replace(/</g, '<') .replace(/>/g, '>') .replace(/'/g, '\'') .replace(/"/g, '\"') .replace(/&#(\d+)/g, function ($0, $1) { return String.fromCharCode(parseInt($1, 10)); }); } /** * 把一个字符串进行反转操作 * @return {string} */ String.prototype.reverse = function () { // 1. 先获得我需要的字符串,然后进行分割处理 var arr = this.toString().split(''); // 2. 对我分割后得到的数组元素进行逆序处理 arr = arr.reverse(); // 3.把数组中的元素变为一个字符串 return arr.join(); //return (this.toString()).split('').reverse().join(); } } // Array对象方法的扩充 function arrayExtend() { /** * 将一个数组元素清空 * @return {Array} */ Array.prototype.clear = function () { this.length = 0; return this; } /** * 计算一个数组的长度 * @return {*} */ Array.prototype.size = function () { return this.length; } /** * 返回数组里面的第一个元素 * @return {*} */ Array.prototype.first = function () { return this[0]; } /** * 返回数组的最后一个元素 * @return {*} */ Array.prototype.last = function () { return this[this.length - 1] } function cacl(arr, callback) { // 变量的初始化(治理在使用的时候进行初始化) var ret; for (var i = 0, len = arr.length; i < len; i++) { ret = callback(arr[i], ret); } return ret; } /** * 对数组的所有元素进行求和 * @return {*} */ Array.prototype.sum = function () { // 1. 一般的方法 /*var ret = 0; for (var i = 0, len = this.length; i < len; i++){ ret = ret + this[i]; } return ret;*/ // 2.使用上面的计算类 /** * @param:item 数组的每一项 * @param:sum 数组求和的结果 */ return cacl(this, function (item, sum) { // 如果刚开始没有初始化的话,就直接使用第一项作为sum(ret)的初始值 if (typeof sum === 'undefined') { return item; } else { return sum += item; } }) } /** * 找出数组中的最大值 * @return {*} */ Array.prototype.max = function () { // 1. 一般的方式求出最大值 /*var ret = 0; for (var i = 0, len = this.length; i < len; i++){ if (ret < this[i]){ ret = this[i]; } } return ret;*/ // 2. 第二种方式 return cacl(this, function (item, max) { if (typeof max === 'undefined') { return item; } else { if (max < item) { return item; } else { return max; } } }) } /** * 找出一个数组中的最小值 * @return {*} */ Array.prototype.min = function () { return cacl(this, function (item, min) { if (typeof min === 'undefined') { return item; } else { // 只要每一项的值都不比最小值小的话 if (!(min < item)) { return item; } else { return min; } } }) } /** * 求出一个数组中所有元素的平均值 * @return {*} */ Array.prototype.avg = function () { // 1. 先对数组中的元素个数组进行判断一下,防止计算出现无穷的情况 if (this.length === 0) { return; } var sum = this.sum(); return sum / this.length; /*return cacl(this, function (item, avg) { // 1. 先求和(进入到这个函数里面, this指向的是window对象,此时window对象是没有sum方法的,故执行错误) //var sum = this.sum(); // 2.求出平均值 if (typeof avg === 'undefined'){ return item; } else{ avg = sum / (this.length); } return avg; })*/ } // 去除数组中的重复项 /* * 实现思路: 遍历原始数组中的每一项元素,让每次遍历的这一个元素和后面的每一个元素进行比较 * 【只要相同的话就直接跳过继续向下寻找】 * */ Array.prototype.unique = function () { var a = [], len = this.length; for (var i = 0; i < len; i++) { for (var j = i + 1; j < len; j++) { if (this[i] === this[j]) { // 如果找到了相邻的两个元素是相同的,i直接向后移动一位 // 然后j开始从i的位置继续向后寻找元素 j = ++i; } } a.push(this[i]); } ; return a; } /** * 去除数组中的重复项 * 【实现思路】:先对数组进行排序,然后比较相邻的元素是否相同 * @return {Array} */ Array.prototype.unique = function () { var tmp = [], len = this.length; // 1.先对原始的数组进行排序 this.sort(); // 2.比较相邻的元素 for (var i = 0; i < len; i++) { // 只要相邻的元素相同,就直接跳过 if (this[i] === this[i + 1]) { continue; } // 由于tmp.length初始的位置一直是0, 添加一个元素之后变为1,因此下标和长度每次相差1, 实现了实时插入数据的功能 tmp[tmp.length] = this[i]; } return tmp; } /** * 实现两个数组的并集,然后去除重复元素 * @param target * @return {*} */ Array.prototype.union = function (target) { // concat() 方法用于连接两个或多个数组。 // 连接数组之后然后去除数组中的重复项 return this.concat(target).union(); } /** * 求出两个数组的交集 * @param target * @return {Array|*[]} */ Array.prototype.intersect = function (target) { // 1.先去除原始数组和目标数组中的重复元素 var originArr = this.unique(), targetArr = target.unique(); // filter()的作用是返回某一数组中满足条件的元素,该方法返回的是一个新的数组 // 2.开始使用条件过滤 /** * @param element(必选):当前元素的值 @param index(可选): 当前元素的索引 @param array(可选):当前元素所属的数组 */ return originArr.filter(function (element, index, array) { // filter函数默认会把所有的返回false的元素去掉 for (var i = 0, len = targetArr.length; i < len; i++) { if (element === targetArr[i]) { // 只要是返回满足true的所有条件,基本上都会被过滤掉 return true; } //return false; } // 只有找到相同的元素的时候返回的是true,其他情况都是返回的是false return false; }); } /** * 找出两个数组中的不同元素 * @param target * @return {Array|*[]} */ Array.prototype.diff = function (target) { // 1. 获取原始数组和目标数组,去除重复项 var orignArr = this.unique(), targetArr = target.unique(); // 2. 开始使用filter函数过滤条件 return orignArr.filter(function (element, index, array) { for (var i = 0, len = targetArr.length; i < len; i++) { // 只要元素相等的话,就全部过滤掉 if (element === targetArr[i]) { return false; } } return true; }); } /** * 对数组的每一项遍历的时候设置一个回调函数(没有返回结果) * @param fn * @param ctx */ Array.prototype.forEach = function (fn, ctx) { var i = 0, len = this.length; for (; i < len; i++) { // element, index, array // call 的第一个参数也就是this的指向, 其他参数表示需要传递给回调函数的的参数 fn.call(ctx || null, this[i], i, this); } } } /** * * 对数组的每一项执行回调,返回由回调函数的结果组成的数组 * @param fn * @param ctx * @return {Array} */ Array.prototype.map = function (fn, ctx) { // 初始化变量 var ret = [], i = 0, len = this.length; // 遍历数组的每一项元素, 返回由回调函数的结果组成的数组 for (; i < len; i++) { // 调用回调函数, 返回指向结果 res = fn.call(ctx || null, this[i], i, this); // 将每一项执行的结果放入到一个新的数组里面 ret.push(res); } return ret; } /** * 对数组的每一项执行回调函数, 返回回调函数执行结果为true的数组集合 * @param fn * @param ctx */ Array.prototype.filter = function (fn, ctx) { var ret = [], i = 0, len = this.length; // 遍历每一项,把执行结果为true的所有元素集合存起来 for (; i < len; i++) { // 注意这里的这种运算方式只会返回所有的回调函数返回true的计算结果集 fn.call(ctx || null, this[i], i, this) && ret.push(this[i]); } return ret; } /** * 对数组的【每一项】执行回调函数,必须每一项回调函数返回true, 就返回true * @param fn * @param ctx */ Array.prototype.every = function (fn, ctx) { var i = 0, len = this.length; // 遍历数组中所有的元素, 只要有一个函数回调函数为false就返回false,只要所有的都是true才会返回true for (; i < len; i++) { // 如:a默认是undefined,!a是true,!!a则是false,所以b的值是false,而不再是undefined。这样写可以方便后续判断使用。 // 所以,!!(a)的作用是将a强制转换为布尔型(boolean)。 // 如果a = null, !!(a) 的结果就是假, 可以直接把一个弱类型强制转换为一个新的类型 // 下面的代码就是强制将一个函数转换为bool的类型 if(!!fn.call(ctx || null, this[i], i, this) === false) return false; // 上面的代码等价于 /*if (fn.call(ctx || null, this[i], i, this)) { return true; }*/ } return true; } /** * 对数组中的每一项执行回调函数,只要有一项为true的话,就是true,否则就是false * @param fn * @param ctx */ Array.prototype.some = function (fn, ctx) { var i = 0, len = this.length; // 循环遍历每一项,只要有一项为true,就是true for (; i < len; i++) { /* * // 强制转换为Boolean 用 !! var bool = !!"c"; console.log(typeof bool); // boolean // 强制转换为Number 用 + var num = +"1234"; console.log(typeof num); // number // 强制转换为String 用 ""+ var str = ""+ 1234; console.log(typeof str); // string * */ if(!!fn.call(ctx || null, this[i], i, this) === true) return true; } return false; } /** * 从左向右执行回调函数(第二个元素开始) * 其中包含了上一次回调的返回值 * @param callback */ Array.prototype.reduce = function (callback) { var i = 0, len = this.length, callbackRet = this[0]; // 这个变量保存着上一次回到的函数的返回结果, 默认存储的是第一个元素 for (; i < len; i++) { // this的指向,element, index, 数组对象本身 // callbackRet 里面存储了数组上一次计算的处理结果 callbackRet = callback.call(null, callbackRet, this[i], i, this); } return callbackRet; } /** * 从右向左处理每一项元素,倒数第二项开始执行 * @param callback */ Array.prototype.reduceRight = function (callback) { var len = this.length, i = this[len - 2], callbackRet = this[len - 1]; // 保存着最后一项 // 从倒数第二项开始向前遍历数组的每一项 for (; i >= 0; i--) { //this指向, prev, element, index, arr callbackRet = callback.call(null, callbackRet, this[i], i, this); } return callbackRet; } /** * 返回目标值target在数组中第一次出现的位置, 搜索默认会从左向右执行 * @param target * @param start */ Array.prototype.indexOf = function (target, start) { /* * 其实是一种利用符号进行的类型转换,转换成数字类型 ~~true == 1 ~~false == 0 ~~"" == 0 ~~[] == 0 ~~undefined ==0 ~~!undefined == 1 ~~null == 0 ~~!null == 1 * */ var len = this.length, start = ~~start; // 如果start不传过来,这里就是undefined,指向后面的就会保存,这里使用了~~把其他类型强制转换为数字类型 if (start < 0) { // 如果指定搜索的起始位置小于0的话, 默认就从0的位置开始向后搜索 start = 0; } // 从用户指定的起始位置开始向后搜索 for (; start < len; start++) { if (this[start] === target) { return start; } } // 如果没找到的话,就返回-1 return -1; } /** * 返回指定的目标值在数组中最后一次出现的位置 * @param target * @param start */ Array.prototype.lastIndexOf = function (target, start) { // 这里相当于是typeof start ==== 'undefined' if (start === void 0) { start = this.length; } else if (start < 0) { start = 0; } // 开始从数组的最后面向前遍历 for (; start >= 0; start--) { // 找到目标元素target在数组中最后一次出现的位置(从后向前找) if (this[start] === target) { return start; } } return -1; } /** * 数组去重方法加强版本 * 局限性:只适用于数组中存放的是单一的数据类型,如果是多种数据类型并存的话,就会去重失败 * ['ff', 1, '1'] */ Array.prototype.enhanceUnique = function () { var ret = [], tempMap = {}, i = 0, len = this.length, temp; // 遍历数组的每一项 for (; i < len; i++) { temp = this[i]; // 只要这个tempMap中没有这一项的话,就直接放入到数组中去 if (tempMap[temp] === void 0) { ret.push(temp); // {}数据的存储格式为{1 : true, 2 : false, 3 : false} tempMap[temp] = true; } } return ret; } /** * 删除数组中的指定元素, 通过arguments伪数组的方式来接受传递过来的参数 * 经过测试,只能删除数组中重复的多余的元素 * @return {Array} */ Array.prototype.without = function () { // slice(start, end) 方法可从已有的数组中返回选定的元素。 // 如果slice()这个函数没有指定结束的位置的话,默认是会返回数组中的start之后的所有元素 // 1. 获取用户传过来的参数, 去掉数组中重复的元素 //var args = [].slice.call(arguments).unique(); /* * Array.prototype.slice.call({ 0:"likeke", 1:12, 2:true, length:3 }); * */ //1. 由于arguments实际上是一个伪数组,不能直接使用数组里面的方法 // 因此先要把arguments转换为数组 var arr = Array.prototype.slice.call(arguments) || [].slice.call(arguments); // 2. 把数组中的重复元素去重 var args = arr.unique(), len = this.length, aLength = args.length, i = 0, j = 0; // 遍历原始的数组(由于后面每次删除掉一个元素之后,这里的this.length的长度就是已经都改变了, 因此每次在执行完毕之后都要重新计算一下length) for (; i < len; i++) { for (; j < aLength; j++) { if (this[i] === args[j]) { // 只要删除的数组在我的这个里面,就直接去掉 // i 为起始的值,1为要删除的项, 也就是删除i位置的元素 // splice 返回的是删除的元素, this内容是已经修改过之后的项 this.splice(i, 1); // 为了避免删除数组的元素之后的数组长度的变化,这里需要重新计算一下数组的新的长度 // len = this.length; } } // 将j下标复位,以便下一次循环(注意是在每一次j循环完毕之后然后再把j初始化到原始的状态) j = 0; } return this; } /** * 去掉数组中的目标元素 */ Array.prototype.enhanceWithout = function () { // 用于去除数组中指定的的多余的元素 var ret = [], len = this.length, args = ([]).slice.call(arguments), argsLength = args.length, i = 0, j = 0; for (; i < len; i++){ for(; j < argsLength; j++){ if (args[j] !== this[i]){ ret.push(this[i]); } } // 由于这里的j使用的是局部变量,因此这里需要进行处理 j = 0; } return ret; } /** * 实现一个数组的扁平化(可以解决数组里面存放数组的问题)【递归处理调用】 * [[], [], [], [[], [], []]] * @return {Array} */ Array.prototype.flatten = function () { // 实现一个flatten函数,将一个嵌套多层的数组 array(数组) (嵌套可以是任何层数)转换为只有一层的数组 // 数组中元素仅基本类型的元素或数组, var ret = [], len = this.length, // 注意当下一次执行递归调用之后,这里的this指向的是tmp i = 0, tmp; for (; i < len; i++) { // 注意这里先取出来数组中的每一项元素 tmp = this[i]; // 判断一下数组里面存放的还是不是数组类型(数组里面的每一项) if (({}).toString.call(tmp) === '[object Array]' || Object.prototype.toString.call(tmp) === '[object Array]') { // 继续递归调用(递归调用的时候需要把结果存起来哦) // 1. 对当前数组里面的数组进行扁平化处理, tmp.flatten()得到的就是一个普通的数组类型 // 2. 由于ret是一个数组类型,使用concat之后可以把两个数组里面的元素链接起来 // 下一次执行递归的时候上面的this就是指向了这里的tmp数组 ret = ret.concat(tmp.flatten()) //tmp.flatten(); } else { // 如果不是数组类型的话,就直接放入到我的新数组里面 ret.push(tmp); } } return ret; } /** * 删除数组中的指定位置的项 * @param pos * @return {Array} */ Array.prototype.removeAt = function (pos) { // 移出数组中指定位置的项 // slice() 函数调用的执行结果返回的是删除掉的项, 这个this就是修改之后的项 this.splice(pos, 1); return this; } /* 【经验话语1】 直接用等号 (==) 判断时,变量必须要声明(包括不用var 的隐式声明),否则出错。 不管变量有没有声明,都可用typeof 判断,注意typeof 返回结果为字符串,所以是与"undefined"做比较。 所以,判断类型最好用typeof ,因为当判断的变量是在其他js 文件中定义的全局变量时, 执行此判断时,定义该变量所在的js 文件可能还未加载完成,用== 判断就会报错:is not defined 【经验话语2】 注意slice()和splice() 这两者的区别 * */ /** * 检测数组中是不是包含某一项 * @param target * @return {boolean} */ Array.prototype.contains = function (target) { // 可以调用自己之前申明好的some方法,数组中只要有一项,就会返回true return this.some(function (element, index, self) { // 调用this.some()方法实际上会返回遍历数组元素的每一项 return element === target; }) } /** * 随机返回数组中的某一项(把数组中的任意一项返回) * @param n * @return {*} */ Array.prototype.random = function (n) { //Math.floor():向下取整。Math.floor(1.8) -> 1 //Math.ceil():向上取整。Math.ceil(1.1) -> 2 //v = Math.random() * n:会产生一个 0 < v < nv的数 //v2 = Math.floor(Math.random() * n):v2为一个大于等于0,小于n的整数 var index = (Math.floor(Math.random()) * n); return this[index] || this[this.length-1]; } // Function对象方法的扩充 function functionExtend(func) { Function.prototype.before = function () { // 一般来说加下划线的变量为私有变量,这是常规都比较遵守的一种代码规范。 var __self = this; // 私有的属性用下划线 return function () { // 重新把我需要传递的参数传递过去, 如果目标函数返回的是false, 就是false if (func.apply(this, arguments) === false){ return false; } // 否则就把我的自己的参数传递过去 return __self.apply(this, arguments); } } /** * AOP 切面编程的函数扩充 * @param func * @return {Function} */ Function.prototype.after = function (func) { var __self = this; return function () { var ret = __self.apply(this, arguments); // //返回一个函数,相当于一个代理函数,也就是说,这里包含了原函数和新函数,原函数指的是myFunc,新函数指的是fn if (ret === false){ return false; } func.apply(this, arguments); return ret; } } } })();

优秀的个人博客,低调大师

javascript成神之路(4):深入理解this关键字,是的就是this

摘要:如果你真的理解了this是什么,那么你的web几乎所向披靡(文章后面有惊喜,不要错过) 很多程序员会这么认为,this关键字与面向对象程序开发紧密相关,其完全指向由构造器新创建的对象。在ECMAScript规范中也是这样实现的,但正如我们将看到那样,在ECMAScript中,this并不限于只用来指向新创建的对象。还有很多新功能特性 一、定义 this代表当前对象,说明this是在某种特定的情况下才是成立的,它是执行上下文的一个属性。 activeExecutionContext = { AEC: {...}, this: thisVal }; 这里AEC是我们讨论的变量对象。this与上下文中可执行代码的类型有直接关系,this值在进入上下文时确定,并且在上下文运行期间永久不变。 二、全局代码中的this 在全局代码中,this始终是全局对象本身,这样就有可能间接的引用到它了。 // 显示定义全局对象的属性 this.ab = 10; // global.ab = 10 alert(ab); // 10 // 通过赋值给一个无标示符隐式 bb = 20; alert(this.bb); // 20 // 也是通过变量声明隐式声明的 // 因为全局上下文的变量对象是全局对象自身 var cc = 30; alert(this.cc); // 30 三、函数代码中的this 在这时候this值的首要特点是它不是静态的绑定到一个函数。this是进入上下文时确定,在一个函数代码中,这个值在每一次完全不同,但是在代码运行时的this值是不变的,也就是说,因为它不是一个变量,就不可能为其分配一个新值。 var F = {y: 10}; var Bar = { y: 20, test: function () { alert(this === Bar); // true alert(this.y); // 20 this = F; // 错误,任何时候不能改变this的值 alert(this.y); // 如果不出错的话,应该是10,而不是20 } }; // 在进入上下文的时候 // this被当成Bar对象 B.test(); // true, 20 F.test = Bar.test; // 不过,这里this依然不会是foo // 尽管调用的是相同的function F.test(); // false, 10 在我们通常的函数调用中,this是由激活上下文代码的调用者来提供的,即调用函数的父上下文(parent context )。this取决于调用函数的方式,正是调用函数的方式影响了调用的上下文中的this值,没有别的什么可以看到,即使是正常的全局函数也会被调用方式的不同形式激活,这些不同的调用方式导致了不同的this值。例如: function F() { alert(this); } F(); // global alert(F === F.prototype.constructor); // true // 但是同一个function的不同的调用表达式,this是不同的 F.prototype.constructor(); // F.prototype 那么,调用函数的方式如何影响this值?请看下面 四、引用类型 引用类型的值只有两种情况: 1、当我们处理一个标示符时,2、或者一个属性访问器 在一个函数上下文中,this由调用者提供,由调用函数的方式来决定。如果调用括号()的左边是引用类型的值,this将设为引用类型值的base对象(base object),在其他情况下(与引用类型不同的任何其它属性),这个值为null。不过,实际不存在this的值为null的情况,因为当this的值为null的时候,其值会被隐式转换为全局对象,例如: function F() { return this; } F(); // global 我们看到在调用括号的左边是一个引用类型值(因为F是一个标示符) var fooReference = { base: global, propertyName: 'foo' }; 相应地,this也设置为引用类型的base对象。即全局对象 var F = { B: function () { return this; } }; F.B(); // F 我们再次拥有一个引用类型,其base是F对象,在函数B激活时用作this。 var FB = { base: F, propertyName: 'B' }; 五、作为构造器调用的函数中的this 还有一个与this值相关的情况是在函数的上下文中,这是一个构造函数的调用。 unction A() { alert(this); // "a"对象下创建一个新属性 this.x = 10; } var a = new A(); alert(a.x); // 10 new运算符调用“A”函数的内部的[[Construct]] 方法,接着,在对象创建后,调用内部的[[Call]] 方法。 所有相同的函数“A”都将this的值设置为新创建的对象。 六、函数调用中手动设置this 在函数原型中定义的两个方法允许去手动设置函数调用的this值。它们是.apply和.call方法。他们用接受的第一个参数作为this值,this 在调用的作用域中使用。这两个方法的区别很小,对于.apply,第二个参数必须是数组(或者是类似数组的对象,如arguments,反过来,.call能接受任何参数。两个方法必须的参数是第一个——this。 var dog = { say() { console.log(this) } } var cat = {} dog.say.call(cat) 其中this通过call被绑定到了cat上 七、箭头函数 它的this指向与普通函数有很大的不同。箭头函数内部的 this 是词法作用域,由上下文确定。简单说就是箭头函数中的 this 只和定义它时候的作用域的 this 有关,而与在哪里以及如何调用它无关,同时它的 this 指向是不可改变的。 var obj = { x: 10, foo: function() { var fn = () => { return () => { return () => { console.log(this); //Object {x: 10} console.log(this.x); //10 } } } fn()()(); } } obj.foo(); 对于箭头函数还需要注意一点,就是它的this确定后不会改变。使用call、apply、bind也无法改变它的this,因此使用它们传入的第一个参数无效。但是后面添加的参数值还是有效的。 原文发布时间:2018年01月10日 作者:技术金三胖 本文来源:开源中国如需转载请联系原作者

资源下载

更多资源
Mario

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长,特征是大鼻子、头戴帽子、身穿背带裤,还留着胡子。与他的双胞胎兄弟路易基一起,长年担任任天堂的招牌角色。

Spring

Spring

Spring框架(Spring Framework)是由Rod Johnson于2002年提出的开源Java企业级应用框架,旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念,提供核心容器、应用上下文、数据访问集成等模块,支持整合Hibernate、Struts等第三方框架,其适用范围不仅限于服务器端开发,绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux

Rocky Linux(中文名:洛基)是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版,作为CentOS稳定版停止维护后与RHEL(Red Hat Enterprise Linux)完全兼容的开源替代方案,由社区拥有并管理,支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性,采用模块化包装和SELinux安全架构,默认包含GNOME桌面环境及XFS文件系统,支持十年生命周期更新。

WebStorm

WebStorm

WebStorm 是jetbrains公司旗下一款JavaScript 开发工具。目前已经被广大中国JS开发者誉为“Web前端开发神器”、“最强大的HTML5编辑器”、“最智能的JavaScript IDE”等。与IntelliJ IDEA同源,继承了IntelliJ IDEA强大的JS部分的功能。

用户登录
用户注册