运行JavaScript有多种方式，可以直接在浏览器的控制台编写运行；
也可以编写一个独立的js文件，然后在Html文件中引入；
（上面两种方法由浏览器解释执行，是以前唯一的方式）
也可以用编辑软件如Webstrom或VSCode编写独立的js文件，由安装好的Node.js解释执行运行（node-v10.11.0-64位下载）。
<script> 与 </script> 标签之间。<body> 和 <head> 部分中。我们在 Chrome浏览器中可以通过按下 F12 按钮或者右击页面，选择"检查"来开启开发者工具。
> 符号后输入我们要执行的代码：
我们也可以在 Chrome 浏览器中创建一个脚本来执行，在开发者工具中点击 Sources 面板，选择 Snippets 选项卡，在导航器中右击鼠标，然后选择 Create new snippet 来新建一个脚本文件：
点击 Create new snippet 后，会自动创建一个文件，在右侧窗口输入以下代码，保存后右击文件名，选择 "Run" 执行代码：
1. 大小写敏感
2. 标识符
标识符是指变量、函数、属性的名字，或者函数的参数。
标识符的第一个字符只能是字母、下划线（ _ ）或美元符号（ $ ）之一；其他字符可以是字母、下划线、美元符号或数字。
按照惯例，ECMAScript（European Computer Manufacturers Association） 标识符采用驼峰大小写格式，也即第一个字母小写，剩下的每个单词的首字母大写，如getNameById。
ECMAScript：JavaScript 语言的标准，被称为ECMAScript标准
3. 注释
单行注释以 // 开头；
多行注释以 /* 开始，以 */ 结尾。
4. 语句
语句后的分号建议添加，但不必须。
5. 关键字/保留字
break do instanceof typeof case else new var catch finally return void continue for switch while debugger function this with default if throw delete in try
6. 输出
JavaScript 可以通过不同的方式来输出数据：
console.log() 写入到浏览器的控制台。window.alert() 弹出警告框。document.write() 方法将内容写到 HTML 文档中。innerHTML 写入到 HTML 元素。7. 变量
ECMAScript 的变量是松散类型的（可以用来保存任何类型的数据，如： String、Number、Object等的数据）
用 var 操作符定义的变量是局部变量；不加var即为全局变量（慎用）
例如：
function test(){
var message = "hi"; // 局部变量，去掉var即为全局变量
}
test();
alert(message); // 错误！
8. 操作符
++ --
&& || ！
除下列值为假外其余皆为真：
false、null、undefined、''、0、NaN
+ - * / %
注意以下代码：
var result = 5 + '5'; // 一个数值和一个字符串相加
console.log(result); // '55'
//============================================
var num1 = 5;
var num2 = 10;
var message = "The sum of 5 and 10 is " + num1 + num2;// (num1 + num2)，还可使用模板字符串``
console.log(message); // "The sum of 5 and 10 is 510"
可见：数字与字符串相加，返回字符串。
<> <= >= == === != !=====称为全等（值和类型）注意以下代码：
var x = 5;
console.log(x == 5); //true
console.log(x == '5'); //true
console.log(x === 5); //true
console.log(x === '5'); //false
? :
= += -= *= /= %=
if do-while while for for-in for-of break continue switch
注意，请为语句块添加
{}，不要吝啬
另外，for-of、forEach能简洁的遍历集合中的元素，如下代码：
var colors = ['red', 'green', 'blue', 'brown']; //colors是一个数组
//传统遍历（基本不用了）
for(var i=0;i<colors.length;i++){
console.log(colors[i]);
}
//for-in，专注下标
for(var c in colors){
console.log(colors[c]);
}
//for-of，专注元素
for(var c of colors){
console.log(c);
}
//高级遍历
colors.forEach(c => console.log(c));
var other = colors.map(c => c + 'X');//map不仅遍历，还返回另一个数组
console.log(other);
函数（ function）对任何语言来说都是一个核心的概念。通过函数可以封装任意多条语句，而且可以在任何地方、任何时候调用执行。
以下是一个函数示例：
function sayHi(name, message) {
console.log('Hello ' + name + ',' + message);
}
sayHi('Gridwang', '你好。'); //结果为：Hello Gridwang,你好。
ECMAScript 中的函数在定义时不必指定是否返回值。实际上，任何函数在任何时候都可以通过 return 语句后跟要返回的值来实现返回值。请看下面的例子：
function sum(num1, num2) {
return num1 + num2;
}
var result = sum(3, 2);
console.log(result);
ECMAScript 函数不介意传递进来多少个参数，也不在乎传进来参数是什么数据类型。
也就是说，即便你定义的函数只接收两个参数，在调用这个函数时也未必一定要传递两个参数。可以传递一个、三个甚至不传递参数，而解析器永远不会有什么怨言。
之所以会这样，原因是 ECMAScript中的参数在内部是用一个数组来表示的。函数接收到的始终都是这个数组，而不关心数组中包含哪些参数（如果有参数的话）。如果这个数组中不包含任何元素，无所谓；如果包含多个元素，也没有问题。
如果在 ECMAScript中定义了两个名字相同的函数，则该名字只属于后定义的函数。
例如：
function addSomeNumber(num){
return num + 100;
}
function addSomeNumber(num) {
return num + 200;
}
console.log(addSomeNumber(100)); //结果为300
在 JavaScript中，几乎所有的事物都是对象。
创建对象有如下两种方式，我们常用方式二：
//方式一new
var person = new Object();//生成空对象
person.name = 'Elon Musk';//设置对象的属性
person.age = 46;
person.job = 'SpaceX Rocket';
person.sayName = function(){ //设置对象的方法/函数，注意此处
console.log(this.name);
};
//方式二字面量
var person = {
name: 'Lary Page',
age: 47,
job: 'Software Engineer',
sayName: function(){ //注意此处
console.log(this.name);
}
};
console.log(person.job);
person.sayName();
虽然Object构造函数或对象字面量都可以用来创建单个对象，但这些方式有个明显的缺点：使用同一个接口创建很多对象，会产生大量的重复代码。
为解决这个问题，人们开始使用工厂模式的一种变体。代码如下：
function createPerson(name, age, job){
var o = new Object();
o.name = name;
o.age = age;
o.job = job;
o.sayName = function(){
console.log(this.name);
/*this 指的是“拥有” sayName 函数的createPerson对象。
this.name 的意思是this对象的name属性*/
};
return o;
}
var person1 = createPerson('Steve Jobs',56 , 'Inventor');
var person2 = createPerson('Linus Torvalds', 49, 'Software Engineer');
var person2 = createPerson('Julian Assange', 47, 'Ethical Hacker');
除了 Object 之外， Array 类是 ECMAScript 中最常用的类型。
ECMAScript 中的数组与其他多数语言中的数组有着相当大的区别。虽然 ECMAScript 数组与其他语言中的数组都是数据的有序列表，但与其他语言不同的是，ECMAScript 数组的每一项可以保存任何类型的数据。
也就是说，可以用数组的第一个位置来保存字符串，用第二位置来保存数值，用第三个位置来保存对象，以此类推。而且，ECMAScript 数组的大小是可以动态调整的，即可以随着数据的添加自动增长以容纳新增数据。
创建数组有以下两种方法，我们常用方式二：
//方式一new
var colors = new Array('red', 'blue', 'green');
//方式二字面量
var colors = ['red', 'blue', 'green']; // 创建一个包含 3 个字符串的数组
console.log(colors[1]); // blue
colors[3] = 'brown';
console.log(colors.length); // 4
var names = []; // 创建一个空数组
var hyBird = [1, 2, 'haha', {firstName: 'Yong', lastName: 'Wang'}]; //不推荐！
console.log(hyBird[3].firstName); // Yong
常用的数组方法如下：
1. 元素联合
var colors = ['red', 'green', 'blue'];
console.log(colors.join(',')); //red,green,blue
console.log(colors.join('||')); //red||green||blue
2. 堆栈方法
栈是一种 LIFO（Last-In-First-Out，后进先出）的数据结构；
而栈中项的插入（叫做推入）和移除（叫做弹出），只发生在一个位置——栈的顶部。
ECMAScript 为数组专门提供了 push() 和 pop() 方法，以便实现类似栈的行为。
pop() 方法从数组中删除最后一个元素；它返回“被弹出”的值。
push() 方法（在数组尾处）向数组添加一个新的元素；它返回新数组的长度。
var colors = []; // 创建一个数组
var count = colors.push('red', 'green'); // 末尾推入两项
console.log(count); //2
colors.push('black'); // 末尾推入另一项
console.log(colors); // [ 'red', 'green', 'black' ]
var item = colors.pop(); // 末尾弹出最后一项
console.log(item); //'black'
console.log(colors); // [ 'red', 'green' ]
3. 队列方法
FIFO（First-In-First-Out，先进先出）；由于 push() 是向数组末端添加项的方法，因此要模拟队列只需一个从数组前端取得项的方法。
实现这一操作的数组方法就是 shift() ，它能够移除数组中的第一个项并返回该项，并将所有其他元素“位移”到更低的索引，同时将数组长度减1。
var colors = new Array(); //创建一个数组
colors.push('red', 'green'); //推入两项
console.log(colors); // [ 'red', 'green' ]
count = colors.push('black'); //推入另一项
console.log(colors); // [ 'red', 'green', 'black' ]
var item = colors.shift(); // 前端弹出第一项
console.log(item); // 'red'
console.log(colors); //[ 'green', 'black' ]
ECMAScript 还为数组提供了一个 unshift() 方法，它能在数组前端添加任意个项并返回新数组的长度。
var colors = new Array(); //创建一个数组
var count = colors.unshift('red', 'green'); // 推入两项
console.log(colors); // [ 'red', 'green' ]
count = colors.unshift('black'); // 推入另一项
console.log(colors); // [ 'black', 'red', 'green' ]
var item = colors.pop(); // 取得最后一项
console.log(item); // 'green'
console.log(colors); // [ 'black', 'red' ]
总结：
push、pop操作在数组末，而unshift、shift操作在数组头；
push、unshift压入，而pop、shift弹出。
4. 反转数组项
var values = [1, 2, 3, 4, 5];
values.reverse();
console.log(values); //5,4,3,2,1
5. 连接方法
concat() 方法通过合并（连接）现有数组来创建一个新数组；var colors1 = ['red', 'green', 'blue'];
var colors2 = ['yellow', 'black'];
console.log(colors1.concat(colors2)); // [ 'red', 'green', 'blue', 'yellow', 'black' ]
console.log(colors2.concat(colors1)); // [ 'yellow', 'black', 'red', 'green', 'blue' ]
console.log(colors2.concat('brown')); // [ 'yellow', 'black', 'brown' ]
console.log(colors2); //[ 'yellow', 'black' ]
6. 分片方法
slice() 方法用数组的某个片段切出新数组；var colors1 = ['red', 'green', 'blue', 'yellow', 'purple'];
var colors2 = colors1.slice(1);
var colors3 = colors1.slice(2, 4);
var colors4 = colors1.slice(2, 2);//结果是什么？
console.log(colors1); //[ 'red', 'green', 'blue', 'yellow', 'purple' ]
console.log(colors2); // [ 'green', 'blue', 'yellow', 'purple' ]
console.log(colors3); // [ 'blue', 'yellow' ]
console.log(colors4); // []
7. 拼接数组
splice() 方法可用于向数组添加新项；它返回一个包含已删除项的数组；它能直接更改原始数组。
它可对数组如下3种操作：
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); // yellow，返回的数组中只包含一项
链式语法已变得非常流行。基本上，你只需要让每个函数返回 this代表包含该函数的对象，这样其他函数就可以立即被调用。
例如：
//链式语法
var bird = {//定义对象字面量
catapult: function() {
console.log( 'Yippeeeeee!' );
return this;//返回bird对象自身
},
destroy: function() {
console.log( "That'll teach you... you dirty pig!" );
return this;
}
};
bird.catapult().destroy();
结果为：
闭包（Closure）实现局部（私有）；全局变量活得和应用程序（窗口、网页）一样久；
局部变量活得不长。它们在函数调用时创建，在函数完成后被删除。
当在一个函数内定义另外一个函数就会产生闭包，如下代码：
function greeting(name) {
var text = 'Hello ' + name; // local variable
// 每次调用时，产生闭包，并返回内部函数对象给调用者
return function() { console.log(text); }//注意该函数无名称，称为匿名函数
}
var sayHello = greeting('Closure');//调用greeting()返回了什么？
sayHello(); // 注意此处的使用方法。通过闭包访问到了局部变量text。
上述代码的执行结果是：Hello Closure，因为sayHello指向了greeting函数对象，sayHello()则对其进行调用，greeting函数执行完毕后将返回greeting函数内定义的匿名函数对象，而该匿名函数仍然可以访问到了定义在greeting之内的局部变量text，注意此时我们已从greeting函数中退出了（注意：只有该内部匿名函数能访问，其它任何代码都不能访问）。
在JavaScript里面，所有东西都可以看作为一个object，还是很容易理解。
JavaScript无法对函数等的参数进行类型描述，JavaScript 只提供动态类型。可以说JavaScript包容性很好，它会尽可能地执行代码，不会报错。但当要完成一个大型工程时，若最后达不到预期结果，很难知道到底是哪个地方出了错，后续我们学习TypeScript将会解决这个问题。
[1] https://www.runoob.com/js/js-obj-intro.html
[2] https://www.w3school.com.cn/js/js_array_methods.asp