JS学习三

数组

数组是指一组数据的集合，其中每个数据被称为元素，在数组中可以存放任意类型的元素

创建数组

创建数组的两种方式：

• 利用new创建数组

var arr = new Array();	// 创建了一个空的数组

• 利用数组字面量创建数组[]（最常用）
  数组字面量是[ ]

var arr = []; // 利用数组字面量创建了一个空的数组
var arr1 = [1, 2, 'pink', true]; // 数组里面的数据要用逗号分隔开

获取数组中的元素

数组的索引
索引（下标）：用来访问数组元素的序号，下标从0开始。格式：数组名[索引]

var arr1 = [1, 2, 'pink老师', true];
console.log(arr1);//(4) [1, 2, "pink老师", true]
console.log(arr1[2]);//pink老师

var arr2 = ['古力娜扎', '迪丽热巴', '佟丽娅'];
console.log(arr2[0]); //古力娜扎
console.log(arr2[1]); //迪丽热巴
console.log(arr2[2]); //佟丽娅
console.log(arr2[3]); //undefined

遍历数组

var arr = ['red', 'green', 'blue'];
for (var i = 0; i < 3; i++) {
    console.log(arr[i]);
}

数组的长度

格式：数组名.length

var arr = ['关羽', '张飞', '马超', '赵云', '黄忠', '刘备', '姜维'];
for (var i = 0; i < arr.length; i++) {
    console.log(arr[i]);
}

案例：求数组的所有数的平均值以及和

var arr = [2, 6, 1, 7, 4];
var sum = 0;
var aver;
for (var i = 0; i < arr.length; i++) {
    sum = sum + arr[i];
}
aver = sum / arr.length;
console.log(sum);
console.log(aver);

案例：求数组中的最大值

var arr = ['2', '6', '1', '77', '53', '25', '7'];
var max_num = arr[0];
for (var i = 0; i < arr.length; i++) {
    if (arr[i] > max_num) {
        max_num = arr[i];
    }
}
console.log(max_num);

案例：把数组转化为字符串

var arr = ['red', 'green', 'blue', 'pink'];
var str = '';
var sep = '*';
for (var i = 0; i < arr.length; i++) {
    str = str + arr[i] + sep;
}
console.log(str);

数组中新增元素

现阶段的方法：通过修改length长度以及索引号增加数组元素

通过修改length长度新增数组元素

length属性是可读写的

var arr = ['red', 'green', 'blue'];
console.log(arr.length); //3
arr.length = 5; //将数组的长度修改为5，里面应该有5个元素
console.log(arr); //(5) ["red", "green", "blue", empty × 2]
console.log(arr[3]); //undefined
console.log(arr[4]); //undefined

这样就实现了数组的扩容

通过修改数组索引增数组元素

在上述扩容的基础上

arr[3] = 'pink';
console.log(arr); //(5) ["red", "green", "blue", "pink", empty]
arr[4] = 'hotpink';
console.log(arr); //(5) ["red", "green", "blue", "pink", "hotpink"]

这样就实现了数组元素的追加，在上述的基础上，如果索引号是之前已经有的，那么将实现元素的替换，如下所示：

arr[0] = 'yellow';
console.log(arr);//(5) ["yellow", "green", "blue", "pink", "hotpink"]

同时注意：不要给数组名赋值，否则里面的数据全部都没有啦！

arr = '有点意思';
console.log(arr);//有点意思

案例：
将1~10存到数组中

var arr = [];
var num = 10;
for (var i = 0; i < num; i++) {
    arr[i] = i + 1;
}
console.log(arr);

案例：
筛选数组
要求将数组[2,0,6,1,77,0,52,0,25,7]中大于等于10的元素选出来，放入新的数组
方法1：

var arr = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7];
var arr1 = [];
var j = 0;
for (var i = 0; i < arr.length; i++) {
    if (arr[i] >= 10) {
        arr1[j++] = arr[i];
    }
}
console.log(arr1);//(3) [77, 52, 25]

方法2：

var arr = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7];
var arr1 = [];
//var j = 0;
for (var i = 0; i < arr.length; i++) {
    if (arr[i] >= 10) {
        arr1[arr1.length] = arr[i];
    }
}
console.log(arr1); //(3) [77, 52, 25]

数组案例

