JavaScript day5

• 前言
• 一、arguments的使用
• • 1.arguments和数组的区别
  • 2.利用arguments实现数组元素的反转；
• 二、函数的封装
• • 2.1 封装数组翻转
  • 2.2 封装冒泡排序
  • 2.3 封装判断闰年程序
• 三、函数调用另外一个函数
• 四、函数声明的两种方式
• • 4.1 function关键字声明函数
  • 4.2 函数表达式
• 五、JavaScript作用域（ES6之前）
• • 5.1 作用域的作用
  • 5.1 作用域种类
  • • 5.1.1 全局作用域
    • 5.1.2 局部作用域
• 六、变量的类型
• • 6.1 全局变量
  • 6.2 局部变量
• 七、JavaScript作用域链
• • 作用域链：内部函数在访问外部函数的变量时，采用的是就近原则，选取离内部函数最近的那个变量的值；
• 八、JavaScript预解析
• • 8.1 预解析的步骤
  • • 8.1.1 变量提升
    • 8.1.2 函数提升
• 九、对象
• • 9.1创建对象的方式
  • • 9.1.1 对象字面量创建对象
    • 9.1.2 new关键字创建对象
    • 9.1.3 构造函数创建对象
  • 9.2 如何使用对象
  • • 9.2.1 调用对象属性
    • 9.2.2 调用对象内部的方法
  • 9.3 对象内部属性、方法分别和变量、函数的区别
  • • 9.3.1 属性和变量的区别
    • 9.3.2 方法和函数的区别
  • 9.4 对象new关键字的执行过程
  • 9.5 遍历对象

前言

本文主要讲解arguments的使用、函数的封装、对象等内容；

提示：以下是本篇文章正文内容，下面案例可供参考

一、arguments的使用

1、只有函数才有arguments对象，每个函数都内置有arguments对象；
2、arguments里面储存了所有传递过来的实参；
3、arguments被称为伪数组；

1.arguments和数组的区别

1、其具有数组元素的length属性；
2、其和数组一样按照索引的方式进行储存；
3、其不具备真正数组的一些方法；如pop（），push（）等等；

   // arguments 的使用  只有函数才有 arguments对象  而且是每个函数都内置好了这个arguments // 作用: 里面存储了所有传递过来的实参 function fn() {     // console.log(arguments); // 里面存储了所有传递过来的实参  arguments = [1,2,3]     // console.log(arguments.length);     // console.log(arguments[2]);     // 我们可以按照数组的方式遍历arguments     for (var i = 0; i < arguments.length; i++) {  console.log(arguments[i]);     } } fn(1, 2, 3); fn(1, 2, 3, 4, 5); // 伪数组 并不是真正意义上的数组 // 1. 具有数组的 length 属性 // 2. 按照索引的方式进行存储的 // 3. 它没有真正数组的一些方法 pop()  push() 等等

2.利用arguments实现数组元素的反转；

注意：以下输入的数组元素对arguments来说，接收的元素数量为1，要想对接收的数组元素内部数据进行操作，需要arguments[0],先获取数组元素，再对数组元素进行下一步操作；

  function reverse () {     var newArr = [];     for(var i = arguments[0].length - 1 ; i >= 0; i--){  newArr[newArr.length] = arguments[0][i];     }     return newArr; } console.log(reverse([1,2,3,4,5]));

二、函数的封装

为了方便使用代码实现的功能，可以将实现某个功能的代码片段，利用return，封装到函数内部，每次使用时，直接传入形参调用函数即可。

2.1 封装数组翻转

实现将某一数组元素进行翻转；
代码如下（示例）：

function reverse (arr){     var newArr = [];     for(var i = arr.length - 1; i >= 0; i--){  newArr[newArr.length] = arr[i];     }     return newArr;      } console.log(reverse([1,2,3,4,5]));

2.2 封装冒泡排序

将输入的数组元素内部元素进行从小到大或从大到小排列；

