构造函数与原型对象

目录

1、构造函数

2 、原型对象

3、this的指向问题

4、JS中的错误处理

查找算法

1、 顺序查找

2、折半查找（二分法查找）

1、构造函数

(1) 作用：用于创建对象，初始化对象的属性

//在ES5中创建构造函数
function Student (id,name){
    this.id = id
    this.name = name
}
let s1 = new Student(101,'张三')

//在ES6中创建类，给类单独定义构造函数
class Student{
    constructor(id,name){  //构造函数
        this.id = id
        this.name = name
    }
}
let s1 = new Student(101,'张三') //自动调用constructor函数  new Student实例化成S1

注意 ：通常把构造函数创建对象的过程称为类的实例化，对象就是类的实例化

（2）构造函数的成员或类的成员

a: 什么是成员

类的成员包括属性、方法（行为），通常将属性称为成员变量，把方法（行为）称为成员方法（成员函数）

b ：成员变量

成员变量又称为实例变量：用类或构造函数创建的对象都有相同的属性和方法

class Person{
     constructor(id,name){
         this.id = id  //id是成员P1的变量
         this.name = name  //name是成员p2的变量
     }
 }
 display(){ //成员方法，函数，不是变量
     console.log('编号',this.id)
     console.log('姓名',this.name)
 }
 let p1 = new Person (101,'张三')  //p1 是person的成员
 let p2 = new Person (101,'张三')  //p2是person的成员
 //对象p1 和p2 的属性和方法是相同的，但他们在内存中的存储空间是不同的
 console.log(p1 == p2)  //false

C ：静态成员

通过构造函数名或类名直接访问的成员。它不属于任何对象，为类的所有对象（实例共享的）静态成员也成为类成员

 class Student{
     constructor(studentId,studentName){
         Student.schoolName = '西北工业大学'  //静态成员，通过类名直接访问
         this.studentId = studentId
         this.studentName = studentName
     }
     display(){
         console.log('学校',Student.schoolName)
         console.log('学号',this.studentId)
         console.log('姓名',this.studentName)
     }
 }
 let s1 = new Student('1001','Tom')
 let s2 = new Student('1002','Marry')
 let s3 = new Student('1003','Jack')
 ​
 s1.display()
 console.log('---------------')
 s2.display()
 console.log('-------------------')
 s3.display()
 ​
 console.log('--------------------')
 Student.schoolName = '中国西北工业大学'
 s3.display()
 s2.display()

d ： 构造方法和类的区别

    1. 构造函数中定义的**方法**，本质是属性，需要占用存储空间 。

    2. 在类中定义的方法，不是属性，不需要占用存储空间。即在创建类的对象过程中，只给对象的属性分配空间，对象的方法不占空间，因此节省了内存空间。

2 、原型对象

每个构造函数都有一个原型对象，可以通过构造函数的prototype属性访问。

（1）：构造函数的原型对象

1. 构造函数的原型对象是object类型，通过prototype访问到

2. 作用：

   a：通过原型对象可以给构造函数增加新的功能，这些新的功能可以共享给构造函数创建的所有对象。

    function Option(n1,n2){
                this.n1 = n1
                this.n2 = n2
    ​
                this.add = function(){
                    return this.n1 + this.n2
                }
            }
            let op1 = new Option(123,456)
            let op2 = new Option(1,20)
            console.log(op2.add())
            /*需求：
                  前提：不知道Option类的内部定义
                  增加：减法的功能
             */
            
             Option.prototype.sub = function(n1,n2){
                return n1-n2
             }
             console.log(op1.sub(123,456))

（2）对象的原型对象

js中每个对象都有一个原型对象，通过 _ _ proto_ _获得

（3）实例对象与原型对象的关系

（4）对象的构造函数：

通过对象的原型对象来获取。在对象的原型对象有constructor属性，代表了对象的构造函数。示例：用赋值方式修改原型对象为新的对象，就无法访问构造函数。

