//js

'use strict'

var a;

var $b=1;

var s_007='007';

var Answer=true;

var t=null;

var arr=[1,2,3.14,'hhh',null,true]

//'你好'+name+‘了’===`你好，${name},了`

var s=‘hello, world!’;

s.length;//13

s[0];//'h';

s[13];//undefined

var s='hello';

alert(s);

s.toUpperCase();//'HELLO'

var arr=[1,2,3.14,'hhh',null,true];

arr.length;

var arr=['a','b','c'];

arr[1]=99;

var arr=[1,2,3];

arr[5]='x';

arr;//arr变为[1,2,3,undefined,undefined,'x']

arr.indexOf(1);

var arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];

arr.slice(0, 3); // 从索引0开始，到索引3结束，但不包括索引3: ['A', 'B', 'C']

arr.slice(3); // 从索引3开始到结束: ['D', 'E', 'F', 'G']

var aCopy=arr.slice();

var arr=[1,2];

arr.push('a','b');

arr.pop();//arr=[1,2,'a'];

arr.pop(); // 空数组继续pop不会报错，而是返回undefined

arr.unshift('a','b');

arr.shift();//如果要往Array的头部添加若干元素，使用unshift()方法，shift()方法则把Array的第一个元素删掉

arr.sort();//排序

arr.reverse();

//splice()方法是修改Array的“万能方法”，它可以从指定的索引开始删除若干元素，然后再从该位置添加若干元素：

var arr = ['Microsoft', 'Apple', 'Yahoo', 'AOL', 'Excite', 'Oracle'];

// 从索引2开始删除3个元素,然后再添加两个元素:

arr.splice(2, 3, 'Google', 'Facebook'); // 返回删除的元素 ['Yahoo', 'AOL', 'Excite']

arr; // ['Microsoft', 'Apple', 'Google', 'Facebook', 'Oracle']

// 只删除,不添加:

arr.splice(2, 2); // ['Google', 'Facebook']

arr; // ['Microsoft', 'Apple', 'Oracle']

// 只添加,不删除:

arr.splice(2, 0, 'Google', 'Facebook'); // 返回[],因为没有删除任何元素

arr; // ['Microsoft', 'Apple', 'Google', 'Facebook', 'Oracle']

var arr = ['A', 'B', 'C'];

var added = arr.concat([1, 2, 3]);

added; // ['A', 'B', 'C', 1, 2, 3]

arr; // ['A', 'B', 'C']

var arr = ['A', 'B', 'C'];

arr.concat(1, 2, [3, 4]); // ['A', 'B', 'C', 1, 2, 3, 4]

var arr = ['A', 'B', 'C', 1, 2, 3];

arr.join('-'); // 'A-B-C-1-2-3'

//对象

var xiaoming={

name:'xiaoming',

birth:1990,

school:'no.1 middle school',

height:1.70,

weight:65,

score:null,

'm-school':'mmmmschool'

};

xiaoming.name;//'xiaoming'

xiaoming['m-school'];//

'name' in xiaoming;

xiaoming.hasOwnProperty('name'); // true

xiaoming.hasOwnProperty('toString'); // false

var s='123';

if(s.length){

//JavaScript把null、undefined、0、NaN和空字符串''视为false

//其他值一概视为true，因此上述代码条件判断的结果是true。

}

//循环

var x=0;

var i;

for(i=1;i<=10000;i++){

x=x+i;

}

x;

var x = 0;

for (;;) { //3个条件均可省略 将无限循环下去

if (x > 100) {

break; // 通过if判断来退出循环

}

x ++;

}

//for ... in

var o = {

name: 'Jack',

age: 20,

city: 'Beijing'

};

for (var key in o) {

console.log(key); // 'name', 'age', 'city'

}

var o = {

name: 'Jack',

age: 20,

city: 'Beijing'

};

for (var key in o) {

console.log(o[key]); // 'Jack', '20', 'Beijing'

}

//要过滤掉对象继承的属性，用hasOwnProperty()来实现

