JS基础知识（二）

一、对象

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

var xiaoming = {
    name: '小明',
    birth: 1990,
    school: 'No.1 Middle School',
    height: 1.70,
    weight: 65,
    score: null
};

最后一个键值对不需要在末尾加“，”，在低版本的浏览器中，如果添加了会报错。

2、对象访问属性是通过“.”操作符完成的，但前提是属性必须是一个有效的变量名。如果属性名包含特殊的字符，就必须用 ‘ ’ 括起来：

var xiaoming = {
    name: '小明',
    ‘mid-school’: 'No.1 Middle School'
};

xiaoming的属性’mid-school’不是一个有效变量名，同时也不能通过’.’来访问，必须使用[‘mid-school’]来访问。

3、实际上javascript的属性均为字符串，不过属性对应的值可以是任何数据类型

4、javascript规定，访问对象不存在的属性不会报错，而是返回undefined：

var xiaoming = {
    name: '小明'
};
xiaoming.age; // undefined

5、由于javascript的对象是动态类型，所以可以自由的给对象添加或者删除属性：

var xiaoming = {
    name: '小明'
};
xiaoming.age; // undefined
xiaoming.age = 18; // 新增一个age属性
xiaoming.age; // 18
delete xiaoming.age; // 删除age属性
xiaoming.age; // undefined
delete xiaoming['name']; // 删除name属性
xiaoming.name; // undefined
delete xiaoming.school; //删除一个不存在的school属性也不会报错

6、如果要检测对象是否包含某一属性，有两种方法

（1）in：

var xiaoming = {
    name: '小明',
    birth: 1990,
    school: 'No.1 Middle School',
    height: 1.70,
    weight: 65,
    score: null
};
'name' in xiaoming; // true
'grade' in xiaoming; // false

注意：如果’in’判断一个属性存在，这个属性不一定是当前对象的，它也可能是当前对象继承得到的

'toString' in xiaoming; // true

因为’toString’定义在object对象中，而所有的对象最终都会在原型链上指向object，所以xiaoming也拥有‘toString’属性。

（2）hasOwnProperty(): 判断一个属性是否是对象本身拥有而不是继承所得：

var xiaoming = {
    name: '小明'
};
xiaoming.hasOwnProperty('name'); // true
xiaoming.hasOwnProperty('toString'); // false

二、条件判断语句

javascript中的条件判断与其它语言基本都是一样的，这里需要注意点的就是判断条件:

在JavaScript中把null、undefined、0、NaN和空字符串’’视为false，其他值一概视为true。

三、循环语句

循环语句与其它语言也基本一致，但需要注意的有两点：

• 由于在javascript中Array也是对象，而它的每个元素的索引被视为对象的属性，因此 ‘for...in’的循环可以直接循环出数组的索引，并且数据类型是String而不是Number。
• 用 ‘do...while’循环体至少执行一次，而for和while循环则可能一次也不执行。

四、Map和Set

1、Map：

javascript中对象的键必须是字符串，但实际上Number或其他数据类型作为键也是合理的。为了解决这个问题，ES6引入了新的数据类型 ‘Map’。Map是一组键值对的结构，具有极快的查找速度。

（1）二维数组的形式初始化Map：

var m = new Map([['Michael', 95], ['Bob', 75], ['Tracy', 85]]);
m.get('Michael'); // 95

（2）初始化空Map：

var m = new Map(); // 空Map
m.set('Adam', 67); // 添加新的key-value
m.set('Bob', 59);
m.has('Adam'); // 是否存在key 'Adam': true
m.get('Adam'); // 67
m.delete('Adam'); // 删除key 'Adam'
m.get('Adam'); // undefined

（3）Map的键不能重复，所以后赋值的键会覆盖前面相同的键对应的值：

var m = new Map();
m.set('Adam', 67);
m.set('Adam', 88);
m.get('Adam'); // 88

2、Set：

Set和Map类似，也是一组key的集合，但是不存储value，同样的，Set中的key也不能重复。

（1）初始化Set，可以提供一个数组作为输入或者创建一个空Set：

var s1 = new Set(); // 空Set
var s2 = new Set([1, 2, 3]); // 含1, 2, 3

（2）重复元素在Set中自动被过滤：

var s = new Set([1, 2, 3, 3, '3']);
s; // Set {1, 2, 3, "3"} 注意数字3和字符串“3”是不同元素

（3）通过add(key)方法添加元素到Set中，可以重复添加，但不会有效果：

var s = new Set([1, 2, 3]);
s.add(4)
s   //{1, 2, 3, 4}
s.add(4)
s   //{1, 2, 3, 4}

(4)通过delete(key)方法删除元素：

var s = new Set([1, 2, 3]);
s.delete(2)
s   //{1,3}

注意：Map和Set是ES6新增的数据类型，请根据浏览器的支持情况决定是否使用

五、iterable

为了统一集合类型，ES6标准引入了新的iterable类型，Array、Map和Set都是iterable类型。

1、具有iterable类型的集合可以通过 ‘for...of’循环来遍历：

var a = ['A', 'B', 'C'];
var s = new Set(['A', 'B', 'C']);
var m = new Map([[1, 'x'], [2, 'y'], [3, 'z']]);
for (var x of a) { // 遍历Array
    alert(x);       //A B C
}
for (var x of s) { // 遍历Set
    alert(x);   //A B C
}
for (var x of m) { // 遍历Map
    alert(x[0] + '=' + x[1]);   //1=x 2=y 3=z
}

Q： ‘for...of’和 ‘for...in’循环有什么区别？
A: ‘for...in’循环遍历的是对象的属性名称，对于数组，他的每个元素的索引被视为属性，我们通过给数组添加额外属性再遍历的结果发现，遍历输出了新添加的属性却没有输入length属性：
var a = ['A', 'B', 'C'];
a.name = 'Hello';
for (var x in a) {
alert(x); // '0', '1', '2', 'name'
}
而 ‘for...of’则输出的是数组本身的元素：
var a = ['A', 'B', 'C'];
a.name = 'Hello';
for (var x of a) {
alert(x); // 'A', 'B', 'C'
}
var a = ['A', 'B', 'C'];
a.name = 'Hello';
a[3] = 'D';
alert(a.length); //4
for (var x in a) {
alert(x); // 0,1,2,3,name
}

2、forEach()：

ES5.1引入，它接收一个函数，每次迭代就自动回调该函数：

（1）Array：

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

（2）Set：

var s = new Set(['A', 'B', 'C']);
s.forEach(function (element, sameElement, set) {
        // element: 指向当前元素的值
     //sameElement:Set没有索引，所以依然指向当前元素本身
     // set: 指向set对象本身
    alert(element);
});

（3）Map：

var m = new Map([[1, 'x'], [2, 'y'], [3, 'z']]);
m.forEach(function (value, key, map) {
     //value:值
    //key:键
     // map: 指向map对象本身
    alert(value);
});

注意：
(1)参数名称可不一致，例如elment修改为el等；
(2)函数调用时如果对某个函数不感兴趣，可以省略，但是只能省略有用参数后面的参数：
var a = ['A', 'B', 'C'];
a.forEach(function (element) {
alert(element);
});
a.forEach(function (element,index) {
alert(index);
});