1. JS中有两大数据类型
    2.  简单数据类型
    3.    string number undefined null boolean 
    4.    简单数据类型主要是在栈空间开辟空间的，直接开辟空间存储数据
    5.  复杂数据类型
    6.    对象 Array Function Math Date RegExp
    7.    复杂数据类型是在堆空间开辟空间，存储真正的数据
    8.    还会在栈空间开辟空间，存储数据在堆空间的内存地址，存储一个堆中的引用
    10.  //=============================变量数据类型的传递=================================
    11.  //如果实参是一个简单的数据类型，在进行数据传递的时候，是将当前的值复制一份进行传递
    12.  function getSum(n1,n2){
    13.    n1=100;
    14.    n2=200; //当n1 n2 重新赋值的时候 它直接会覆盖掉实参传给形参的值 直接返回300
    15.    return n1+n2
    16.  }
    17.  var n1=20;
    18.  var n2=30;
    19.  var sum =getSum(n1,n2)//实参  这时n1 和n2 直接复制一份给 getSum中的形参给到n1 和n2 
    20.  console.log(sum) //300
    21.  console.log(n1，n2) //还是20 30

    ea7cc92b6e60dd7e59ebfcf6c290b8b.png
    1bdc29d545c43545708ad4c4ec33087.png

    1.  //============复杂数据类型的传递（或者引用数据类型的传递）（传递数组）===================
    2.  //复杂数据类型是将栈空间的内存地址复制一份传递给函数的形参
    3.  //新参通过这个内存地址也可以找到堆空间中的真正数据，可以进行正常的修改
    4.   function fn(arr){
    5.    arr[2]=200;
    6.    var sum=0
    7.    for(var i=0;i<arr.length;i++){
    8.     sum+=arr[i]
    9.    }
    10.    return sum
    11.   }
    13.   var nums=[20,30,40,50]
    14.   var sum =fn(arr);
    15.   console.log(sum);
    17. //=================复杂数据类型的传递（或者引用数据类型的传递）（传递对象）=================
    19.   //创建对象的方式，有两种
    20.   //new +构造函数 
    21.   //对面字面量的
    22.   //在传递复杂数据类型的时候，是将复杂类型的栈空间的内存地址复制一份进行传递
    23.   // 当接收方接受获得这个地址后，会按着这个地址找到堆空间的真正数据
    24.   function Stu(name，age,sex){
    25.    this.name =name;
    26.    this.age =age;
    27.    this.sex=sex;
    28.   }
    29.   var zs =new Stu("张三",15,"男")
    30.   -------------------------------------------------------------------------
    31.   function fn(obj){
    32.    obj.name='李四'//因为操作的是同一空间中的数据 
    33.     console.log(obj.name) //李四
    34.   }
    35.   fn(zs)
    36.   console.log(zs.name)；//李四
    37.   -------------------------再变--------------------------------------------------
    38.     function fn(obj){
    39.    obj=new Stu('田七'，18，'女') 
    40.     console.log(obj.name) //田七
    41.   }
    42.   fn(zs)
    43.   console.log(zs.name)；//张三

    c0560c575c190a089f44ea005d43323.pngf16f212681084d3780ca62962961e4e.png

    1. instanceof 用于判断当前对象是不是某一个类型的实例
    2. 其中Object 是对象的顶级
    3. instance是实例的意思，就是判断某个实例对象，是不是属于某个构造函数
    5.   function Stu(name，age,sex){
    6.    this.name =name;
    7.    this.age =age;
    8.    this.sex=sex;
    9.   }
    10.   var zs =new Stu("张三",15,"男")
    11.   console.log(zs instanceof Stu)// true
    12.   console.log(zs instanceof Object); //true
    13.   var obj ={} // 写的是对象字面量的方式，相当于是使用了 new Object() 来创建一个空对象
    14.   console.log(zs instanceof Object) //true
    15.   console.log(zs instanceof obj) //false
    17.   // 数组中的验证
    18.   var arr =new Array(10,20,30);
    19.   var arr1 =[40,50,60];
    20.   consol.log(arr instanceof Array) //true
    21.   console.log(arr1 instanceof Array) //true
    22.   var box=document.getElementByClassName("div");//伪数组
    23.   console.log(box instanceof Array);//false box是一个伪数组，就是不是使用new Array创建出来的
    24.   // 伪数组也是数组，也有length属性，也可以存储数据，但是不能使用数组的方法 例如push（） shift（）
    1. 构造函数
    2. 如果要批量创建对象的话，优先使用new +构造函数
    3. 构造函数就相当于一类事物的模板，比如老师类、学生类
    4. 这个模板相当于盖大楼的图纸，有了图纸才能够很好的施工
    5. 凡是同一类事物，写在构造函数当中，肯定是有同样的属性和方法
    6.   function Stu(name，age,sex){ //构造函数中的this指代当前的对象，创建那个对象就指向那个对象
    7.    this.name =name;
    8.    this.age =age;
    9.    this.sex=sex;
    10.    this.sayHi=function(){
    11.    console.log('大家好，我是'+this.name+',今年'+this.age+'岁，是一名'+this.sex+'生')
    12.    }
    13.   }
    15.   //new 做了一四件事
    16.   //1.创建了一个新对象
    17.   //2.return 一个this的返回值
    18.   //3.将this指向这个空对象
    19.   //4.执行构造函数里面的代码
    1. prototype是构造函数的一个属性，同时它也是一个对象
    2. 任何一个构造函数里面都有一个属性prototype
    3. 任何一个实例对象都有一个属性__proto__
    4. Function 所有函数都是由Function 创建出来的
    6. 构造函数中prototype可以让我们写构造函数的时候，节约大量的内存
    7. 因为我们把公共的方法写在prototype上
    8. 凡是在构造函数的prototype属性上定义的方法都可以被所有实例所调用
    10.   function Stu(name，age,sex){ //构造函数中的this指代当前的对象，创建那个对象就指向那个对象
    11.    this.name =name;
    12.    this.age =age;
    13.    this.sex=sex;
    14.   }
    16.   Stu.prototype.sayHi=function(){
    17.    console.log('大家好，我是'+this.name+',今年'+this.age+'岁，是一名'+this.sex+'生')
    18.    }
    19.    Stu.prototype.showInfo =function(){
    20.     console.log(this.name)
    21.    }
    23.    var zs =new Stu("张三"，12，"男")
    24.    zs.sayHi();
    25.    zs.showInfo();
    27.    //所有的构造函数都有prototype原型对象
    28.    //原型对象可以用来扩展方法，给创建出来的实例对象使用
    29.    //在prototype 上面定义或者扩展的方法，能够被所有的实例对象来调用
    31.    //原型对象prototype不但可以定义方法还可以添加属性
    32.    Stu.prototype.address='上海市'
    33.    //原型对象上的方法和属性被所有的实例对象所共用
    34.    //如果实例对象上有自己的属性的话，会优先使用自身的属性，如果自身没有这个属性再去原型对象上找
    35.    //如果原型对象上也没有，则是undefined
    37.    //一般是用法尽量不要在原型对象上定义属性，把属性定义在自己的构造函数里面
    38.    //要在原型对象上定义公共方法或者函数

    构造函数的特殊情况

    1. function Stu(name,age){
    2. this.name=name;
    3. this.age =age;
    4.   //return 123;
    5.  // return [1,2,3]
    6.   return new Date();
    7. }
    8. var tom =new Stu('tom',17);
    9. console.log(tom);
    10. //返回一个实例对象，当存在return 的时候 且是普通的数据类型的时候 还是返回一个实例对象
    11. //当构造函数return 一个数组的时候 直接取代实例对象，返回数组 同样new Date() 也是一样的
    12. console.log(tom.name);