js数据类型以及数组字符串常⽤⽅法JS判断数据类型
例⼦：
var a = "iamstring.";
var b = 222;
var c= [1,2,3];
var d = new Date();
var e = function(){alert(111);};
var f = function(){this.name="22";};
1、最常见判断⽅法：typeof
可以判断基本数据类型，对于引⽤数据类型就要⽤别的
alert(typeof a)  ------------> string
alert(typeof b)  ------------> number
alert(typeof c)  ------------> object
alert(typeof d)  ------------> object
alert(typeof e)  ------------> function
alert(typeof f)  ------------> function
2、判断已知对象类型⽅法：instanceof
alert(c instanceof Array) ---------------> true
alert(d instanceof Date)
alert(f instanceof Function) ------------> true
alert(f instanceof function) ------------> false
3、根据对象的constructor判断：constructor
structor === Array) ----------> true
structor === Date) -----------> true
structor === Function) -------> true
注意： constructor 在类继承时会出错
4、⽆敌通⽤⽅法pe()
JQuery判断
jQuery.isArray()：是否为数组，返回值为⼀个布尔
jQuery.isFunction()：是否为函数
jQuery.isPlainObject()：是否为使⽤{}或new Object⽣成对象
jQuery.isNumeric()：是否为数字
Js常⽤字符串处理⽅法
js⾃带函数
concat(将两个或者多个字符⽂本组合起来，返回⼀个新的字符串)
var a = “hello”
var b = “,world”
var d = “snow”
var c = a.concat(b,d);
Console.log(c)//“hello,worldsnow”
indexOf(返回字符串中⼀个⼦串第⼀次出现的索引值，从左到右，如果没值则返回-1)
var index1 = a.indexOf(‘l’);//index1 = 2;
var index2 = a.indexOf(“l”,3);//index2 = 3
chartAt(返回指定位置的字符)
var get_char = a.chartAt(0);//get_char = “h”
lastIndexOf(返回字符串中⼀个⼦串最后⼀处出现的索引，从右向左搜索，如果没有匹配，返回-1)
var index1 = a.lastindexOf(‘l’);//index1 = 3;
var index2 = a.lastindexOf(“l”,3);//index2 = 2
match(检查⼀个字符串匹配⼀个正则表达式内容，如果没有则返回null)
var re = new RegExp(/^\w+$/);
var is_Ma = a.match(re);//is_Ma = “hello”
var is_Ma2 = b.match(re);//is_Ma2 = null
substring(返回字符串的⼀个⼦串，传⼊参数是起始位置和结束位置)
var sub_string1 = a.substring(1);
/
/sub_string1 = "ello"
var sub_string2 = a.substring(1,4);
//sub_string2 = "ell"
substr(返回字符串的⼀个⼦串，传⼊参数是起始位置和长度)
var sub_string1 = a.substr(1);
//sub_string1 = "ello"
var sub_string2 = a.substr(1,4);
//sub_string2 = "ello"
replace(⽤来查匹配⼀个正则表达式字符串，然后使⽤新字符代替匹配的字符串)
var result1 = a.replace(re,"Hello");
//result1 = "Hello"
var result2 = b.replace(re,"Hello");
//result2 = ",world"
search(执⾏⼀个正则表达式匹配查，如果查成功，返回字符串匹配的索引，否则返回-1)
var index1 = a.search(re);
//index1 = 0
var index2 = b.search(re);
//index2 = -1
slice(提取字符串的⼀个⼦串，返回⼀个新的字符串，传⼊参数是起始位置和结束位置，同substring)
split(通过将字符串划分成⼦串，将⼀个字符串做出字符串数组)
var arr1 = a.split("");
//arr1 = [h,e,l,l,o]
length()
var len = a.length();
//len = 5
toLowerCase()
var lower_string = a.toLowerCase();
//lower_string = "hello"
toUpperCase()
var upper_string = a.toUpperCase();
//upper_string = "HELLO"
js常⽤数组处理⽅法(蓝⾊为es5新增数组⽅法)
join()->将数组元素组起⼀个字符串，以⾃⼰定义的符号分割，省略的话则以逗号分割，该⽅法只接收⼀个参数：分隔符
var arr = [1,2,3];
console.log(arr.join());//1,2,3
Console.log(arr.join(“-”));//1-2-3
push()和pop()
push()：可以接收任意数量的参数，逐个添加到数组末尾，并返回修改后的数组长度；
pop()：数组末尾移除最后⼀项，减少数组的length值，返回移除的项
var arr = ["Lily","lucy","Tom"];
var count = arr.push("Jack","Sean");
console.log(count); // 5
console.log(arr); // ["Lily", "lucy", "Tom", "Jack", "Sean"]
var item = arr.pop();
console.log(item); // Sean
console.log(arr); // ["Lily", "lucy", "Tom", "Jack"]
shift()和unshift()
shift()：删除原数组第⼀项，并返回删除的元素；如果为空则返回undefined;
unshift()：将参数添加到原数组开头，并返回数组的长度
var arr = ["Lily","lucy","Tom"];
var count = arr.unshift("Jack","Sean");
console.log(count); // 5
console.log(arr); //["Jack", "Sean", "Lily", "lucy", "Tom"]
var item = arr.shift();
console.log(item); // Jack
console.log(arr); // ["Sean", "Lily", "lucy", "Tom"]
sort()->按升序排列数组项
在排序的时候，sort()⽅法会先把数组的每⼀项转化为字符串再⽐较(toString())，因此会出现数字不是按照升序的⽅式排列这时候就需要⾃⼰写⼀个⽅法来调⽤function compare(value1, value2) {
if (value1 < value2) {
return -1;
} else if (value1 > value2) {
return 1;
} else {
return 0;
}
}
arr2 = [13, 24, 51, 3];
console.log(arr2.sort()); // [13, 24, 3, 51]直接调⽤排序的话
console.log(arr2.sort(compare)); // [3, 13, 24, 51]
reverse()->反转数组项顺序
var arr = [13, 24, 51, 3];
console.verse()); //[3, 51, 24, 13]
console.log(arr); //[3, 51, 24, 13](原数组改变)
concat()->将参数添加到数组中，然后返回⼀个新构建的数组，原数组未改变
var arr = [1,3,5,7];
var arrCopy = at(9,[11,13]);
console.log(arrCopy); //[1, 3, 5, 7, 9, 11, 13]
console.log(arr); // [1, 3, 5, 7](原数组未被修改)
slice()->返回从原数组指定开始下标和结束下标之间的新数组，有两个参数，如果参数出现负值，则为负数加上数组的长度的值
var arr = [1,3,5,7,9,11];
var arrCopy = arr.slice(1);
var arrCopy2 = arr.slice(1,4);
var arrCopy3 = arr.slice(1,-2);
var arrCopy4 = arr.slice(-4,-1);
console.log(arr); //[1, 3, 5, 7, 9, 11](原数组没变)
console.log(arrCopy); //[3, 5, 7, 9, 11]
console.log(arrCopy2); //[3, 5, 7]
console.log(arrCopy3); //[3, 5, 7]
console.log(arrCopy4); //[5, 7, 9]
splice()->可以实现删除，插⼊和替换，最终返回删除的选项数组
删除：可以删除任意数量的项，只需指定 2 个参数：要删除的第⼀项的位置和要删除的项数。例如， splice(0,2)会删除数组中的前两项。
插⼊：可以向指定位置插⼊任意数量的项，只需提供 3 个参数：起始位置、 0（要删除的项数）和要插⼊的项。例如，splice(2,0,4,6)会从当前数组的位置 2 开始插⼊4和6。
替换：可以向指定位置插⼊任意数量的项，且同时删除任意数量的项，只需指定 3 个参数：起始位置、要删除的项数和要插⼊的任意数量的项。插⼊的项数不必与删除的项数相等。例如，splice (2,1,4,6)会删除当前数组位置 2 的项，然后再从位置 2 开始插⼊4和6。
var arr = [1,3,5,7,9,11];
var arrRemoved = arr.splice(0,2);
console.log(arr); //[5, 7, 9, 11]
console.log(arrRemoved); //[1, 3]
var arrRemoved2 = arr.splice(2,0,4,6);
console.log(arr); // [5, 7, 4, 6, 9, 11]
console.log(arrRemoved2); // []
var arrRemoved3 = arr.splice(1,1,2,4);
console.log(arr); // [5, 2, 4, 4, 6, 9, 11]
console.log(arrRemoved3); //[7]
indexOf()和lastIndexOf()返回要查的项的位置索引，没到返回-1
indexOf()：接收两个参数，要查的项和表⽰查起点位置的索引（可选），从数组开头往后查
lastIndexOf()：同上，只是从数组末尾开始向前查
var arr = [1,3,5,7,7,5,3,1];
console.log(arr.indexOf(5)); //2
console.log(arr.lastIndexOf(5)); //5
console.log(arr.indexOf(5,2)); //2
console.log(arr.lastIndexOf(5,4)); //2indexof能用于数组吗
console.log(arr.indexOf("5")); //-1
forEach()->对数组进⾏遍历循环，对数组中的每⼀项运⾏给定函数，没有返回值；参数分别为：遍历的数组内容；对应的数组索引；数组本⾝
var arr = [1, 2, 3, 4, 5];
arr.forEach(function(x, index, a){
console.log(x + '|' + index + '|' + (a === arr));
});
// 输出为：
// 1|0|true
// 2|1|true
// 3|2|true
// 4|3|true
// 5|4|true
map()->映射，对数组中每⼀项运⾏给定的函数，返回每次函数调⽤的结果组成的数组
var arr = [1, 2, 3, 4, 5];
var arr2 = arr.map(function(item){
return item*item;
});
console.log(arr2); //[1, 4, 9, 16, 25]
filter()->过滤功能，数组中每⼀项运⾏给定的函数，返回满⾜条件组成的数组
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var arr2 = arr.filter(function(x, index) {
return index % 3 === 0 || x >= 8;
});
console.log(arr2); //[1, 4, 7, 8, 9, 10]
every()->判断数组中每⼀项是否满⾜条件，只有所有项都满⾜才会返回true
var arr = [1, 2, 3, 4, 5];
var arr2 = arr.every(function(x) {
return x < 10;
});
console.log(arr2); //true
var arr3 = arr.every(function(x) {
return x < 3;
});
console.log(arr3); // false
some()->判断数组中是否存在满⾜条件的项，只要有⼀项满⾜条件就会返回true
var arr = [1, 2, 3, 4, 5];
var arr2 = arr.some(function(x) {
return x < 3;
});
console.log(arr2); //true
var arr3 = arr.some(function(x) {
return x < 1;
});
console.log(arr3); // false
reduce()和 reduceRight()
这两个⽅法都会实现迭代数组的所有项，然后构建⼀个最终返回的值。reduce()⽅法从数组的第⼀项开始，逐个遍历到最后。⽽ reduceRight()则从数组的最后⼀项开始，向前遍历到第⼀项。
这两个⽅法都接收两个参数：⼀个在每⼀项上调⽤的函数和（可选的）作为归并基础的初始值。
传给 reduce()和 reduceRight()的函数接收 4 个参数：前⼀个值、当前值、项的索引和数组对象。这个函数返回的任何值都会作为第⼀个参数⾃动传给下⼀项。第⼀次迭代发⽣在数组的第⼆项上，因此第⼀个参数是数组的第⼀项，第⼆个参数就是数组的第⼆项。
下⾯代码⽤reduce()实现数组求和，数组⼀开始加了⼀个初始值10。
var values = [1,2,3,4,5];
var sum = duceRight(function(prev, cur, index, array){
return prev + cur;
},10);
console.log(sum); //25
最近⼀段时间把js的基础⼜复习了⼀下，总结⼀下常⽤的操作⽅法，欢迎补充指正

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。