JavaScript笔记(1)

全局变量

strict模式

JavaScript在设计之初，为了方便初学者学习，并不强制要求用var申明变量。这个设计错误带来了严重的后果：如果一个变量没有通过var申明就被使用，那么该变量就自动被申明为全局变量：

i = 10; // i现在是全局变量
在同一个页面的不同的JavaScript文件中，如果都不用var申明，恰好都使用了变量i，将造成变量i互相影响，产生难以调试的错误结果。为了修补JavaScript这一严重设计缺陷，ECMA在后续规范中推出了strict模式，在strict模式下运行的JavaScript代码，强制通过var申明变量，未使用var申明变量就使用的，将导致运行错误。
启用strict模式的方法是在JavaScript代码的第一行写上：
'use strict'

对象

JavaScript的对象是一种无序的集合数据类型，它由若干键值对组成。

创建一个对象：

var person={
  name="小明",
  age=20,
  sex=man
};

添加和删除属性：

/* 添加属性 */
person.hight;//未定义的属性先定义
person.hight=180;//给添加的属性赋值

/* 删除属性的两种方法 */
delet persion.hight;
delet persion['hight'];

检查对象是否拥有某个属性：

'name' in persion;//true

//因为toString是定义在object对象中，所有的对象都是object的子类
'toString' in persion;//true

//判断属性是该对象自己的还是继承的
persion.hasOwnProperty('name'); // true
persion.hasOwnProperty('toString'); // false

JavaScript的集合

Map

类似java的Map,根据键值对来定位数据，有序的集合。
例如：

var m=new Map();
m.set('key01',10);
m.set('key02',20);

m.get('key01');//10

Set

类似java的Set，无序的集合。

var s= new Set();
s.add(1);s.add(3);s.add(2);

iterable

遍历Array可以采用下标循环，遍历Map和Set就无法使用下标。为了统一集合类型，ES6标准引入了新的iterable类型，Array、Map和Set都属于iterable类型。

1. 具有iterable类型的集合可以通过新的for … of循环来遍历。

var a = ['A', 'B', 'C'];
for(x of a){
    alert(x);
    //输出A B C
};

1. 使用forEach(element,index,array)

数组：

var a = ['A', 'B', 'C'];
a.forEach(function (element, index, array) {
    // element: 指向当前元素的值
    // index: 指向当前索引
    // array: 指向Array对象本身
    alert(element+"--"+index+"--"+array);
    //输入格式：A--0--A,B,C
});

Set:

var s = new Set(['A', 'B', 'C']);
s.forEach(function (element, sameElement, set) {
     // element: 指向当前元素的值
     //sameElement:和element一样
     //setobject
    alert(element+"--"+sameElement+"--"+set);
    //输出格式：A--A--[object Set]
});

Map:

var m = new Map([[1, 'x'], [2, 'y'], [3, 'z']]);
m.forEach(function (value, key, map) {
    alert(value+'--'+key+"--"+map);
    //输出格式：
    //1--x--[object Map]
});

函数

方法函数

在对象中定义的方法称为方法函数

this关键字

var bart={
  name:'bart',
  birthday:1993,
  age:function (){
      var a = new Date().getFullYear();
      return a-this.birthday;
  }
};

bart.age();//输出23

/*===================================*/
function getAge() {
    var y = new Date().getFullYear();
    return y - this.birthday;
}

var bart = {
    name: '小明',
    birthday: 1990,
    age: getAge
};

bart.age(); // 25, 正常结果
getAge(); // NaN

apply关键字

要指定函数的this指向哪个对象，可以用函数本身的apply方法，它接收两个参数，第一个参数就是需要绑定的this变量，第二个参数是Array，表示函数本身的参数。

function getAge(){
    var a= new Date().getFullYear();
    return a-this.birthday;
}

var bart={
  name:'bart',
  birthday:1993,
  age:getAge
};

getAge();//直接这样调用输出NaN

//使用'函数名'.apply('要定向的对象','传入的参数');
//当函数没有参数的时候下面三种方法都正确
getAge.apply(bart,[]);
getAge.apply(bart,null);
getAge.apply(bart);

getAge.call(bart,[]);

另一个与apply()类似的方法是call()，唯一区别是：
- apply()把参数打包成Array再传入；
- call()把参数按顺序传入。

高阶函数

高阶函数英文叫Higher-order function.
JavaScript的函数其实都指向某个变量。既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

实例：

function fun(i){
    return i*2;
}
function fun2(x,y,f){
    var a = f(x)+f(y);
    alert(a);
}
fun2(1,3,fun);//输出8

类似于C语言中的函数指针，但这里面包装好了比较简单明了。

map函数

map() 方法返回一个由原数组中的每个元素调用一个指定方法后的返回值组成的新数组。

function double(i){
    return 2*i;
}
var arr=[1,2,3];
arr.map(double);//[2,4,6]

reduce函数

Arr.reduce(fun),fun函数必须接受数组的连续两个值作为参数，函数的返回值作为新数组的第一个值，fun函数再次调用新的数组的连续两个值。

function add(x,y){
    return x+y;
}
var arr=[1,2,3];
arr.reduce(add);//6，相当于add(add(1,2),3)

filter

和map()类似，Array的filter()也接收一个函数。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是true还是false决定保留还是丢弃该元素。

例如：

var arr=[1,2,3,4,5,6,7,8,9];
arr.filter(function(x){
    if(x%2===0)//判断是否为偶数
    return true;
    else 
    return false;
});
//最后arr值劝全部为偶数

sort排序

js的sort()函数默认是把所有的内容转换成字符串后再按照ASCII吗大小进行排序，所以使用的时候应该利用告诫函数的性质重写；
例如;

var arr = [10, 20, 1, 2];
arr.sort(function (x, y) {
    if (x < y) {
        return -1;
    }
    if (x > y) {
        return 1;
    }
    return 0;
}); // [1, 2, 10, 20]