JS的重新回顾——第二篇

JS循环

循环可以将代码块执行指定的次数。
不同的循环：
JavaScript 支持不同类型的循环：

• for - 循环代码块一定的次数
• for/in - 循环遍历对象的属性
• while - 当指定的条件为 true 时循环指定的代码块
• do/while - 同样当指定的条件为 true 时循环指定的代码块

for循环：
语句：

for (语句 1; 语句 2; 语句 3)
{
    被执行的代码块
}
for (var i=0; i<5; i++)
{
      x=x + i;
}

从上面的例子中，您可以看到：
1、在循环开始之前设置变量 (var i=0)。
2、定义循环运行的条件（i 必须小于 5）。
3、在每次代码块已被执行后增加一个值 (i++)。

for-in循环
for/in 语句循环遍历对象的属性：

var person={fname:"John",lname:"Doe",age:25}; 
var txt = '';
for (x in person)  // x 为属性名
{
    txt=txt + person[x];
}
console.log(txt);//JohnDoe25

因为对象有三条属性，即循环会执行三次。

while循环
while 循环会在指定条件为真时循环执行代码块。

while (条件)
{
    需要执行的代码
}
var x="",i=0;
while (i<5)
{
    x=x + "The number is " + i + "<br>";
    i++;
}

注：如果您忘记增加条件中所用变量的值，该循环永远不会结束。这可能导致浏览器崩溃。

do/while 循环
do/while 循环是 while 循环的变体。该循环会在检查条件是否为真之前执行一次代码块，然后如果条件为真的话，就会重复这个循环。

do
{
    需要执行的代码
}
while (条件);

do
{
    x=x + "The number is " + i + "<br>";
    i++;
}
while (i<5);

注：别忘记增加条件中所用变量的值，否则循环永远不会结束！

Break和Continue关键字

break 语句可用于跳出循环。
break 语句跳出循环后，会继续执行该循环之后的代码（如果有的话）

continue 语句中断循环中的迭代，如果出现了指定的条件，然后继续循环中的下一个迭代。（跳过当前循环，进入下一次循环）

typeof操作符
用来判断当前数据是什么类型的。
请注意：

• NaN 的数据类型是 number
• 数组(Array)的数据类型是 object
• 日期(Date)的数据类型为 object
• null 的数据类型是 object
• 未定义变量的数据类型为 undefined

constructor 属性
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] }

JS正则表达式

什么是正则表达式？
正则表达式是由一个字符序列形成的搜索模式。
当你在文本中搜索数据时，你可以用搜索模式来描述你要查询的内容。
正则表达式可以是一个简单的字符，或一个更复杂的模式。
正则表达式可用于所有文本搜索和文本替换的操作。

正则修饰符
修饰符 可以在全局搜索中不区分大小写

JS错误

try 语句测试代码块的错误。
catch 语句处理错误。
throw 语句创建自定义错误。
finally 语句在 try 和 catch 语句之后，无论是否有触发异常，该语句都会执行。

try {
    ...    //异常的抛出
} catch(e) {
    ...    //异常的捕获与处理
} finally {
    ...    //结束处理
}

JS变量提升

JavaScript 中，函数及变量的声明都将被提升到函数的最顶部。
JavaScript 中，变量可以在使用后声明，也就是变量可以先使用再声明。

var x; // 声明 x
x = 5; // 变量 x 设置为 5

elem = document.getElementById("demo"); // 查找元素 
elem.innerHTML = x;                     // 在元素中显示 x

声明变量会默认提升到代码最前，赋值却不会。使用ES
6的let或者const声明则不会出现此问题。

JS this关键字

面向对象语言中 this 表示当前对象的一个引用。
但在 JavaScript 中 this 不是固定不变的，它会随着执行环境的改变而改变。

• 在方法中，this 表示该方法所属的对象。
• 如果单独使用，this 表示全局对象。
• 在函数中，this 表示全局对象。
• 在函数中，在严格模式下，this 是未定义的(undefined)。
• 在事件中，this 表示接收事件的元素。
• 类似 call() 、bind()和 apply() 方法可以将 this 引用到任何对象。

var person = {
  firstName: "John",
  lastName : "Doe",
  id       : 5566,
  fullName : function() {
    return this.firstName + " " + this.lastName;
  }
};

this指向person对象。

显示函数绑定
在 JavaScript 中函数也是对象，对象则有方法，apply 和 call 就是函数对象的方法。这两个方法异常强大，他们允许切换函数执行的上下文环境（context），即 this 绑定的对象。

1. 全局环境作用域: this在全局环境始终指向window
2. 函数环境 作用域： 函数由谁调用， this就指向谁
3. 对象中的方法函数调用: 指向 该方法所属的对象
4. 在构造函数中: this始终指向新对象
5. 通过事件绑定的方法: this 指向 绑定事件的对象
6. 定时器函数: 因为是异步操作， this 指向 window
7. 自执行函数(匿名函数): 指向全局变量window
8. 箭头函数中的this始终指向父级对象

JS let和const

ES6新增的两个关键字：let 和 const。

let 声明的变量只在 let 命令所在的代码块内有效。
const 声明一个只读的常量，一旦声明，常量的值就不能改变。

作用域
let定义的变量只在let命令所在的代码块内有效。因此产生块级作用域。

{ 
    let x = 2;
}
// 这里不能使用 x 变量

{ 
    var x = 2; 
}
// 这里可以使用 x 变量

重新定义变量
使用 var 关键字重新声明变量可能会带来问题。
在块中重新声明变量也会重新声明块外的变量：

var x = 10;
// 这里输出 x 为 10
{ 
    var x = 2;
    // 这里输出 x 为 2
}
// 这里输出 x 为 2

循环作用域

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

使用了 var 关键字，它声明的变量是全局的，包括循环体内与循环体外。

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

使用 let 关键字， 它声明的变量作用域只在循环体内，循环体外的变量不受影响。

局部变量
在函数体内使用 var 和 let 关键字声明的变量有点类似。
它们的作用域都是 局部的:

// 使用 var
function myFunction() {
    var carName = "Volvo";   // 局部作用域
}

// 使用 let
function myFunction() {
    let carName = "Volvo";   //  局部作用域
}

全局变量
在函数体外或代码块外使用 var 和 let 关键字声明的变量也有点类似。
它们的作用域都是 全局的:

// 使用 var
var x = 2;       // 全局作用域

// 使用 let
let x = 2;       // 全局作用域

var carName = "Volvo";
// 可以使用 window.carName 访问变量
let carName = "Volvo";
// 不能使用 window.carName 访问变量

使用 var 关键字声明的全局作用域变量属于 window 对象；
使用 let 关键字声明的全局作用域变量不属于 window 对象。

使用 var 关键字声明的变量在任何地方都可以修改；
在相同的作用域或块级作用域中，不能使用 let 关键字来重置 var 关键字声明的变量。

const关键字
const 用于声明一个或多个常量，声明时必须进行初始化，且初始化后值不可再修改。