代码如下（示例）：

 function sort(arr){     for(var i = 0 ;i < arr.length - 1; i++){  for(var j = 0 ;j < arr.length - i -1; j++){      if(arr[j] > arr[j+1]){   var temp = 0;   temp = arr[j];   arr[j] = arr[j+1];   arr[j+1] = temp;      }  }     }     return arr; } console.log(sort([1,4,6,2,8,0]));

2.3 封装判断闰年程序

闰年：能被4整除且不能被100整除，或能被400整除

代码如下（示例）：

//闰年：能被4整除且不能被100整除，或能被400整除 function  isRunYear(year){     return year % 4 == 0 && year % 100 != 0 || year % 400 == 0; } console.log(isRunYear(2000));

三、函数调用另外一个函数

在一个函数内部可以调用另外一个定义的函数；

代码如下（示例）：

 //在函数内部是可以调用另一个函数 function fn1() {     console.log(11);     fn2(); // 在fn1 函数里面调用了 fn2 函数 } fn1();

四、函数声明的两种方式

4.1 function关键字声明函数

代码如下（示例）：

// 1. 利用函数关键字自定义函数(命名函数) function fn() { }

4.2 函数表达式

声明一个变量将匿名函数传入变量中；函数表达式声明方式跟声明变量差不多，只不过变量里面存的是值 而 函数表达式里面存的是函数；

代码如下（示例）：

// 2. 函数表达式(匿名函数)  // var 变量名 = function() {}; var fun = function(aru) {     console.log('我是函数表达式');     console.log(aru); } fun('老师'); // (1) fun是变量名 不是函数名   // (2) 函数表达式声明方式跟声明变量差不多，只不过变量里面存的是值 而 函数表达式里面存的是函数 // (3) 函数表达式也可以进行传递参数

五、JavaScript作用域（ES6之前）

5.1 作用域的作用

作用域限制代码中的变量起作用的范围，这样能保证代码的可靠性，相同的变量名在不同的作用域下不会出现命名冲突；
注：ES6才有块级作用域；

5.1 作用域种类

5.1.1 全局作用域

整个script标签和单独的js文件都是全局作用域
全局作用域中不能访问局部作用域里的变量；

5.1.2 局部作用域

函数内部就是局部作用域；

代码如下（示例）：
以下函数内部的num1 和外部的num1不会命名冲突；

