第199天：js---扩充内置对象功能总结

一、数组

1、删除数组中指定索引的数据

1 /** 删除数组中指定索引的数据 **/
2 Array.prototype.deleteAt = function (index) {
3     if (index < 0) {
4         return this;
5     }
6     return this.slice(0, index).concat(this.slice(index + 1, this.length));
7 }

2、数组洗牌

1 /** 数组洗牌 **/
2 Array.prototype.random = function () {
3     var tempArr = [], me = this, t;
4     while (me.length > 0) {
5         t = Math.floor(Math.random() * me.length);
6         tempArr[tempArr.length] = me[t];
7         me = me.deleteAt(t);
8     }
9     return tempArr;
10 }
11 Array.prototype.orderRandom = function () {
12     return this.sort(function () {
13         return Math.random() > 0.5 ? "-1" : "1";
14     });
15 }

3、数字数组排序

1 /** 数字数组排序 **/
2 Array.prototype.sortNum = function (i) {
3     if (!i) {
4         i = 0;
5     }
6     if (i == 1) {
7         return this.sort(function (a, b) {
8             return b - a;
9         });
10     }
11     return this.sort(function (a, b) {
12         return a - b;
13     });
14 }

4、获取数字数组中的最大项

1 /** 获取数字数组中的最大项 **/
2 Array.prototype.getMax = function () {
3     return this.sortNum(1)[0];
4 }

5、获取数字数组中的最小项

1 /** 获取数字数组中的最小项 **/
2 Array.prototype.getMin = function () {
3     return this.sortNum(0)[0];
4 }

6、数组第一次出现指定元素的位置

1 /** 数组第一次出现指定元素的位置 **/
2 Array.prototype.indexOf = function (o) {
3     for (var i = 0; i < this.length; i++) {
4         if (this[i] == o) {
5             return i;
6         }
7     }
8     return -1;
9 }

7、去除数组中的重复项

1 /** 去除数组中的重复项 **/
2 Array.prototype.arrUnique = function () {
3     var reset = [], done = {};
4     for (var i = 0; i < this.length; i++) {
5         var temp = this[i];
6         if (!done[temp]) {
7             done[temp] = true;
8             reset.push(temp);
9         }
10     }
11     return reset;
12 }

二、常用string内置对象方法

1、concat() – 将两个或多个字符的文本组合起来，返回一个新的字符串

1 //concat() – 将两个或多个字符的文本组合起来，返回一个新的字符串。
2     var str = "Hello";
3     var out = str.concat(" World","!");
4     console.log(str); //Hello
5     console.log(out); //Hello World!

2、charAt() – 返回指定位置的字符

1 //charAt() – 返回指定位置的字符。
2     var str = "HelloString";
3     var out = str.charAt(1);
4     console.log(out); //e

3、charCodeAt() – 返回在指定的位置的字符的 Unicode 编码

1 //charCodeAt() – 返回在指定的位置的字符的 Unicode 编码。
2     var str = "HelloString";
3     var out = str.charCodeAt(5);
4     console.log(out); //83

4、indexOf(searchvalue,fromindex) – 返回字符串中一个子串第一处出现的索引，如果没有匹配项，返回 -1

1 //indexOf(searchvalue,fromindex) – 返回字符串中一个子串第一处出现的索引，如果没有匹配项，返回 -1 。
2     //fromindex是可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。
3     //如省略该参数，则将从字符串的首字符开始检索,此时indexOf()跟search()方法类似。
4     var str = "HelloStringend";
5     console.log(str.indexOf("e")); //1
6     console.log(str.indexOf("e",2)); //11

5、lastIndexOf(searchvalue,fromindex) – 返回字符串中一个子串最后一处出现的索引，如果没有匹配项，返回 -1

1 //lastIndexOf(searchvalue,fromindex) – 返回字符串中一个子串最后一处出现的索引，如果没有匹配项，返回 -1 。
2     //如果在 stringObject 中的 fromindex 位置之前存在 searchvalue，则返回的是出现的最后一个 searchvalue 的位置。
3     var str = "HelloString";
4     console.log(str.lastIndexOf("l")); //3
5     console.log(str.lastIndexOf("l", 1)); //-1
6     console.log(str.lastIndexOf("l", 2)); //2
7     console.log(str.lastIndexOf("l", 3)); //3

