js相关学习

js相关的基础知识：

• === 为绝对相等，即数据类型与值都必须相等。
• JavaScript 拥有动态类型。这意味着相同的变量可用作不同的类型

var x;               // x 为 undefined
var x = 5;           // 现在 x 为数字
var x = "John";      // 现在 x 为字符串

• js对象的key不需要引号，

var person={firstname:"John", lastname:"Doe", id:5566};
// 对象属性有两种寻址方式
name=person.lastname;
name=person["lastname"];

• 如果把数字与字符串相加，结果将成为字符串！
• constructor 属性返回所有 JavaScript 变量的构造函数。

"John".constructor                 // 返回函数 String()  { [native code] }
(3.14).constructor                 // 返回函数 Number()  { [native code] }
false.constructor                  // 返回函数 Boolean() { [native code] }
[1,2,3,4].constructor              // 返回函数 Array()   { [native code] }
{name:'John', age:34}.constructor  // 返回函数 Object()  { [native code] }
new Date().constructor             // 返回函数 Date()    { [native code] }
function () {}.constructor         // 返回函数 Function(){ [native code] }

你可以使用 constructor 属性来查看对象是否为数组 (包含字符串 "Array"):

function isArray(myArray) {
// toString()转为字符串，通过indexOf找到array所在的索引值，进行判断
    return myArray.constructor.toString().indexOf("Array") > -1;
}

• 将字符串转换为数字
  全局方法 Number() 可以将字符串转换为数字。
  字符串包含数字(如 "3.14") 转换为数字 (如 3.14).
  空字符串转换为 0。
  其他的字符串会转换为 NaN (不是个数字)。

Number("3.14")    // 返回 3.14
Number(" ")       // 返回 0
Number("")        // 返回 0
Number("99 88")   // 返回 NaN

• 一元运算符 +
  Operator + 可用于将变量转换为数字：

var y = "5";      // y 是一个字符串
var x = + y;      // x 是一个数字

var y = "John";   // y 是一个字符串
var x = + y;      // x 是一个数字 (NaN)

var y = "John";  // y 是一个字符串
var x = y + 5; // x 是一个字符串 (John5)

• 数值转换：
  字符串“0” 转bool是true。

• Undefined 不是 Null

在 JavaScript 中, null 用于对象, undefined 用于变量，属性和方法。
对象只有被定义才有可能为 null，否则为 undefined。
如果我们想测试对象是否存在，在对象还没定义时将会抛出一个错误。
错误的使用方式：

if (myObj !== null && typeof myObj !== "undefined") 

正确的方式是我们需要先使用 typeof 来检测对象是否已定义：

if (typeof myObj !== "undefined" && myObj !== null) 

• 使用 var 关键字声明的变量不具备块级作用域的特性，它在 {} 外依然能被访问到。

var i = 5;
for (var i = 0; i < 10; i++) {
    // 一些代码...
}
// 这里输出 i 为 10

let i = 5;
for (let i = 0; i < 10; i++) {
    // 一些代码...
}
// 这里输出 i 为 5

• const 的本质: const 定义的变量并非常量，并非不可变，它定义了一个常量引用一个值。使用 const 定义的对象或者数组，其实是可变的。
  不能修改常量const修饰的对象，即对它赋值，但是可以对对象的属性进行修改
  下面的代码并不会报错：

// 创建常量对象
const car = {type:"Fiat", model:"500", color:"white"};
 
// 修改属性:
car.color = "red";
 
// 添加属性
car.owner = "Johnson";



const car = {type:"Fiat", model:"500", color:"white"};
car = {type:"Volvo", model:"EX60", color:"red"};    // 错误

常量的使用

使用var关键字声明的全局作用域变量属于window对象。
使用let关键字声明的全局作用域变量不属于window对象。
使用var关键字声明的变量在任何地方都可以修改。
在相同的作用域或块级作用域中，不能使用let关键字来重置var关键字声明的变量。
在相同的作用域或块级作用域中，不能使用let关键字来重置let关键字声明的变量。
let关键字在不同作用域，或不用块级作用域中是可以重新声明赋值的。
在相同的作用域或块级作用域中，不能使用const关键字来重置var和let关键字声明的变量。
在相同的作用域或块级作用域中，不能使用const关键字来重置const关键字声明的变量
const 关键字在不同作用域，或不同块级作用域中是可以重新声明赋值的:
var关键字定义的变量可以先使用后声明。
let关键字定义的变量需要先声明再使用。
const关键字定义的常量，声明时必须进行初始化，且初始化后不可再修改。

