arguments
克隆
浅克隆
深克隆
var obj = {
name : "Tom",
age: 10,
arr: ["one", "two"],
say: function() {
console.log("abc")
}
};
var obj1 = {
};
// 1 判断原始值 typeof
// 2 判断数组或对象 Object.prototype.toString
// 3 建立相应的数组或对象
// 4 递归
function deepClone(origin, target) {
var target = target || {},
toStr = Object.prototype.toString,
arrStr = "[object Array]";
for(var prop in origin) {
if(origin.hasOwnProperty(prop)) { // 判断是不是自有属性
if(origin[prop] !== null && typeof (origin[prop]) == "object") { // 判断数据类型是不是引用类型
// if(toStr == arrStr) {
// target[prop] = [];
// } else {
// target[prop] = {};
// }
target[prop] = toStr.call(origin[prop]) == arrStr ? [] : {}; // 判断是数组还是对象
deepClone(origin[prop], target[prop]); // 递归，自调用
} else {
target[prop] = origin[prop]; // 如果是基础数据类型，则浅拷贝。
}
}
}
return target
}
deepClone(obj, obj1)
三目运算符 ? :
条件判断 ? 是 : 否 （并且返回）
?前面是条件判断，如果是则执行:前面的，并返回，如果不是则执行:后面的，并返回
var num = 1 < 0 ? 2 + 2 : 1 + 1;
//返回2
//相当于
(function () {
if (1 < 0) {
return console.log(2 + 2)
} else {
return console.log(1 + 1)
}
}())
三目运算符的返回值相当于if else中的return
数组 Array
定义数组：
字面量：var arr = []
var arr = [1,2,3,4,5,6,7,,9]
// arr.length ===> 9
var arr = new Array()
var arr = new Array(1,2,3,4,5,6)
// console.log(arr) ===> [1,2,3,4,5,6]
var arr = new Array(10) // 如果只写一个参数，代表长度为10且没有数据的数组（稀松数组）
// console.log(arr) ===> empty * 10
数组常用方法
可改变原数组
-
push()在数组最后一位添加数据，任何数据都可以，可以同时添加很多个数据
var arr = [];
arr.push(10)
arr.push(1,2,3,4,5,6,7,8,9)
// arr = [10,1,2,3,4,5,6,7,8,9]
内部原理
Array.prototype.push = function(target) {
this[this.length] = target;
this.length ++
}
-
pop()把数组最后一位剪切出来，并返回该值
var arr = [1,2,3,4,5,6]
var num = arr.pop() //返回6
-
shift()把数组的第一位删除，并返回该值。
var arr = [1,2,3,4,5];
arr.shift() //返回1
//arr ===> [2,3,4,5]
-
unshift()在数组最前面一位添加数据，任何数据都可以，可以同时添加很多个数据
var arr = [1,2,3,4,5];
arr.unshift(-1,0)
// arr ===> [-1,0,1,2,3,4,5]
-
sort给数组排序，并改变原数组。
var arr = [1,0,-1,4,3]
arr.sort();
// arr ===> [-1, 0, 1, 3, 4]
语法： arr.sort([compareFunction])
[compareFunction]可选，用来指定按某种顺序进行排列的函数。
var arr = [1,4,10,2,5,-1,0]
arr.sort()
console.log(arr) // [-1, 0, 1, 10, 2, 4, 5]
// 这个排序是根据各个字符的Unicode位点进行排序的
// 但这个排序并不是我们想要的。怎么办？
var arr1 = [1,4,10,2,5,-1,0]
arr1.sort(function(a,b) {
// return a - b //升序 [-1, 0, 1, 2, 4, 5, 10]
return b - a //降序 [10, 5, 4, 2, 1, 0, -1]
})
-
reverse反向排列数组，并返回原数组
var arr = [1,2,3,4,5]
arr.reverse(); //返回原数组[5,4,3,2,1]
// arr ===> [5,4,3,2,1]
-
splice截取数组，并返回截取的内容，并且修改原数组。
splice()可填三个参数
splice(从第几位开始，截取多少长度，在切口处添加新的数据)
//在数组中，3和5中插入4
var arr = [1,2,3,5];
arr.splice(3,0,4) //从第三位开始，截取0位，插入4
//arr ===> [1,2,3,4,5]
不可改变原数组
-
concat合并两个数组，并返回新数组
var arr= [1,2]
var arr1 = [3,4,5,6]
var arr2 = arr.concat(arr1)
console.log(arr2) //[1,2,3,4,5,6]
-
join将数组中所有元素连接为一个字符串
join([字符串类型])
var arr = [1,2,3,4,5,6]
arr.join("-") // "1-2-3-4-5-6"
-
split使用指定的分隔符字符串将一个字符串分割成字符串数组
var str = "1-2-3-4-5-6";
var arr1 = arr.split("-");
console.log(arr1); // ["1", "2", "3", "4", "5", "6"]
toString把数组转成字符串slice剪切一个数组，并返回新数组
array.slice([开始索引],[结束索引])但并不包括结束索引
var arr = [1,2,3,4,5,6,7]
var arr1 = arr.slice(1,5)
console.log(arr1)
两个相同的数组，并不相等。数组是对象，是引用类型，引用的地址不同。
[1,2,3,4] == [1,2,3,4] // false
[1,2,3,4] === [1,2,3,4] // false
类数组
- 可以利用属性名，模拟数组特性
- 可以动态增长length属性
- 如果强行让类数组调用push方法，则会根据length属性值的位置进行属性的扩充。
var obj = {
"0" : "first",
"1" : "second",
"2" : "thrid",
"length": 3,
"push" : Array.prototype.push,
"splice" : Array.prototype.splice //写上splice方法后，可是对象像数组一样操作。
}
某年阿里的面试题
var obj = {
"2" : "a",
"3" : "b",
"length" : "2",
"push" : Array.prototype.push
}
obj.push("c");
obj.push("d");
// 问，最后obj变成什么？"2" : "c", "3" : "d"
//
// 类数组添加东西是根据length的改变而改变。
类数组，属性一定要为索引（数字）属性，必须有length属性，最好写上push方法。
类数组，也是对象，也类似数组。
封装type方法
function type(target) {
var typeIs = typeof(target);
var ret = {
"[object Array]" : "Array",
"[object Object]" : "Object",
"[object Number]" : "Object Number",
"[object Boolean]" : "Object Boolean",
"[object String]" : "Object String"
}
if(target === null) {
return "null"
} else if(typeIs == "object") {
var str = Object.prototype.toString.call(target)
return ret[str]
} else {
return typeIs
}
}