JS 学习经验

在工作的时候遇到很多js的问题，然后自己就去看了，做了一些笔记，一起发表出来。

js数组学习

js这个东西，真是java不能够比的，感觉入门很容易，但是后面整起来真是不爽，最近在做项目时经常运用到js的数组操作，但这玩意真心玩起来不爽，今天专门花时间来，具体来学习。还是要吐槽js这玩意 真是麻烦

JS的数组可以使用Array（new Array）和[]，我经常使用[]来创建数组。

数组遍历

循环.forEach() 方法用来循环遍历数组，说IE7和IE8不支持，哎，那玩意就是恼火

[1,2,3,4].forEach(function(value,index,array){
 console.log(value); 
})

value 是遍历出来的值，index是遍历的序号，array就是这个数组

satisfied = [10, 12, 10, 8, 5, 23].some(function (value, index, array) {
   console.log(value);
   return value=10
})


console.log(satisfied);
// <- true
console.log("-------------");

satisfied = [10, 12, 10, 8, 5, 23].every(function (value, index, array) {
   console.log(value);
   return value==10
})
console.log(satisfied);

输出的结果

10
true
-------------
10
12
false
[Finished in 0.3s]

some 方法当回调函数返回的是true的时候就将返回，如果一直不能够返回true就讲一直执行到数组结束

every方法相反，是当返回的false时结束循环

这种的遍历的效率 说是比较低，但是我并没有验证
for( r in t){
    console.log(t[r]);
}
in 也可以用于遍历数组 但是这里的r 只是表示数组的序号

数组的串行化

var b=['qw','we','er','rt'];
var bb = b.join(",");

var b2 = b.toString()

bb b2输出

qw,we,er,rt

用”,”分隔然后组成新的字符串 join()还可以指定分隔符，组成的新的字符串

数组元素添加

var b=['qw','we','er','rt'];
b.push('re')//在数组结尾添加元素 返回新数组的长度
b.unshift('re')在元素开头添加元素 返回新数组的长度

b.splice(1,0,'ew')//这表示在第一位（0开始）添加'we' 这里的第二个参数，表示删除几位，如果这里第二个参数是1表示将第一位删除后将ew 添加 整个数组长度不变。如果是2 表示将第一位后的两个删除，然后添加ew

数组的截取和合并

arrayObj.slice(start, [end]); //以数组的形式返回数组的一部分，注意不包括 end 对应的元素，如果省略 end 将复制 start 之后的所有元素

arrayObj.concat('reeee'); //将多个数组（也可以是字符串，或者是数组和字符串的混合）连接为一个数组，返回连接好的新的数组

数组元素的排序

arrayObj.reverse(); //反转元素（最前的排到最后、最后的排到最前），返回数组地址

arrayObj.sort(); //对数组元素排序，返回数组地址

JavaScript一些基础学习

有关闭包

闭包我感觉自己没有那么多理论，我的理解就是函数里面有属性，有操作的方法，就应该算闭包 还是代码来的直观

var generateClosure = function() {
var count = 0;
var get = function() {
count ++;
return count;
};
return get;
};

var counter = generateClosure();
var counter2 = generateClosure();
console.log(counter()); // 输出 1
console.log(counter()); // 输出 2
console.log(counter()); // 输出 3
console.log(counter2());//输出1

一、闭包时，返回的函数不光只有函数，还包括定义函数的环境（就是函数中的变量等），函数中的变量会跟着环境变化而变化，他不会随着函数定义的返回而消释。
二、当一个函数，产生两个闭包实例的时候，两个实例相互独立。不会相互影响（他们的函数环境，相互独立，不相互影响）

js原型（prototype）

还是直接上代码吧

function Foo() {
}
Object.prototype.name = 'My Object';
Foo.prototype.name = 'Bar';
var obj = new Object();
var foo = new Foo();
console.log(obj.name); // 输出 My Object
console.log(foo.name); // 输出 Bar
console.log(foo.__proto__.name); // 输出 Bar
console.log(foo.__proto__.__proto__.name); // 输出 My Object
console.log(foo. __proto__.constructor.prototype.name); // 输出 Bar

js属性特征

Object.defineProperty(o,'x',{
    value:1,
    writable:true,
    enumerable:false,
    configurable:true
});

console.log(Object.getOwnPropertyDescriptor(o,'x'));

js 属性4个特征分别是值(value),可写行(writable),可枚举性(enumerable:false)可配置型(configurable)

writable:false时不能够设置value的值。

enumerable：false是不能够用for in 遍历出他的key

configurable不可配置型，false 就不能够配置上面的属性

用defineProperty(object,fild，{})来配置属性

getOwnPropertyDescriptor(object,fild)开获取属性描述

JS高级写法学习

! function te(){
    console.log("reee");
}()

上面的写法表示 当js脚本解释器解释到这个位置的时候就要执行该function

function te(){
     this.t='t--->';
     this.tt= function(re){
        console.log(this.t+re);
    }
    var ttt='';
}
te.prototype.tr = function() {
    console.log(this.t);
};

var th = new te();
th.tt('ewww');

只有通过this定义的属性才能够访问 其中的ttt只能够在te构造函数中访问，不能够通过prototype访问，这样就形成了私有变量

JSON 做参数

function five(son){
        var t = 'this is color '+son.color+' for '+son.persone;
        son.success(t)
    }

five({
    color:'red',
    persone:'tangc',
    success:function(t){
        console.log(t);
    }

})//输出this is color red for tangc