前端常用关键字

关键字in的使用
　　一般用于for...in用来遍历数组或者对象属性
　　注：in可以区分不存在的属性和存在但值为undefined的属性。
1.遍历数组
var n;
var nums=[11,22,36,26,88,12];
for(n in nums){
　　console.log(n)
}
输出结果为 数组nums的下标 0,1，2,3,4,5
2.遍历对象
var n;
var obj={
　　a:"aa",
　　b:"bb",
　　c:"cc"
}
for (n in obj){
　　console.log(n);
}
此时输出的是：a,b,c为对象的属性 并非对应的值

  3.判断对象是否为数组/对象的元素/属性：

　　格式：（变量  in  对象）

　　console.log("11" in nums)//例1　　输出true

　　console.log("a" in obj);//例2　　输出true

 

　4.对象的 hasOwnProperty() 方法

　　用来检测给定的名字是否是对象的自有属性。对于继承属性它将返回 false

　　console.log(obj.hasOwnProperty("a"));　　//true　　自有属性

　　console.log(obj.hasOwnProperty("m"));　　//false　　

　　console.log(obj.hasOwnProperty("toString"));　　//false toString是继承属性

 

　5.propertyIsEnumerable() 是 hasOwnProperty() 的增强版

　　只有检测到是自有属性且这个属性的可枚举性（enumerable attribute）为 true 时它才返回 true

 

对象序列化

　　JSON.stringify() 和 JSON.parse() 用来序列化和还原 JavaScript 对象

a = {
　　x:1,
　　y:{
　　　　z:[false,null,""]
　　　}
};       // 定义一个对象
s = JSON.stringify(a);                  // s是 '{"x":1,"y":{"z":[false,null,""]}}'
p = JSON.parse(s);                      // p是a的深拷贝　

arguments

arguments用法
arguments他的特性和使用方法
特性：
arguments对象和Function是分不开的。因为arguments这个对象不能显式创建，arguments对象只有函数开始时才可用。
使用方法：
虽然arguments对象并不是一个数组，但是访问单个参数的方式与访问数组元素的方式相同
例如：
arguments[0],arguments[1],。。。。。。。。arguments[n]

在js中 不需要明确指出参数名，就能访问它们，例如：
function test() {
        var s = "";
        for (var i = 0; i < arguments.length; i++) {
            alert(arguments[i]);
            s += arguments[i] + ",";
        }
        return s;
    }
    test("name", "age")

输出结果：
name,age

arguments中的callee,指向函数自身引用
关于arguments.callee的案例
求1到100的阶乘，arguments.callee就是找到自己的引用。
var num = (function (n) {
    if(n == 1){
        return 1;
    }
    return n * arguments.callee(n - 1);
}(100))function test() {
    conso.log(arguments.callee);//打印test函数
    function demo () {
        conso.log(arguments.callee);//打印demo函数
    }
    demo();
}
test();
就是说在哪个函数里面的arguments.callee就指向那个函数的引用。

数组