var num1 = 10; function fun(aru) {     var num1 = 10; // num1就是局部变量 只能在函数内部使用     num2 = 20; } fun();

六、变量的类型

6.1 全局变量

在全局作用域中的变量；
注：1、在函数内部未声明的变量也是全局变量；
2、外部作用域中不能访问内部作用域的变量；

6.2 局部变量

在局部作用域中的变量叫做局部变量；
注：1、函数的形参也叫做局部变量；
2、内部函数可以访问外部函数的变量

七、JavaScript作用域链

作用域链：内部函数在访问外部函数的变量时，采用的是就近原则，选取离内部函数最近的那个变量的值；

代码如下（示例）：

 var num = 10; function fn() { // 外部函数     var num = 20;     function fun() { // 内部函数  console.log(num);     }     fun(); } fn();

八、JavaScript预解析

js引擎在执行js代码有两步：1、预解析 2、执行js代码；

8.1 预解析的步骤

8.1.1 变量提升

变量提升是将所有的变量声明提升到当前作用域最前面；注：不提升赋值操作！！！

8.1.2 函数提升

函数提升是将所有的函数声明提升到当前作用域最前面；注：不提升函数调用！！！

代码如下（示例）：

 fun(); // 报错  坑2  var fun = function() {  console.log(22);     }     // 函数表达式 调用必须写在函数表达式的下面     // 相当于执行了以下代码     // var fun;     // fun();     // fun = function() {     //  console.log(22); //     }

九、对象

对象是一系列无序的属性和方法的集合；

9.1创建对象的方式

9.1.1 对象字面量创建对象

代码如下（示例）：

// 1.利用对象字面量创建对象 {} // var obj = {};  // 创建了一个空的对象  var obj = {  uname: '张三疯',  age: 18,  sex: '男',  sayHi: function() {      console.log('hi~');  }     }     // (1) 里面的属性或者方法我们采取键值对的形式  键 属性名 ： 值  属性值      // (2) 多个属性或者方法中间用逗号隔开的     // (3) 方法冒号后面跟的是一个匿名函数

9.1.2 new关键字创建对象

利用new关键字创建的对象在给对象添加属性和方法时，直接利用赋值的方法;

代码如下（示例）：

 // 利用 new Object 创建对象 var obj = new Object(); // 创建了一个空的对象 obj.uname = '张三疯'; obj.age = 18; obj.sex = '男'; obj.sayHi = function() {  console.log('hi~');     }     // (1) 我们是利用 等号 = 赋值的方法 添加对象的属性和方法     // (2) 每个属性和方法之间用 分号结束 console.log(obj.uname); console.log(obj['sex']); obj.sayHi(); var obj1 = new Object(); obj1.uname = 'mingren' obj1.age = '18'; obj1.fn1 = function(){     console.log('我是名人'); } obj1.fn1();

9.1.3 构造函数创建对象

构造函数就是将对象封装到函数中；构造函数中的对象的属性和方法需要加this关键字，在调用构造函数时，需要加上new关键字；

代码如下（示例）：

// function 构造函数名() { //     this.属性 = 值; //     this.方法 = function() {} // } // new 构造函数名();

注：构造函数自动返回对象，不需要return；

9.2 如何使用对象

9.2.1 调用对象属性

方法一：

代码如下（示例）：

 // (1). 调用对象的属性 我们采取 对象名.属性名 . 我们理解为 的 console.log(obj.uname);

方法二：

代码如下（实例）：

 // (2). 调用属性还有一种方法 对象名['属性名'] console.log(obj['age']);

9.2.2 调用对象内部的方法

代码如下（实例）：

(3) 调用对象的方法 sayHi   对象名.方法名() obj.sayHi();

注：在调用对象内部的方法时，不要忘记加（）！！！

9.3 对象内部属性、方法分别和变量、函数的区别

9.3.1 属性和变量的区别

变量：1、变量单独声明并赋值；2、单独存在，使用时直接引用变量名；

属性：1、属性不需要声明，依托于对象存在；2、使用时必须是：对象.属性名；

9.3.2 方法和函数的区别

相同点：都是运行某一段代码实现某种功能；
异同点：函数是单独声明，单独调用，方法在函数的内部，依赖对象而存在，调用时必须加上new关键字；

代码如下（实例）：

// 变量、属性、函数、方法的区别 // 1.变量和属性的相同点 他们都是用来存储数据的  var num = 10; var obj = {     age: 18,     fn: function() {     } } function fn() { } console.log(obj.age); // console.log(age); // 变量 单独声明并赋值  使用的时候直接写变量名 单独存在 // 属性 在对象里面的不需要声明的 使用的时候必须是 对象.属性 // 2. 函数和方法的相同点 都是实现某种功能  做某件事 // 函数是单独声明 并且调用的 函数名() 单独存在的 // 方法 在对象里面 调用的时候 对象.方法()

9.4 对象new关键字的执行过程

代码如下（实例）：

// new关键字执行过程 // 1. new 构造函数可以在内存中创建了一个空的对象  // 2. this 就会指向刚才创建的空对象 // 3. 执行构造函数里面的代码 给这个空对象添加属性和方法 // 4. 返回这个对象 function Star(uname, age, sex) {     this.name = uname;     this.age = age;     this.sex = sex;     this.sing = function(sang) {  console.log(sang);     } } var ldh = new Star('刘德华', 18, '男');

9.5 遍历对象

遍历对象类似于循环访问对象中的属性和方法；

代码如下（实例）：

// 遍历对象  var obj = {  name: 'pink老师',  age: 18,  sex: '男',  fn: function() {}     }     // console.log(obj.name);     // console.log(obj.age);     // console.log(obj.sex);     // for in 遍历我们的对象     // for (变量 in 对象) { // } for (var k in obj) {     console.log(k); // k 变量 输出  得到的是 属性名     console.log(obj[k]); // obj[k] 得到是 属性值 } // 我们使用 for in 里面的变量 我们喜欢写 k  或者  key

步森服饰商城