这段时间，白龙网重复回顾了数据的2种创建方法、追加元素，以及如何访问、遍历元素。另外，还复习了函数的声明、调用以及形参的玩法。同时，对再次使用对象实现的计算器的功能，对于对象的三种创建方法、三种访问技巧，学会了综合运用。
一、数组
一、数组
1、数组概念
数组是一组数据的集合，它是数据存在单个变量下的优雅方式。可能通过new关键字，或者数据字面量来创建。
2、创建数组
（1）数组字面量创建数组
<script>
var arr = [1,2,'白龙网',true];
</script>
创建一个数组并赋值叫数组初始化，数组中的数据叫元素，元素之间用逗号隔开，元素可以是数字、字符、布尔、null、undefined等不同的数据类型。
（2）关键字创建数组
<script>
var arr = new Array();//使用元素下标为空数组添加元素并访问元素
arr[0] = 1;
arr[1] = 245;
console.log(arr[0]);
console.log(arr[1]);
</script>
3、访问数组中的元素
（1）访问数组中的某个元素
通过“数组名[下标]”的形式访问数组中的某个元素，下标是从0开始。如果要访问数组名，那么，不但可以返回数组元素，还可以返回数组长度等信息。
<script>
var arr = [1,2,'白龙网',true];
console.log(arr);//访问数组arr中的所有元素
console.log(arr[2]);//访问数组中第2个元素白龙网
</script>
（2）访问数组中的所有元素（遍历数组）
<script>
var arr = [1,2,'白龙网',true];
for (i = 0; i < arr.length; i++) {
console.log('遍历所有元素：' + arr[i]);
}
console.log('数组的第一个元素是：' + arr[0]);//访问数组第一个元素
console.log('数组的最后一个元素：' + arr[arr.length -1]);//访问数组最后一个元素，下标等于数组长度减去1
</script>
（3）访问数组中的最后首尾元素
<script>
var arr = [1,2,'白龙网',true];
console.log('数组的第一个元素是：' + arr[0]);//访问数组第一个元素
console.log('数组的最后一个元素：' + arr[arr.length -1]);//访问数组最后一个元素，下标等于数组长度减去1
</script>
数组的长度等于元素的个数，数组的最后一个元素下标等于数据的长度减1.
案例1：求出数组中所有元素的和与平均值
<script>
var arr = [1,30,59,49,23];
var sum = 0;
var average = 0;
for (i = 0 ; i < arr.length; i++) {
sum += arr[i];//我们把要数组元素全部加起来，而不是把计数器加起来
}
average = sum / arr.length;
console.log(sum,average);//打印多个变量时，变量之间用逗号隔开
</script>
案例2：求数组元素中的最大值、最小值
<script>
var arr = [111,30,59,149,23];
var max = arr[0];//首先假设数据元素中最大值是第一个元素
var min = arr[0];
for (i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];//每个元素与max比较，如果比max大，就把那个值arr[i]赋值给max
}
if (arr[i] < min) {
min = arr[i];
}
}
console.log('最大值是：' + max);
console.log('最小值是：' + min);
</script>
案例3：把数组中的字符拼接一个字符串，该需求类似于求，只不过在拼接的过程中，加号变成了连字符。
<script>
var arr = ['白龙网','是一个','专业做网站','的','平台'];
var str = '';
var step = '*';
for (i = 0 ; i < arr.length; i++) {
str += arr[i] + step;
}
console.log(str);
</script>
4、数组中新增元素
（1）修改数组长度增加元素
<script>
var arr = ['白龙网','是一个','专业做网站','的','平台'];
console.log(arr.length);
arr.length = 8;
console.log(arr);//修改数组长度后，在数组尾部增加了3个空元素，未定义的元素。
</script>
（2）追加数组元素
通过上面修改数组长度，我们在数组后面增加了三个未定义的元素，接下来，就可以在空元素位置增加新的元素了。在非空元素位置赋值，是为修改该位置的内容。
<script>
var arr = ['白龙网','是一个','专业做网站','的','平台'];
console.log(arr.length);
arr.length = 8;
console.log(arr);//修改数组长度后，在数组尾部增加了3个空元素，未定义的元素。
arr[7] = '白龙SEO';
arr[6] = '白龙前端';//在空元素位置添加元素，是为追加元素
console.log(arr);
arr[0] = '修改后打地铺经';//在非空元素上添加新元素，会覆盖原来的元素，即修改；
console.log(arr);
arr = '直接给数据名赋值会出现什么现象：'//不能直接给数组名赋值，否则会覆盖掉数组中所有元素
console.log(arr);
</script>
案例1：把1-10的数字追加到数组中
<script>
var arr = [];
for (i = 0 ; i < 10; i++) {
arr[i] = i + 1;//该算法的关键点在于把计数器赋值给数组元素
}
console.log(arr);
</script>
案例2：筛选数组中大于50的元素，并把它们放到新数组中去
<script>
var arr = [100,40,210,2,60];
var newArr = [];//创建空数组，什么都不写即可
var j = 0;
for (var i = 0;i < arr.length;i++) {//条件表达式可以借助数组长度动态执行
if (arr[i] > 50) {
newArr[j] = arr[i];//先处理满足条件的元素，追加到新数组中去
j++;//再声明一个变量，用来处理新数组的下标，从0开始
}
}
console.log(newArr);//查看新数组，要放入声明的变量newArr，即新数组名
</script>
或者使用新数组的长度来控制新数组的下标
<script>
var arr = [100,40,210,2,60];
var newArr = [];
newArr.length = 0;//通过新数组的长度来控制新数据的下标
for (var i = 0;i < arr.length;i++) {
if (arr[i] > 50) {
newArr[newArr.length] = arr[i];//初始状态下，新数组里面有0个元素，故此时newArr.length=0，那么newArr[0]就存入第一个大于等于10的元素，依次类推[1]存第2个……
}
}
console.log(newArr);
</script>
案例3：去重操作，去掉数组中重复元素0，把剩下的元素放入新的数组中
<script>
var arr = [100,40,0,210,0,2,0,60,1];
var newArr = [];
for (var i = 0; i < arr.length; i++) {//条件表达式中的i要声明变量
if (arr[i] != 0) {
newArr[newArr.length] = arr[i];
}
}
console.log(newArr);
for (var j = 0; j < newArr.length; j++) {
console.log(newArr[j]);
}
</script>
案例4：翻转操作
<script>
var arr = ['red','blue','black','orange','skyblue'];
var newArr = [];
for (var i = arr.length -1; i >= 0; i--) {//
newArr[newArr.length] = arr[i];//核心算法：把最后一个元素放到新数组的第一个位置，因此，计数器要人大到小，执行减减操作
}
console.log(newArr);
</script>
结合条件表达式与循环体，观察数组元素长度与下标的关系，即可写出相应算法。
案例5：冒泡排序(从大到小排列，或者从小到大排列)
冒泡排序的无非就是从小到大，或者从大到小排列数组元素，因此只需要两两元素进行比较，然后满足条件不理会，不满足条件交换位置即可。
如果有5个元素，需要比较4趟；如果在6个元素，需要比较5趟，由此可见，元素的长度比趟数大1。即需要比较：length-1趟。
另外每趟对比的次数与每趟元素的下标有个关系：length-1-i。
有了上面两个关系，趟数用for外循环实现，比较次数用for内循环实现，再用上交换变量的算法，就实现了冒泡算法。
<script>
var arr = [115,14,33,212,11,1];
for (i = 0; i <= arr.length -1;i++) {//比较的趟数：arr.length -1
for (j = 0;j <= arr.length -1 -i;j++) {//每一趟比较的次数：arr.length -1
if (arr[j] > arr[j + 1]) {//交换数组
var temp;
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] =temp;
}
}
}
console.log(arr);
</script>
二、函数
1、函数的概念
函数是封装了一段可重复调用执行的代码，目的是让大量代码重复使用。
2、函数的使用
函数要先声明，再调用，方可生效。
<script>
function sayHi() {//声明函数要注意，function是关键词；函数名是小写的动词；后面跟小括号（）和花括号｛｝。
console.log('say hi---------');
}
sayHi();//2.函数不调用，自己不执行；调用函数的格式是：函数名（）
</script>
案例：把求和封装到函数中
<script>
function getSum() {
var sum = 0;
for (var i = 1; i <= 100; i++) {
sum += i;
}
console.log(sum);
}
getSum();
</script>
3、函数的参数
利用参数实现函数重复执行不同的代码。例如，利用参数求两个数之间的累加和
<script>
function getSum(num1,num2) {//声明函数的小括号里是形参，它主要是用来接收实参的，类似于变量的赋值，只是不用声明，直接赋值即可；参数没有企业限制，可以有，也可以没有；
var sum = 0;
for (var i = num1; i <= num2; i++) {
sum += i;
}
console.log(sum);
}
getSum(50,200);//调用函数的小括号里是实参
getSum(300,800);//多个参数之间有逗号隔开
</script>
另外，需要注意实参与形参的匹配问题：
（1）当实参数量=形参数量时，形参对应接收实参；
（2）当实参的数量大于形参时，以形参数量为准，接收实参，多出的实参不参执行；
（3）如果实参的数量小于形参时，那么未接收实参的形参为undefined，其它数与undefined一起去处，结果不是一个数字，即：NaN。
建议，尽量让实参的数量与形参的数量相匹配。
4、函数的返回值
（1）函数必须有返回值
函数的值要返回给调用者，谁调用，返回给谁。
函数只是实际某种功能，最终的结果要返回给调用者，用return实现；
只要函数遇到return，就把后面的结果返回给调用者。
函数的三要素：声明函数、返回内容、调用函数。
另外，要注意，函数是可以相互调用的，期间，要搞明白执行过程。
function getSum(num1,num2) {
return num1 + num2;//执行结果返回给调用者
}
console.log(getSum(5,6));
</script>
案例1：利用函数返回值实现求出两个数的最大值
function valueMax(num1,num2) {
// if (num1 > num2) {//用if else实现
// return num1;
// } else {
// return num2;
// }
return num1 > num2 ? num1 : num2;//用三元运算符实现效果
}
console.log(valueMax(67,113));
</script>
案例2：返回任意数组元素的最大值
<script>
function getMax(arr) {//函数的形参可以是变量，数组、等等任意类型；形参是数组，则实参也要送数组到形参
var max = arr[0];
for ( i = 1; i <= arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
return max;//此处是函数的返回值，因此一定要写在函数之下，不要写到for循环之内
}
//返回结果可以赋值给一个变量，方便打印显示
var result = getMax([15,4,3,2,888]);//实参送数组给形参
console.log(result);
</script>
（2）return终止函数
return后面的代码不会被执行；return只能返回一个值得，且以最后一个值为准；如果要返回多个值，可通过返回数组实现。
function getSum(num1,num2) {
// 1.只能返回一个值num2
// return num1,num2;
// 2.return后面的代码不会被执行
// alert('这里不会执行');
//3.通过在数组中放置表达式，让函数返回多个值
return [num1 + num2,num1 *num2]
}
console.log(getSum(1,2));
</script>
（3）返回undefined
<script>
function getSum(num1,num2) {
// return后面有值返回该该值,反之，则返回undefined
// return '白龙网';
}
console.log(getSum(1,2));
</script>
(4)区别“退出”
break:退出for while循环
continue:跳出本次for while循环，执行下一次循环。
return:不能退出循环，还能退出函数；并且把返回值传递给调用者，终止其后面的代码不再执行。
案例1：用户输入任意两个数，弹出两个数之和
<script>
var num1 = prompt('请输入一个数：');
var num2 = prompt('请再输入一个数：');
function getSum(num1,num2) {
return parseFloat(num1) + parseFloat(num2);
}
alert('两个数的和是：' + getSum(num1,num2));
</script>
因为是让用户输入任意数，返回给调用者也是任意数，因此，需要形参、实参、接受输入等3个参数都要实用变量。
案例2：用户输入任意两个数，弹出最大值
function getSum(num1,num2) {
//return num1 > num2 ? num1 : num2;
if (num1 > num2) {
return num1;
} else {
return num2;
}
}
alert('最大值是：' + getSum(num1,num2));
</script>
案例3：求素数？
5、arguments的使用
这个对象中存储了所有传递过来的实参。只有函数有这个arguments对象，只要声明了函数，就可以在函数中使用这个对象。
他是个伪数组，并还是真正意义上的数组，因此不没有数组的pop push等方法。但是，他有数组的长度、下标等属性。
有了arguments就可以不用函数的形参了。
<script>
function fn() {
console.log(arguments);//1.以数组的形式存储所有实参
console.log(arguments.length);//2.打印数组长度
console.log(arguments[4]);//3.通过下标访问数组元素
for (i = 0; i < arguments.length; i++) {//4.使用for循环取出所有实参
console.log(arguments[i]);
}
}
fn(1,2,3,4,5,9);
</script>
案例1：求出任意个数的最大值
<script>
function getMax() {
var max = arguments[0];
for (var i = 1; i < arguments.length; i++) {
if (arguments[i] > max) {
max = arguments[i];
}
}
return max;
}
console.log(getMax(56,23,123,34,1));
console.log(getMax(67,34,23,156,781));
</script>
要养成一个习惯，先声明函数，再调用函数，同时在函数体中返回函数值，切记：返回值不是在循环中。
案例2：翻转数据（新数组元素的个数/长度与放入原数组最后一个元素之后有关系）
<script>
function reverse(arr) {
var newArr = [];
for (var i = arr.length - 1;i >= 0;i--) {
newArr[newArr.length] = arr[i];
}
return newArr;
}
var arr1 = reverse([1,2,5,1,7,3]);//因为是用数组比较，所以要实参要用数组传递数据给形参
console.log(arr1);
</script>
案例3：冒泡排序，明确趟数比元素的个数少1；清楚每趟比较的次数=趟数-趟数的下标；比较大小调换位置。
<script>
function sort(arr) {
for(i = 0; i < arr.length; i++) {
for (j = 0; j < arr.length - 1 - i; j++) {
var temp;
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] =temp;
}
}
}
return arr;
}
var arr1 = sort([6,1,12,89,0,5]);
console.log(arr1);
</script>
案例4：判断闰年，通过一个布尔值来判断闰年
<script>
function getRunYear(year) {
var flag = false;
if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
flag = true;
}
return flag;
}
console.log(getRunYear(2000));
console.log(getRunYear(2001));
</script>
案例5：函数是可以相互调用的
<script>
function backYear() {//该函数调用闰年函数，并打印提示信息
var years = prompt('请输入年份：'); //此处的years是实参
if (getRunYear(years)) {
alert('当前年份是闰年，2月有28天');
} else {
alert('当前年份是平年，2月有29天');
}
}
backYear();
function getRunYear(year) { //此处的year是形参,该函数主要用来判断闰年
var flag = false;
if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
flag = true;
}
return flag;
}
</script>
6、函数的两种声明方式
（1）使用关键字声明函数
function fun() {
}
fun();
（2）函数表达式（匿名函数）
var fn = function() {//1.fn是变量名，不是函数名；这种方式声明函数，与声明变量类同，只不过，变量里面存储的是值，而函数表达式里面存储的是函数；可以传递参数；
}
fn();
7、作用域
（1）作用域
就是在某个范围内的作用与效果，目的是为了减少命名冲突。
①全局作用域
范围是整个script标签，或者是一个单独的JS文件；
②局部作用域（函数作用域）
只在函数内起作用。同一个变量，一个在全局作用域下，一个在局部作用域下，是不冲突的。
es5现阶段JS没有块级作用域，到ES6有块级作用域。块级作用域用花括号包括的区域如if () {} for () {}.ES6时，块作用域只能在内部使用，外面不能调用。
（2）变量作用域
①全局变量
在全局作用域下的变量；全局变量可以在局部作用域下使用。
注意：如果在函数内部没有声明，直接赋值的变量，也是全局变量。例如，var a=b=c=9,相相当于var a=9;b=9;c=9,此时，b与c没有声明var且直接赋值，被当作全局变量。要用集体声明区分开来：var a=9,b=9,c=9;
全局变量在关闭浏览器都会销毁，比较占内存；
②局部变量
在函数中的变量；函数的形参可以看作是局部变量。
在局部作用域下的变量；只能在函数内部使用。
局部变量在函数执行完毕即销毁，比较节省内存。
（3）作用域链
内部函数访问外部函数的变量，采用的是链式查找结构，这种结构叫作用链。就近原则。
（4）预解析
①含义
JS引擎运行JS时分两步，一是预解析，二是代码执行。
预解析:JS引擎会把JS中的var function提升到当前作用域的最前面；
代码执行：按照代码书写顺序，执行。
②变量预解析（变量提升）
把所有的变量声明提升到当前的作用域最前面，只提升变量声明，不提升变量赋值；
③函数预解析（函数提升）
把所有的函数声明提升到当前作用域的最前面，不调用函数。
函数表达式的调用必须写表达式的下面；而关键字创建的函数，调用写前后都可以。
经验：
先按照预解析排列好，再按照作用链的方式查找变量。
三、对象
1、对象的概念
（1）含义
对象是一个具体的实物，万物皆对象。在JS中，对象是一组无序的相关属性与方法的集合。
（2）组成
由此可见，对象是由属性和方法两部分组成的：
属性：是事物的特征，在对象中用属性来表示，一般是名词；
方法：是事物的行为，在对象中用方法来表示，一般是动词；
（3）目的
存储一个值可以使用变量，存储多个值可以用数组，存储一个完整的信息可以用对象，因此，使用对象，可以让事物的结构更加清晰。
2、创建对象
（1）字面量创建对象
①语法
这里面包含字面量创建对象的方法，以及调用对象属性的2种方法，调用方法的技巧；如果花括号里面没有属性和方法，说明该对象为空，即：var obj = {}
<script>
var obj = {//1.var 对象名 = ｛属性，方法｝
uname: '白龙网',//2.属性采用键值对的形式，属性名：属性值
age: 15,//3.属性或者方法之间用逗号隔开
sex: '男',
sayHi: function() {//4.方法是方法名：匿名函数
console.log('hi----------');
}
}
console.log(obj.uname);//调用对象属性方法1：对象名.属性名
console.log(obj['age']);//调用对象属性方法2：对象名['属性名']
obj.sayHi();//该用方法是：对象名.方法名()，一定要小括号
</script>
②变量、属性、函数、方法
①变量与属性
他们相同点，他们都是用来存储数据的；不同的是，变量是单独声明并赋值，使用的时候用变量名即可，单独使用；而属性在对象里面不需要声明，直接用对象名.属性即可调用，
②函数与方法
两者都是为了实现某种功能而生；函数是单独声明使用，函数名()；方法在存在对象之中，调用形式是对象名.方法名()。
变量与函数是单独存在，属性与方法在对象之中，这是他们根据区别。
（2）new object创建对象
①该方法类似于new关键字创建数组：
<script>
var obj = new Object()//1.创建一个空对象，注意O要大写
obj.uname = '白龙网';//2.用等号赋值的方法为对象添加属性、方法
obj.age = 18;//3.属性与方法之间用分号隔开
obj.sex = '男';
obj.sayHi = function() {
console.log('hi-----');
}
obj.sayHi();//调用属性、方法与字面量创造的对象一样
console.log(obj.sex);
</script>
（3）构造函数创建对象
①含义
前面创建对象的两种方式一次只能创建一个对象。由于一次创建一个对象的方法大量相同，因此可以使用函数的方法，重复这些相同的代码。
我们就把这个函数称为构造函数。又因为这个函数有点不一样，因为他封闭的不是普通函数，而是对象。构造函数就是把对象中相同的属性和方法封到函数里面。
<script>
function Star(uname,age,sex) {//1.构造函数的名子首字母要大写；形参必须有，用来接收实参
this.name = uname;//然后把形参赋值给属性名
this.age = age;//4.属性和方法前必须添加this
this.sex = sex;//2.构造函数不需要return，就能返回结果
this.sing = function(sang) {
console.log(sang);
}
}
var bailong = new Star('白龙网',18,'男');//3.调用构造函数要使用new，调用对象，就创建了一个对象
console.log(bailong.name);//调用时用：别名.属性名
console.log(bailong['age']);
bailong.sing('HI-------');//方法的调用
</script>
案例1：使用构造函数，创建2个对象
<script>
function Hero(name,type,blood) {
this.name = name;
this.type = type;
this.blood = blood;
this.attack = function(attack) {
console.log(attack);
}
}
var lianpo = new Hero('廉颇','力量型','500血量');
console.log(lianpo.name);//调用方式1
console.log(lianpo.type);
console.log(lianpo.blood);
lianpo.attack('近战');
var houyi = new Hero('后裔','射手型','100血量');
console.log(houyi['name']);调用方式2
console.log(houyi['type']);
console.log(houyi['blood']);
houyi.attack('远程');
</script>
②构造函数与对象的区别
对象是一个具体的事物，通过new关键字创建出来的，用new关键字创建对象的过程，叫对象实例化；构造函数是泛指一个大类，是对象的公共部分，封装到了函数里面，类似于JAVA中的类；可以利用构造函数来创建对象。
③new 的执行过程
不管是上面哪种方法创建对象，都要使用new关键字来调用对象，实际上就是创建对象。new关键字的执行过程分为4步：
❶new关键字会在内存中创建一个空的对象，
❷this会指向空对象；
❸执行构造函数里面的代码，给空对象添加属性和方法；
❹返回这个对象，所以构造函数不需要return；
3、遍历对象
遍历对象用for(var 变量 in 对象) {}
<script>
var obj = {
name: '白龙网',
age: 3,
sex: '男',
fn: function() {
console.log('hi------------');
}
}
for (var k in obj) {
console.log(k);//K是对象的属性名、方法名
console.log(obj[k]);//obj[k]是对象的属性值、方法名
}
</script>
如果用for (var 变量 in 数组名) {}，那么k是数组元素的下标，arr[k]是数组元素，如下所示：
<script>
var arr = [1,2,3,4,5,3]
for (var k in arr) {
console.log('数组的下标是：' + k);方法名
console.log('数组元素是：' + arr[k]);
}
</script>
案例1：写一个电脑的对象
<script>
//使用字面量创建对象
var computer = {
color: '蓝色',
weight: '18公斤',
brand: 'huaWei',
model: 'A30',
film: function() {
console.log('看看电影啦');
},
music: function(musics) {
console.log(musics);
},
game: function() {
console.log('打一会游戏');
},
code: function(code) {
console.log(code);
}
}
//使用对象名.属性名调用对象属性；使用对象名.方法方法名()调用方法，方法与函数的使用方法一样，也可以有形参
console.log(computer.color);
console.log(computer.weight);
console.log(computer.brand);
console.log(computer.model);
computer.film();
computer.music('世界第一等')
computer.game();
computer.code('hello world');
</script>
案例2：创建一个按钮对象
<script>
//使用new关键字创建对象
var button = new Object();
button.width = '500px';
button.height = '600px';
button.bgc = 'blue';
button.click = function() {
console.log('点击一下哈哈');
}
//使用对象名['属性名']的形式访问对象属性，这是第2种方法访问
console.log(button['width']);
console.log(button['height']);
console.log(button['bgc']);
button.click();
</script>
案例3：使用构造函数创建对象，并使用3种方法分别访问对象属性值、方法，还遍历了对象的所有属性、方法
<script>
function Tractor(weight,color,brand) {
this.weight = weight;
this.color = color;
this.brand =brand;
this.manned = function() {
console.log('载人');
};
this.pull = function() {
console.log('拉货');
};
this.plough = function() {
console.log('耕田');
}
}
//用new关键字重新创建的对象，并赋值给obj，因此，后面可以使用obj这个对象来访问其属性与方法，同时也使用 for in遍历了对象的所有属性、方法值
var obj = new Tractor('1900公斤','红色','华为拖拉机');
console.log(obj.weight);
console.log(obj['color']);
obj.pull();
console.log('-------------分割线---------------------');
for (var k in obj) {
console.log(obj[k]);
}
</script>
案例4：写一个加减乘除的计算器，输入1，计算两数之和；2-减；3-乘；4-除。
<script>
function Calculator() {
this.addition = function(x,y) {
alert(x + y);
};
this.subtraction = function(x,y) {
alert(x - y);
};
this.multiplication =function(x,y) {
alert(x * y);
};
this.division = function(x,y) {
alert(x / y);
}
}
var result = new Calculator();//1.使用构造函数创建对象，因此这里的实参对应构造函数的形参function Calculator()；
而
var num = prompt('1-加法\n2-减法\n3-乘法\n4-除法');
switch(num) {
case '1':
var x = parseFloat(prompt('请输入第一个数：'));
var y = parseFloat(prompt('请输入第二个数：'));
result.addition(x,y);//2.调用方法，因此这里的实参对应构造函数内的方法的形参this.addition = function(x,y)
break;
case '2':
var x = parseFloat(prompt('请输入第一个数：'));
var y = parseFloat(prompt('请输入第二个数：'));
result.subtraction(x,y);
break;
case '3':
var x = parseFloat(prompt('请输入第一个数：'));
var y = parseFloat(prompt('请输入第二个数：'));
result.multiplication(x,y);
break;
case '4':
var x = parseFloat(prompt('请输入第一个数：'));
var y = parseFloat(prompt('请输入第二个数：'));
result.division(x,y);
break;
default:
var x = parseFloat(prompt('请输入第一个数：'));
var y = parseFloat(prompt('请输入第二个数：'));
result.addition(x,y);
}
</script>