• JSON.parse() 用于将一个 JSON 字符串转换为 JavaScript 对象。
  JSON.stringify() 用于将 JavaScript 值转换为 JSON 字符串。
  更多 JSON 信息，你可以阅读我们的 JSON 教程。

• Promise 的使用:
  resolve 和 reject 都是函数，其中调用 resolve 代表一切正常，reject 是出现异常时所调用的：

new Promise(function (resolve, reject) {
    var a = 0;
    var b = 1;
    if (b == 0) reject("Diveide zero");
    else resolve(a / b);
}).then(function (value) {
    console.log("a / b = " + value);
}).catch(function (err) {
    console.log(err);
}).finally(function () {
    console.log("End");
});

Promise 类有 .then() .catch() 和 .finally() 三个方法，这三个方法的参数都是一个函数，.then() 可以将参数中的函数添加到当前 Promise 的正常执行序列，.catch() 则是设定 Promise 的异常处理序列，.finally() 是在 Promise 执行的最后一定会执行的序列。 .then() 传入的函数会按顺序依次执行，有任何异常都会直接跳到 catch 序列：

new Promise(function (resolve, reject) {
    console.log(1111);
    resolve(2222);
}).then(function (value) {
    console.log(value);
    return 3333;
}).then(function (value) {
    console.log(value);
    throw "An error";
}).catch(function (err) {
    console.log(err);
});

// 执行结果：
1111
2222
3333
An error

异步函数 async function 中可以使用 await 指令，await 指令后必须跟着一个 Promise，异步函数会在这个 Promise 运行中暂停，直到其运行结束再继续运行。

async function asyncFunc() {
    let value = await new Promise(
        function (resolve, reject) {
            resolve("Return value");
        }
    );
    console.log(value);
}
asyncFunc();

• 自调用函数：

//  匿名自我调用的函数 (没有函数名)。
(function () {
    var x = "Hello!!";      // 我将调用自己
})();

• 箭头函数：

// ES5
var x = function(x, y) {
     return x * y;
}
 
// ES6
const x = (x, y) => x * y;

• 如果y已经定义 ， y || 返回 y, 因为 y 是 true, 否则返回 0, 因为 undefined 为 false。

function myFunction(x, y) {
    y = y || 0;
}

• 一个元素添加多个事件（addEventListener）

element.addEventListener(event, function, useCapture);
第一个参数是事件的类型 (如 "click" 或 "mousedown").

第二个参数是事件触发后调用的函数。

第三个参数是个布尔值用于描述事件是冒泡还是捕获。该参数是可选的，默认值为 false, 即冒泡传递，当值为 true 时, 事件使用捕获传递。

冒泡：由内到外；
捕获：由外到内。

对应移除方法removeEventListener。

• 给已存在的对象添加属性，直接添加（Person.nationality = "English";）这样是undefined，必须通过prototype 来添加，即
  Person.prototype.nationality = "English";

TODO：

• JavaScript 标签：https://www.runoob.com/js/js-break.html

cars=["BMW","Volvo","Saab","Ford"];
list: 
{
    document.write(cars[0] + "<br>"); 
    document.write(cars[1] + "<br>"); 
    document.write(cars[2] + "<br>"); 
    break list;
    document.write(cars[3] + "<br>"); 
    document.write(cars[4] + "<br>"); 
    document.write(cars[5] + "<br>"); 
}

• 在 JavaScript 中函数也是对象，对象则有方法，apply 和 call 就是函数对象的方法。这两个方法异常强大，他们允许切换函数执行的上下文环境（context），即 this 绑定的对象。
  要注意apply 和 call 的用法
  在下面实例中，当我们使用 person2 作为参数来调用 person1.fullName 方法时, this 将指向 person2, 即便它是 person1 的方法：

var person1 = {
  fullName: function() {
    return this.firstName + " " + this.lastName;
  }
}
var person2 = {
  firstName:"John",
  lastName: "Doe",
}
person1.fullName.call(person2);  // 返回 "John Doe"

• js闭包
• try catch语法

try
{
有可能出现错误的代码写在这里
}
catch
{
出错后的处理
}