删除指定的数组元素

要求：将数组[2,0,6,1,77,0,52,0,25,7]中的0去掉，形成一个不包含0的新数组

var arr1 = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7];
var arr2 = [];
for (var i = 0; i < arr1.length; i++) {
    if (arr1[i] != 0) {
        arr2[arr2.length] = arr1[i]; //(7) [2, 6, 1, 77, 52, 25, 7]
    }
}

翻转数组

要求：将数组[‘red’,‘green’,‘blue’,‘pink’,‘purple’]的内容反过来存放，输出[‘purple’,‘pink’,‘blue’,‘green’,‘red’]

//方法1：
var arr1 = ['red', 'green', 'blue', 'pink', 'purple'];
var arr2 = [];
for (var i = 0; i < arr1.length; i++) {
    arr2[i] = arr1[arr1.length - -1 - i];
}
console.log(arr2);//(5) ["purple", "pink", "blue", "green", "red"]

//方法2：
var arr1 = ['red', 'green', 'blue', 'pink', 'purple'];
var arr2 = [];
for (var i = arr1.length - 1; i >= 0; i--) {
    arr2[arr2.length] = arr1[i];
}
console.log(arr2);//(5) ["purple", "pink", "blue", "green", "red"]

冒泡排序

原理：是一种算法，把一系列的数据按照一定的顺序按照从小到大的顺序进行排列。一次比较两个元素如果它们顺序错误就把它们交换过来。

//冒泡排序  对n（8）个数进行排序
//对于从小到大排列的情况。(3,1,7,8,3,2,9,5)
//第一趟i=0排序会把最大的数9放在最后的位置，之后就不管9了（1 3 7 3 2 8 5 ||9）比较了n-1（7）次
//第二趟i=1排序会把第二大的数8放在正确的位置，之后就不管8了 得到（1 3 3 2 7 5|| 8 9）比较了n-2（6）次
//第三趟i=2排序会把第三大的数7放在正确的位置，之后就不管7了 得到（1 3 2 3 5 ||7 8 9）比较了n-3（5）次
//第四趟i=3排序会把第四大的数5放在正确的位置，之后就不管5了 得到（1 2 3 3||5 7 8 9）比较了n-4（4）次
//第五趟i=4排序会把第五大的数3放在正确的位置，之后就不管3了 得到（1 2 3||3 5 7 8 9）比较了n-5（3）次
//第六趟i=5排序后（1 2 ||3 3 5 7 8 9）比较了n-6（2）次
//第七趟i=6排序后（1||2 3 3 5 7 8 9）比较了n-7（1）次
var a = ['3', '1', '7', '8', '3', '2', '9', '5'];
var n = a.length; //n-1就是趟数
var temp;
for (var i = 0; i < n; i++) {
    for (var j = 0; j < n - 1 - i; j++) {
        if (a[j] > a[j + 1]) {
            temp = a[j];
            a[j] = a[j + 1];
            a[j + 1] = temp;
        }
    }
}
console.log(a); //(8) ["1", "2", "3", "3", "5", "7", "8", "9"]

选择排序

第一次从下标为0的开始下标为0的这个数与后面的n-1个进行比较；找出最小或者最大的放在下标为0的这个位置；第二次从下标为1的开始比较；查询剩下的最大或者最小值；放在下标为1的位置；以此类推；直到排序完成。

//选择排序
var arr1 = ['3', '1', '7', '8', '3', '2', '9', '5'];
var temp;
for (i = 0; i < 4; i++) { //外层for循环确定交换的轮数
    for (j = i + 1; j < 5; j++) {
        if (arr1[i] > arr1[j]) {
            temp = arr1[i];
            arr1[i] = arr1[j];
            arr1[j] = temp;
        }
    }
}
console.log(arr1); //(8) ["1", "2", "3", "3", "5", "7", "8", "9"]

函数

函数就是封装了一段可以被重复执行调用的代码块
目的：就是让大量代码重复使用

函数的使用

声明函数和调用函数

//1.声明函数
//function 函数名() {
//    //函数体
//}
function sayHi() {
    console.log('hi~');
}
//2.调用函数
//函数名();
sayHi(); //hi~

函数的封装

函数的封装是把一个或者多个功能通过函数的方式封装起来，对外只提供一个简单的函数接口