6、substring(start,end) – 返回一个新的字符串,包括 start 处的字符,但不包括 end 处的字符,其长度为 end 减 start

1 //substring(start,end) – 返回一个新的字符串,包括 start 处的字符,但不包括 end 处的字符,其长度为 end 减 start
2     //substring是以两个参数中较小一个作为起始位置，较大的参数作为结束位置。
3     //注意：如果参数是负数，substring则会将负参数都直接转换为0，如果仅有一个参数，则从start开始到末尾。
4     var str = "HelloExample";
5     console.log(str); //HelloExample
6     console.log(str.substring(1, 3)); //el
7     console.log(str.substring(3, 1)); //el
8     console.log(str.substring(2)); //lloExample
9     console.log(str.substring(-1)); //HelloExample
10     console.log(str.substring(-1, -3)); //空字符串
11     console.log(str.substring(-1, 5)); //Hello

7、substr(start [,length]) – 返回一个新的字符串,从起始索引号提取字符串中指定数目的字符

1 //substr(start [,length]) – 返回一个新的字符串,从起始索引号提取字符串中指定数目的字符。
2     //如果仅有一个参数，则从start开始到末尾。
3     //当接收的参数是负数时,substr是将第一个参数与字符串长度相加后的结果作为第一个参数
4     var str = "HelloExample";
5     console.log(str); //HelloExample
6     console.log(str.substr(1, 3)); //ell
7     console.log(str.substr(2, -1)); //空字符串
8     console.log(str.substr(1)); //elloExample
9     console.log(str.substr(-4, 2)); //mp
10     console.log(str.substr(-3)); //ple

8、stringObject.slice(start,end) 返回一个新的字符串,包括 start 处的字符,但不包括 end 处的字符,其长度为 end 减 start

1 //stringObject.slice(start,end) 返回一个新的字符串,包括 start 处的字符,但不包括 end 处的字符,其长度为 end 减 start
2     //当接收的参数是负数时，slice会将它字符串的长度与对应的负数相加，结果作为参数。如果仅有一个参数，则从start开始到末尾。
3     var str = "HelloExample";
4     console.log(str); //HelloExample
5     console.log(str.slice(1, 3)); //el
6     console.log(str.slice(2)); //lloExmaple
7     console.log(str.slice(3, 1)); //空字符串
8     console.log(str.slice(-4, -1)); //mpl
9     console.log(str.slice(-4, 0)); //空字符串
10     console.log(str.slice(-1, -4)); //空字符串
11     console.log(str.slice(1, -4)); //elloExa

9、将字符串转换成大/小写字母

1 //toLowerCase() – 将整个字符串转成小写字母。
2     //toUpperCase() – 将整个字符串转成大写字母。
3     var str = "How Are you";
4     console.log(str.toLowerCase()); //how are you
5     console.log(str.toUpperCase()); //HOW ARE YOU

10、支持正则表达式的 String 对象的方法

1 /*split,match,replace,search*/
2     //stringObject.split(separator,howmany),返回一个字符串数组。该数组是通过在 separator 指定的边界处将字符串 stringObject 分割成子串创建的。返回的数组中的字串不包括 separator 自身。
3     var str = "How are you doing today";
4     console.log(str.split(" ")); //["How", "are", "you", "doing", "today"]
5     console.log(str); //How are you doing today
6     console.log(str.split("")); //["H", "o", "w", " ", "a", "r", "e", " ", "y", "o", "u", " ", "d", "o", "i", "n", "g", " ", "t", "o", "d", "a", "y"]
7     console.log(str.split("", 3)); //["H", "o", "w"]
8     console.log(str.split("a")); //["How ", "re you doing tod", "y"]
9     console.log(str.split("good")); //["How are you doing today"]
10     var str = "a_db-c(d+e";
11     console.log(str.split(/[^a-z]/i)); //["a", "db", "c", "d", "e"]

（1）match(searchvalue)