（5）构造函数、原型对象和实例对象之间的关系 ：

（6）原型链：

a、通过构造函数prototype属性找到构造函数的原型对象，通过构造函数的原型对象的constructor找到构造函数

b、通过构造函数创建实例对象，然后通过实例对象的proto属性可以找到对象的原型对象，也可以通过对象的原型对象的constructor找到构造函数

把上面两种找原型对象和构造函数的过程称为原型链

（7）原型对象的原型对象 ：

原型对象也是一个对象，那么它也有原型对象。

（8）原型链的特点 ：

（9）JS中成员的查找机制 ：

         1. 首先查找对象中有没有这个成员（属性）

1.   如果没有找到，就继续查找原型对象的原型对象

   1. 如果直到最后都没有找到，则返回undefined

function Person(){
     this.sayHello = function(){
         console.log('蜗牛学苑')
     }
 }
 ​
 //输出person的原型对象
 console.log('Person的原型对象:',Person.prototype)
 //输出person的原型对象的原型对象
 console.log('Person的原型对象的原型对象:',Person.prototype.__proto__.constructor)
 ​
 //创建Person对象
 let p1 = new Person()
 console.log('****',p1.userName) //p1的原型对象Person中没有userName成员，继续在Person的原型对象Object中找，么有找到，就是undefined
 ​
 Object.prototype.userName = '张三' //在object的原型对象上定义userName属性
 console.log('----',p1.userName) //在输出p1.userName时会逐层的向上查找，最终在Object的原型对象上找到，就输出“张三”

3、this的指向问题

1. 在构造函数内部this指向新创建的对象

2. 直接通过函数调用函数时，this指向的是全局对象window。

3. 如果将函数作为对象的方法调用，this将会指向该对象

课堂练习：利用原型对象扩展数组（Array）方法。

//通过原型对象扩展Array的方法：求数组元素的和
 ​
 Array.prototype.sum = function(){
     var s = 0;
     for(let i =0;i<this.length;i++){ //this代表的是调用sum函数的数组对象arr
          s = s + this[i]
     }
     return s;
 }
 let arr = new Array(10,20,30,40,50)
 let t = arr.sum()
 console.log(t)

4、JS中的错误处理

（1）使用try--catch处理

 try{
     代码段 //有可能会产生错误
 }catch(错误对象){
     代码段  //产生错误后执行的代码
 }

 ​
 执行过程：
 （1）若try{}中的代码出现了错误，js会根据错误的类型，生成错误对象，然后将该错误对象跑出去
 （2）catch会接受try抛出的错误对象，然后对象错误进行处理
 （3）若try{}中的代码出现错误，try{}中余下的代码就不执行，转到catch下执行

 ​
 let obj = {}
 try{
     obj.show()
 }catch(error){
     console.log(error.message)
 }
 console.log('---------------------------')

(2) 常见的错误类型

 1. Error:表示普通错误，其他的错误对象都是从该对象派生而来

1. RangeError：数值超出有效范围

2. ReferenceError:引用一个不存在的变量

3. SynatxError ：语法错误

4. TypeError：类型错误

(3) throw：是JS的关键字，用于try{}中抛出错误的对象

---

查找算法

1、 顺序查找

按数组或集合中元素的存放顺序依次操作（按顺序依次比较每个元素）

 let arr = [78,98,25,45,99,115,87]
 //在数组arr中查找一个，若找到返回其下标，若没有找打返回-1
 function findNum(arr,num){
     for (let i=0;i<arr.length;i++){
         if(arr[i] ===num){
             return i 
         }
     }
     return -1
 }
 ​
 let k = findNum(arr,99)
 console.log(k)

2、折半查找（二分法查找）

1. 前提条件：被查找的集合或数组必须是有序的

   1. 每次查找时先和被查找区间的中间元素进行比较，若大于中间元素，则继续在被查找区间的右边的区间中找，若小于中间元素则在被查找区间的左边的区间中查找，如此循环