案例：利用函数计算1~100之间的累加和

function getSum() {
    sum = 0;
    for (var i = 1; i <= 100; i++) {
        sum = sum + i;
    }
    console.log(sum);

}
getSum(); //5050
getSum(); //5050

函数的参数

语法格式

//1.声明
//function 函数名(形参1， 形参2，...) {
//    //函数体
//}
//2.调用
//函数名(实参1， 实参2，...);
function cook(aru) {
    console.log(aru);
}
cook('酸辣土豆丝'); //酸辣土豆丝

说明：

• 函数的参数可以有，也可以没有，个数不限

案例1

利用函数求任意两个数之和

function getSum(a, b) {
    console.log(a + b);
}
getSum(1, 5); //6
getSum(66, 66); //132

案例2

利用函数求任意两个数之间的数之和

function getSum(a, b) {
    var sum = 0;
    for (var i = a; i <= b; i++) {
        sum = sum + i;
    }
    console.log(sum);
}
getSum(1, 100); //5050
getSum(2, 6); //20

说明：形参可以是看作两个不用声明的变量

函数实参和形参不匹配问题

参数个数	说明
实参个等于形参个数	输出正确结果
实参个数多于形参个数	只取到形参的个数
实参个数小于形参个数	多的形参定义为undefined，结果为NaN

注意：在JavaScripti，形参的默认值是undefined。

function getSum(num1, num2) {
    console.log(num1 + num2);
}
//1.如果实参的个数和形参的个数一致则正常输出
getSum(1, 2); //3
//2.如果实参个数多于形参个数则会取到形参的个数
getSum(1, 2, 3); //3
//3.如果实参个数小于形参个数
//由于形参是可以看作不用声明的变量  num2是一个变量但是没有接收值，那num2就是undefined
getSum(1); //NaN

//建议：尽量让实参的个数和形参的个数相匹配

函数的返回值

语法格式

//格式
function 函数名() {
    return 需要返回的结果
}
函数名();

运用

function getResult() {
    return 666;
}
getResult();
console.log(getResult()); //666

之前程序的改进

function cook(aru) {
    return aru;
}
console.log(cook('酸辣土豆丝')); //酸辣土豆丝

function getSum(num1, num2) {
    return num1 + num2;
}
console.log(getSum(1, 2)); //3

案例

案例1：
利用函数求两个数的最大值
方法1：

function getMax(a, b) {
    if (a > b) {
        return a;
    } else {
        return b;
    }
}
console.log(getMax(1, 5)); //5
console.log(getMax(10, 5)); //10

方法2：

function getMax(a, b) {
    return a > b ? a : b;
}
console.log(getMax(1, 5)); //5
console.log(getMax(10, 5)); //10

案例2：
利用函数求数组中的最大值

function getArrMax(a) {
    var len = a.length;
    var max_value = a[0];
    for (var i = 1; i < len; i++) {
        if (a[i] > max_value) {
            max_value = a[i]
        }
    }
    return max_value;
}
var re = getArrMax([5, 2, 99, 101, 67, 77]);
console.log(re); //101

注意事项

• return除了可以返回函数值之外，还可以终止函数，即return之后的代码不会被执行
• return只能返回一个值，如果用逗号隔开多个值，以最后一个值为准

//1.终止函数
function getSum(num1, num2) {
    return num1 + num2;
    alert('我是不会被执行的哦!');
}
console.log(getSum(1, 2));

//2.return只能返回一个值
function fn(num1, num2) {
    //如果用逗号隔开多个值，以最后一个值为准 返回num2
    return num1, num2;
}
console.log(fn(1, 2)); //2

案例：
求两个数的加减乘除

function getResult(num1, num2) {
    return [num1 + num2, num1 - num2, num1 * num2, num1 / num2];
}
var re = getResult(6, 3);
console.log(re);

若函数没有return 则返回的是undefined

function fun() {
}
console.log(fun());  //undefined

break continue return的区别

• break：结束当前的循环（如for、while）
• continue：跳出本次循环，继续执行下次循环（如for、while）
• return： 不仅可以退出循环，还可以返回return语句中的值，同时还可以结束当前函数体内的代码

练习

1、写一个函数，用户输入任意两个数字的任意算数运算，弹出运算后的结果(简单计算器)；