1 /** match(searchvalue) 或 match(regexp)检查一个字符串是否匹配一个正则表达式。返回存放匹配结果的数组。
2     match() 方法将检索字符串 stringObject，以找到一个或多个与 regexp 匹配的文本。这个方法的行为在很大程度上有赖于 regexp 是否具有标志 g。
3     如果 regexp 没有标志 g，那么 match() 方法就只能在 stringObject 中执行一次匹配。如果没有找到任何匹配的文本， match() 将返回 null。否则，它将返回一个数组，其中存放了与它找到的匹配文本有关的信息。该数组的第 0 个元素存放的是匹配文本，而其余的元素存放的是与正则表达式的子表达式匹配的文本。除了这些常规的数组元素之外，返回的数组还含有两个对象属性。index 属性声明的是匹配文本的起始字符在 stringObject 中的位置，input 属性声明的是对 stringObject 的引用。
4     如果 regexp 具有标志 g，则 match() 方法将执行全局检索，找到 stringObject 中的所有匹配子字符串。若没有找到任何匹配的子串，则返回 null。如果找到了一个或多个匹配子串，则返回一个数组。不过全局匹配返回的数组的内容与前者大不相同，它的数组元素中存放的是 stringObject 中所有的匹配子串，而且也没有 index 属性或 input 属性。
5     **/
6     var str = "Hello world! Hello";
7     console.log(str.match("lo")); //["lo"] { index: 3, input: "Hello world! Hello" }
8     console.log(str.match("world")); //["world"] { index: 6, input: "Hello world! Hello" }
9     console.log(str.match("world").index); //6
10     console.log(str.match(/Hello/g)); //["Hello", "Hello"]
11     console.log(str.match("World")); //null
12     var str = "1 plus 2 equal 3";
13     console.log(str.match(/\d+/g)); //["1", "2", "3"]

（2）replace()

1  //replace() 方法用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。
2     //stringObject.replace(regexp/substr,replacement),返回一个新的字符串，是用 replacement 替换了 regexp 的第一次匹配或所有匹配之后得到的。
3     //replacement 可以是字符串，也可以是函数。如果它是字符串，那么每个匹配都将由字符串替换。但是 replacement 中的 $ 字符具有特定的含义，它说明从模式匹配得到的字符串将用于替换。
4     //  $1、$2、...、$99----与 regexp 中的第 1 到第 99 个子表达式相匹配的文本。
5     //  $&------------------与 regexp 相匹配的子串。
6     //  $`------------------位于匹配子串左侧的文本。
7     //  $'------------------位于匹配子串右侧的文本。
8     //  $$------------------直接量符号。
9     var str = "Visit HangZhou";
10     console.log(str); //Visit HangZhou
11     console.log(str.replace(/Hang/g, "Su")); //Visit SuZhou
12     var str = "1 plus 2 equal 3";
13     console.log(str); //1 plus 2 equal 3
14     console.log(str.replace(/(\d)/g, "*"));  //* plus * equal *
15
16     var str = "as An angle";
17     console.log(str.replace(/a/, "b")); //bs An angle
18     console.log(str.replace(/a/g, "b")); //bs An bngle
19     console.log(str.replace(/a/gi, "b")); //bs bn angle
20
21     var str = "Karl,John";
22     console.log(str.replace(/(\w+)\s*,\s*(\w+)/, "$2,$1")); //John,Karl
23
24     var str = '"ab", "b"';
25     console.log(str.replace(/"([^"]*)"/g, "'$1'")); //'ab', 'b'
26
27     var str = "aaa bbb ccc";
28     console.log(str.replace(/\b\w+\b/g, function (w) {
29         return w.substring(0, 1).toUpperCase() + w.substring(1);
30     })); //Aaa Bbb Ccc

（3）search() – 执行一个正则表达式匹配查找

1 //search() – 执行一个正则表达式匹配查找。如果查找成功，返回字符串中匹配的索引值。否则返回 -1 。
2     //stringObject.search(regexp) 返回stringObject 中第一个与 regexp 相匹配的子串的起始位置。
3     //此方法跟indexOf类似。此方法会忽略g标识
4     var str = "Visit HangZhou";
5     console.log(str) //Visit HangZhou
6     console.log(str.search(/Hang/)); //6
7     console.log(str.search(/hang/)); //-1
8     console.log(str.search(/hang/i)); //6
9     var str = "1 plus 2 equal 3";
10     console.log(str) //1 plus 2 equal 3
11     console.log(str.search(/\d/g)); //0