var o = {

name: 'Jack',

age: 20,

city: 'Beijing'

};

for (var key in o) {

if (o.hasOwnProperty(key)) {

console.log(key); // 'name', 'age', 'city'

}

}

var x = 0;

var n = 99;

while (n > 0) {

x = x + n;

n = n - 2;

}

x; // 2500

var n = 0;

do {

n = n + 1;

} while (n < 100);

n; // 100

//实例

'use strict';

var arr = ['Bart', 'Lisa', 'Adam'];

for(i=(arr.length-1);i>=0;i--){

alert('hello,'+arr[i]);

}

//MAP

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

m.get('Michael'); // 95

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

//Set

Set和Map类似，也是一组key的集合，但不存储value。

由于key不能重复，所以，在Set中，没有重复的key。

要创建一个Set，需要提供一个Array作为输入，或者直接创建一个空Set：

var s1 = new Set(); // 空Set

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

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

var s = new Set([1, 2, 3, 3, '3']);

s; // Set {1, 2, 3, "3"}

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

s.add(4);

s; // Set {1, 2, 3, 4}

s.add(4);

s; // 仍然是 Set {1, 2, 3, 4}

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

var s = new Set([1, 2, 3]);

s; // Set {1, 2, 3}

s.delete(3);

s; // Set {1, 2}

//用for ... of循环遍历集合，用法如下：

var a = ['A', 'B', 'C'];

var s = new Set(['A', 'B', 'C']);//var s=new Set(a);

var m = new Map([[1, 'x'], [2, 'y'], [3, 'z']]);

for (var x of a) { // 遍历Array

console.log(x);

}

for (var x of s) { // 遍历Set

console.log(x);

}

for (var x of m) { // 遍历Map

console.log(x[0] + '=' + x[1]);

}

然而，更好的方式是直接使用iterable内置的forEach方法，它接收一个函数，每次迭代就自动回调该函数

'use strict';

var a = ['A', 'B', 'C'];

a.forEach(function (element, index, array) {

// element: 指向当前元素的值

// index: 指向当前索引

// array: 指向Array对象本身

console.log(element + ', index = ' + index);

});

/上述也可写为

a.forEach(function(e,i,a){

console.log(i+"->"+e);

})

//或

a.forEach((e,i)=>{

console.log(i+"->"+e+"|"+a);

})

0->A|A,B,C

1->B|A,B,C

2->C|A,B,C

这说明JavaScript实际上只有一个全局作用域。任何变量（函数也视为变量），如果没有在当前函数作用域中找到，就会继续往上查找，最后如果在全局作用域中也没有找到，则报ReferenceError错误。

减少冲突的一个方法是把自己的所有变量和函数全部绑定到一个全局变量中。例如

// 唯一的全局变量MYAPP:

var MYAPP = {};

// 其他变量:

MYAPP.name = 'myapp';

MYAPP.version = 1.0;

// 其他函数:

MYAPP.foo = function () {

return 'foo';

};

由于JavaScript的变量作用域实际上是函数内部，我们在for循环等语句块中是无法定义具有局部作用域的变量的：

'use strict';

function foo() {

for (var i=0; i<100; i++) {

//

}

i += 100; // 仍然可以引用变量i

}

为了解决块级作用域，ES6引入了新的关键字let，用let替代var可以申明一个块级作用域的变量：

'use strict';

function foo() {

var sum = 0;

for (let i=0; i<100; i++) {

sum += i;

}

// SyntaxError:

i += 1;

}

由于var和let申明的是变量，如果要申明一个常量，在ES6之前是不行的，我们通常用全部大写的变量来表示“这是一个常量，不要修改它的值”：

var PI = 3.14;

ES6标准引入了新的关键字const来定义常量，const与let都具有块级作用域：

'use strict';

const PI = 3.14;

PI = 3; // 某些浏览器不报错，但是无效果！

PI; // 3.14

从ES6开始，JavaScript引入了解构赋值，可以同时对一组变量进行赋值。