function cal() {
    num1 = prompt('请输入第一个数');
    symbol = prompt('请输入运算符号');
    num2 = prompt('请输入第二个数');

    switch (symbol) {
        case '+':
            return num1 + num2;
        case '-':
            return num1 - num2;
        case '*':
            return num1 * num2;
        case '/':
            return num1 / num2;
    }
}
alert(cal());

2、写一个函数，用户输入三个不同的数值，返回最大值

function maxnum(num1, num2, num3) {
    if (num1 > num2) {
        if (num1 > num3) {
            return num1;
        } else {
            return num3;
        }
    } else {
        if (num2 > num3) {
            return num2;
        } else {
            return num3;
        }
    }
}

3、写一个函数，用户输入一个数，判断是否是素数(可被1和自身整除的数)

function prime(num) {
    for (var i = 2; i <= num / 2; i++) {
        if (num % i == 0) {
            return num + '不是素数';
        }
    }
    return num + '是素数';
}
alert(prime(2));//2是素数

arguments的使用

函数的实参和形参最好匹配上，否则如果实参多了可能会用不上，实参少了可能会出问题。当我们不确定有多少个参数传递的时候，可以用arguments来获取。在JavaScript中，arguments是当前函数的一个内置对象。所有的函数都内置了一个arguments对象，arguments对象中存储了传递的所有实参。

伪数组
arguments展示形式是一个伪数组，因此可以进行遍历，伪数组具有以下特点：

• 具有length属性
• 按索引方式存储数据
• 可以遍历数组
• 不具有数组的push、pop等方法

//arguments的使用
function fn() {
    console.log(arguments); //Arguments(3) [1, 2, 3, callee: ƒ, Symbol(Symbol.iterator): ƒ]arguments是一个伪数组里面存储了所有传递过来的实参
    //arguments是伪数组
    console.log(arguments.length); //有长度3
    console.log(arguments[2]); //可索引3
    //可以按数组的方式遍历arguments=[1,2,3];
    for (var i = 0; i < arguments.length; i++) {
        console.log(arguments[i]);
    }
}
fn(1, 2, 3);

利用arguments求任意两个数的最大值

function maxnum() {
    var max = arguments[0];
    for (var i = 0; i < arguments.length; i++) {
        if (arguments[i] > max) {
            max = arguments[i];
        }
    }
    return max;
}
rel = maxnum(2, 5, 66, 2, 69, 129, 333, 2, 0);
console.log(rel);

函数的案例

案例1

利用函数封装的方法翻转任意一个数组

//利用函数封装的方法翻转任意一个数组
function reverArr(arr) {
    var arrNew = [];
    for (i = arr.length - 1; i >= 0; i--) {
        arrNew[arrNew.length] = arr[i];
    }
    return arrNew;
}
var a = [1, 2, 3, 4, 6, 8, 2, 6, 8];
var re = reverArr(a);
console.log(re);

案例2

利用函数封装的方式对数组排序（冒泡排序）

//冒泡排序
//对于i的范围：1个数，不用排； 两个数，排1趟； 三个数 排2趟。。。n个数，排n-1趟
//对于j的范围，n个数：第一趟比较n-1次，第二趟比较n-2次。。。第n-1趟比较1次
function sort(arr) {
    var temp;
    for (i = 0; i < arr.length - 1; i++) {
        for (j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    return arr;
}
console.log(sort([4, 1, 6, 88, 9, 3, 666])); //(7) [1, 3, 4, 6, 9, 88, 666]

案例3

输入一个年份，判断是否是闰年（闰年：能被4整除且不可以被100整除或者可以被400整除）

// 输入一个年份，判断是否是闰年（闰年：能被4整除且不可以被100整除或者可以被400整除）
function leap(year) {
    var flag = false;
    if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
        flag = true;
    }
    return flag;
}
console.log(leap(2000)); //true
console.log(leap(1999)); //false

案例4：一个函数可以调用另一个函数

用户输入年份，输出当年二月份的天数，即如果用户输入的是闰年二月份就是29天，如果用户输入的是平年，二月份就是28天

function backDays() {
    year = prompt('用户输入年份');
    if (leap(year)) {
        return alert(year + '年的二月份天数为' + 29 + '天');
    }
    return alert(year + '年的二月份天数为' + 28 + '天');
}
backDays()

//输入一个年份，判断是否是闰年（闰年：能被4整除且不可以被100整除或者可以被400整除）
function leap(year) {
    var flag = false;
    if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
        flag = true;
    }
    return flag;
}