数组
　　删除数组中的元素时，可以使用delete 运算符来删除数组元素。
　　但是：a=[1,2,3,4] delete a[2] 返回的结果中 a.length=4;delete只是删除了下标为2的元素，不会改变数组的长度，后边的元素也不会向前补位
　数组循环遍历时，如果性能有要求，需要优化  可在循环时数组的长度只查询一次而非每次循环都要查询
　　var arr=[1,2,3,4,5,6,'str'];
　　for(var i=0,len=arr.length;i<len;i++){
　　　　//循环体不需要改变
　　}
　　此外 for...in也可用于遍历数组 for(var index in arr){}  不常用（如果数组同时包含对象属性和数组元素，那么枚举出来的顺序就不能保证，如果后期算法依赖于遍历的顺序，那么最好不要使用 for-in 而用常规的 for 循环。）
　　forEach也可用于遍历数组
　　　　var sum=0;
　　　　arr.forEach(function(m){//把数组的每个元素传递给此函数
　　　　　　　//具体对数组的操作 例如对纯数字的数组求和 sum += m;
　　　　})
　数组的arr.toString()和arr.valueOf()和直接输出alter(arr) 值是相同的  alter底层就是toString()
　另外 数组的toLocaleString()方法 输出的是数组的toLocaleString()方法 和toString valueOf的结果有可能不同 例如：
var person1 = {
    toLocaleString : function () {
        return "Nikolaos";
    },
    toString : function() {
        return "Nicholas";
    }
};
var person2 = {
    toLocaleString : function () {
        return "Grigorios";
    },
    toString : function() {
        return "Greg";
    }
};
var people = [person1, person2];
alert(people);                           // Nicholas,Greg
alert(people.toString());                // Nicholas,Greg
alert(people.toLocaleString());          // Nikolaos,Grigorios
数组的排序
var arr=[2,21,32,12,51,5,0]
arr.sort(compare);
function compare(value1, value2) {
    if (value1 < value2) {
        return -1;
    } else if (value1 > value2) {
        return 1;
    } else {
        return 0;
    }
}
　　下一个方法是 splice()，它的主要用途是向数组的中部插入元素，主要有以下3种使用方式。

删除：可以删除任意数量的项，只需指定2个参数：起始位置和要删除元素的数量。例如，splice(0,2) 会删除数组中的前两项。
插入：可以向指定位置插入任意数量的项，只需提供3个参数：起始位置、0（要删除元素的数量）和要插入的元素。如果要插入多个元素，可以再传入第四、第五，以至任意多个元素。例如，splice(2,0,"red","green") 会从当前数组的位置2开始插入字符串 "red" 和 "green"。
替换：可以向指定位置插入任意数量的项，且同时删除任意数量的项，只需指定3个参数：起始位置、要删除元素的数量和要插入的元素。插入的项数不必与删除的项数相等。例如，splice (2,1,"red","green")会删除当前数组位置2的项，然后再从位置2开始插入字符串 "red" 和 "green"
var colors = ["red", "green", "blue"];
var removed = colors.splice(0,1);       // 删除第一项
console.log(colors);                    // green,blue
console.log(removed);                   // red，返回的数组中只包含一项

removed = colors.splice(1, 0, "yellow", "orange");  // 从位置1开始插入两项
console.log(colors);                    // green,yellow,orange,blue
console.log(removed);                   // 返回的是一个空数组

removed = colors.splice(1, 1, "red", "purple");     // 插入两项，删除一项
console.log(colors);                    // green,red,purple,orange,blue
console.log(removed);  
// 例题：（三维数组或 n 维数组）去重
var arr = [2,3,4,[2,3,[2,3,4,2],5],3,5,[2,3,[2,3,4,2],2],4,3,6,2];
var unique = function(arr) {
    var result = [];
    var f = function(i) {
        i.forEach(function(item) {
            if(Array.isArray(item)){
                f(item);
            }else{
                if(result.indexOf(item)<0){
                    result.push(item);
                }
            }
        });
    };
    f(arr);
    return result;
}
console.log(unique(arr)); // [2,3,4,5,6]

函数
　　在函数内部，有两个特殊的对象：arguments 和 this。其中，arguments 是一个类数组对象，包含着传入函数中的所有参数。虽然 arguments 的主要用途是保存函数参数，但这个对象还有一个名叫 callee 的属性，该属性是一个指针，指向拥有这个 arguments 对象的函数。
function factorial(num){
    if (num <= 1) {
        return 1;
    } else {
        return num * factorial(num-1)
    }
}
在这个重写后的 factorial() 函数的函数体内，没有再引用函数名 factorial。这样，无论引用函数时使用的是什么名字，都可以保证正常完成递归调用
function factorial(num){
    if (num <=1) {
        return 1;
    } else {
        return num * arguments.callee(num-1)
    }
}