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
alert(c.constructor === Array) ----------> true
alert(d.constructor === Date) -----------> true
alert(e.constructor === Function) -------> true
注意： constructor 在类继承时会出错
4、无敌通用方法jQuery.type()
jQuery.type( undefined ) === "undefined"
jQuery.type() === "undefined"
jQuery.type( window.notDefined ) === "undefined"
jQuery.type( null ) === "null"
jQuery.type( true ) === "boolean"
jQuery.type( 3 ) === "number"
jQuery.type( "test" ) === "string"
jQuery.type( function(){} ) === "function"
jQuery.type( [] ) === "array"
jQuery.type( new Date() ) === "date"
jQuery.type( new Error() ) === "error" // as of jQuery 1.9
jQuery.type( /test/ ) === "regexp"
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常用数组处理方法(蓝色为es6新增数组方法)
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.log(arr.reverse()); //[3, 51, 24, 13]
console.log(arr); //[3, 51, 24, 13](原数组改变)
concat()->将参数添加到数组中，然后返回一个新构建的数组，原数组未改变
var arr = [1,3,5,7];
var arrCopy = arr.concat(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)); //2
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 = values.reduceRight(function(prev, cur, index, array){
return prev + cur;
},10);
console.log(sum); //25
最近一段时间把js的基础又复习了一下，总结一下常用的操作方法，欢迎补充指正