函数的两种声明方式

• 利用函数关键自定义函数

function fn() {

}
fn();

• 函数表达式

var 变量名=function(){};   // 注意fun是变量名而不是函数名

//函数的2种声明方式
//1. 利用函数关键自定义函数（命名函数）
function fn() {

}
fn();
//2.函数表达式 匿名函数
//var 变量名=function(){}; // 注意fun是变量名而不是函数名
var fun = function(aru) {
    console.log('我是函数表达式'); //我是函数表达式
    console.log(aru); //我是pink老师

}
fun('我是pink老师');
//（1）fun是变量名 不是函数名
//（2）函数表达式声明方式和声明变量差不多，只不过变量里存的是值，函数表达式里存的是函数
//函数表达式也可以进行传递参数

作用域

作用域

一段程序代码中所用到的名字不是总是有效和可用的，而限定这个名字的可用性的代码范围就是这个名字的作用域。目的是为了提高程序的可靠性，更重要的是减少命名冲突。

• 在es6之前，js的作用域有：全局作用域和局部作用域
• 全局作用域：整个script标签，或者是一个单独的js文件
• 局部作用域(函数作用域)：在函数内部就是局部作用域，代码名只在函数内部起效果，函数之外就不起效果了。

//全局作用域
var num = 10;
console.log(num);//10

//局部作用域
function fn() {
    //局部作用域
    var num = 20;
    console.log(num);//20
}
fn();
//由于是在不同的作用域下，上面两个同名的num不会发生冲突

变量的作用域

根据作用域的不同，变量分为全局变量和局部变量

全局变量

在全局作用域下声明的变量叫做全局变量(在函数外部定义的变量)。

• 全局变量在代码的任何位置都可以使用
• 特殊情况下，在函数内不使用var声明的变量也是全局变量(不建议使用)
• 全局变量：在全局作用域下的变量，在全局都可以使用

注意：在函数内部没有声明而直接赋值的变量也属于全局变量

//全局变量
var num = 10; //全局变量
console.log(num); //10
function fun1() {
    console.log(num); //10 全局变量在函数内部也是可以使用的

}
fun1();

//注意：在函数内部没有声明而直接赋值的变量也属于全局变量
function fun2() {
    num2 = 20; //全局变量
}
fun2();
console.log(num2); //20

局部变量

在局部作用域下声明的变量叫做局部变量(在函数内部定义的变量)

• 局部变量只能在该函数内部使用
• 函数的形参实际上就是局部变量
• 局部变量：在局部作用域下的变量，或者说是在函数内部的变量

function fun3() {
    var num1 = 10; //局部变量
}
fun3();
console.log(num1); //报错 num1 is not defined

注意：函数里的形参也看作是局部变量

function fun4(aru) {
}
fun3();
console.log(aru);//aru is not defined

• 全局变量和局部变量比较

（1）只有当浏览器关闭的时候才会销毁，比较占用内存资源
（2）局部变量只有当程序执行完毕就会销毁，比较节约内存
说明：
现阶段js(es5)没有块级作用域的概念，js在es6的时候才新增了块级作用域的概念。块级作用域就是用花括号{}进行包含的，如if{}、for{}等。
而java就是有块级作用域这个概念例如在java中

if (xx) {
    int num;
}
// {}外面是不可以调用这个num的

js(es5)

// js(es5)中没有块级作用域的概念
if (3 < 5) {
    var num = 10;
}
console.log(num);//10 顺利输出

作用域链

内部函数访问外部函数的变量，采取的是链式查找的方法来决定取哪个值，这种结构我们称为作用域链。

var num = 10;

function fun1() {
    var num = 20;

    function fun2() {
        console.log(num); //20  就近原则
    }
    fun2();
}
fun1();

作用域链案例

案例1：

//案例1：结果是几：
function f1() {
    var num = 123;

    function f2() {
        console.log(num);//答案：123
    }
    f2();
}
var num = 456;
f1();

案例2：

// 输出是几？
var a = 1;

function fn1() {
    var a = 2;
    var b = '22';
    fn2();

    function fn2() {
        var a = 3;
        fn3();

        function fn3() {
            var a = 4;
            console.log(a); //a的值？答案：4
            console.log(b); //b的值？ 答案：'22'
            //小技巧：站在当前的位置一层一层地往外找

        }
    }
}
fn1();

预解析

预解析

//1问
console.log(num);//报错 num未定义

//2问
console.log(num); //undefined  未报错
var num = 10;

//3问
fun();//11 未报错

function fun() {
    console.log(11); 

}
//把fun();放在后面、前面都不会报错

//4问
fun1();//报错 fun1 is not a function
var fun1 = function() {
        console.log(22); 

    }
    //把fun1();放在后面就不会报错


//综上，问2和文4都比较奇怪

Js代码是由浏览器中的js解析器来执行的。
js解析器在运行js代码的时候分为两步：预解析和代码执行。

• 预解析：js引擎会把js里面所有的var、function(这里指函数声明，不包括函数表达式)提升到当前作用域的最前面。
• 代码执行：按照代码书写的顺序从上往下执行

变量预解析和函数预解析

预解析分为变量预解析(变量提升)和函数预解析(函数提升)

变量提升

就是把所有的变量声明提升到当前作用域的最前面，不提升赋值操作
对于之前的“问2”

//2问
console.log(num); //undefined  未报错
var num = 10;

相当于执行了以下代码

var num;
console.log(num); //undefined
num = 10;

对于之前的“问4”

// 4问
fun1();//报错 fun1 is not a function
var fun1 = function() {
    console.log(22); 
}
//把fun1();放在后面就不会报错

相当于执行了以下代码

var fun1;
fun1();//报错 fun1 is not a function
fun1 = function() {
    console.log(22);
}

值得注意的是这里的fun1是变量名，不是函数名，这里是函数表达式，是匿名函数。

函数提升

就是把所有的函数声明(注意是函数声明，不是函数表达式)提升到当前作用域的最前面， 不调用函数
这就可用说明为什么在“问3”中，函数的fun();
放在前后都不会报错，
对于之前的问“问3”

fun();//11 未报错

function fun() {
    console.log(11); 

}

相当于执行了以下代码：

function fun() {
    console.log(11); 

}
fun();//11 未报错

注意：由于函数表达式无法进行函数提升，所以函数表达式的调用必须写在函数表达式的下面

预解析案例

• 案例1

//案例1 会输出什么
var num = 10;
fun();

function fun() {
    console.log(num); 
    var num = 20;

}

相当于执行了以下代码

var num;

function fun() {
    var num;
    console.log(num); //undefined
    num = 20;

}
num = 10;
fun();

• 案例2

//案例2
var num = 10;

function fn() {
    console.log(num);
    var num = 20;
    console.log(num);
}
fn();

相当于执行了以下代码

//  由内而外地完成变量提升，在根据链式查找法，得到输出的结果
var num;

function fn() {
    var num;
    console.log(num); //undefined
    num = 20;
    console.log(num); //20
}
num = 10;
fn();

• 案例3

//案例3
var a = 18;
f1();

function f1() {
    var b = 9;
    console.log(a);
    console.log(b);
    var a = '123';
}

相当于执行了以下代码

//相当于执行了以下代码
var a;

function f1() {
    var b;
    var a;
    b = 9;
    console.log(a); //undefined
    console.log(b); //9
    a = '123';
}
a = 18;
f1();

小tips:

var a = b = c = 9;

相当于

var a=9;
b=9;
c=9;

集体声明

var a = 9,b = 9,c = 9;

才相当于

var a = 9;
var b = 9;
var c = 9;

• 案例4

//案例4
f1();
console.log(c);
console.log(b);
console.log(a);

function f1() {
    var a = b = c = 9;
    console.log(a);
    console.log(b);
    console.log(c);
}

相当于执行以下代码

function f1() {
    var a;
    a = b = c = 9;
    // 相当于
    // var a = 9;b = 9;c = 9;
    // 所以b c 是全局变量
    console.log(a); //9
    console.log(b); //9
    console.log(c); //9
}
f1();
console.log(c); //9
console.log(b); //9
console.log(a); //报错 a is not defined

• 案例总结

先将代码按照预解析排列好，再按照作用域链去查找结果即可