06.JS对象

前言:
学习一门编程语言的基本步骤
(01)了解背景知识
(02)搭建开发环境
(03)语法规范
(04)常量和变量
(05)数据类型
(06)数据类型转换
(07)运算符
(08)逻辑结构
(09)函数
(10)对象
10.对象——object
    01.对象属于引用类型数据
        对象:是一组属性(property)和(method)方法的集合
                 一台电脑:属性有颜色,尺寸,品牌,内存大小...方法有看视频,上网,敲代码...
                 一辆汽车:属性有颜色,长度,品牌,空间大小...方法有代步,运输...
                 比较形象的一句比喻就是:万物皆对象
        1)JS中的对象
            内置对象:JS提供的,例如日期,运算等
            宿主对象:根据不同的执行环境划分的,DOM对象的宿主是浏览器,http对象的宿主是node.js
            自定义对象:自己创建的对象,自定义对象包含
                              对象字面量
                              内置构造函数
                              自定义构造函数
        2)对象字面量创造空对象
             使用大括号{ }创建空对象
             多组属性之间用逗号隔开
             属性名中的引号可加可不加,如果含有特殊字符必须加

    //创建自定义对象
    //使用对象字面量创建对象,对象字面量是{ },字面量的意思就是字面上你写的是什么值,打印的就是什么值
    var person={
        ename:"小小",
        sex:"男",
        age:"78",
    }
    console.log(person);//{ename: "小小", sex: "男", age: "78"}
    //创建一个手机对象,包含颜色,尺寸,品牌
    var phone={
        color:"黑色",
        size:5.9,
        brand:"华为",
        "made-in":"china",
    };
    console.log(phone);//{color: "黑色", size: 5.9, brand: "华为", made-in: "china"}

        3)访问对象中的属性
             对象.属性名
             对象['属性名']
             如果访问的属性名不存在,返回undefined

    //访问对象中的属性
    var phone={
    color:"黑色",
    size:5.9,
    brand:"华为",
    "made-in":"china",
    };
    console.log(phone.size);//5.9
    console.log(phone['made-in']);//china
    console.log(phone['size']);//5.9
    //修改属性值
    phone.color="白色";
    console.log(phone.color);//白色
    //添加不存在的属性
    console.log(phone.num);//不存在的  默认是undefinde
    phone.num='P30';
    console.log(phone.num);//P30

        4)内置构造函数由new创建一个对象
             new Object() 创建一个空对象
             需要单独为对象添加每一个属性

    //使用内置函数创建对象
    var car=new Object();
    //添加属性
    car.brand='五菱宏光';
    car.color='白色';
    car['price']=60000;
    console.log(car);//{brand: "五菱宏光", color: "白色", price: 60000}

        5)遍历对象中的属性
             for (var key in 对象){//key代表对象中的每个属性名
             对象[key] //通过属性名获取对应属性值
             }

    //遍历对象中的属性
    var phone={
        color:'黑色',
        brand:'华为',
        num:'p30',
        size:5.9,
    }
    for (var key in phone ){
        //key 每个属性名
        console.log(key,phone[key])//color 黑色 brand 华为 num p30 size 5.9
    }
    
    //练习:创建对象,包含若干个成绩,遍历对象属性,计算总成绩
    var score={
        math:89,
        chinese:80,
        english:92,
    };
    var sum=0;
    for (var key in score ){
        //console.log(key,score[key]);
        //把每个成绩加到一起
        sum+=score[key]; 
    }
    console.log(sum);//261

    02.函数对象
         1)判断对象中是否含有某个属性,属性后面对应的是值
             对象.属性名===undefined               true—>不存在 false—>存在
             对象.hasOwnProperty("属性名")       true—>存在    false—>不存在
             "属性名" in 对象                            true—>存在    false—>不存在

    //判断对象中是否含有某个属性
    var person={
        ename:"晓丽",
        sex:'女',
        age:28
    }
    console.log(person.eid);//undefined
    console.log(person.eid===undefined);//true 属性值和undefined比较结果为true,说明不存在
    console.log( person.hasOwnProperty("age"));//true
    console.log("sex" in person);//true

    //练习:判断是否含有salary,如果没有,添加该属性,并设置值为8000.
    var person={
        ename:"晓丽",
        sex:'女',
        age:28
    }
    //判断方法一
    if (!person.hasOwnProperty("salary")){
        person.salary=8000;
    }
    console.log(person);
    //判断方法二
    if (!("salary" in person)){
        person.salary=8000;
    }
    console.log(person);

         2)对象中的方法——method,方法后面对应的是function(){}
              var person={
              ename:"oksana";
              say:function(){
                   this.name//访问当前对象的属性名,this指代当前所在的对象
                   }
              }
              person.say() //调用对象中的方法

    // 对象中的方法
    var person={
      ename:"oksana",//成员属性
      sex:"女",
      say:function (){//把一个匿名函数赋值给say——成员方法
      console.log("hello,我叫"+this.ename);
      } 
    }
    //调用对象中的方法
    person.say();

         3)对象的存储
             原始类型存储——变量中存储的是值,每个变量的内存空间都是单独的,暂时可理解为栈内存
             引用类型存储——变量中存储的是一个引用地址,暂时可以理解为堆内存
                                     引用类型数据一旦没有被地址所引用,就会销毁,通常使用null用于手动销毁或是释放引用类型

                                     

    //原始类型储存
    var a=1;
    var b=a;//拷贝a的值,赋值给b,占单独的内存空间
    //改变a的值
    a=2;
    console.log(a,b);//b=1,b占单独的内存空间,所以a值改变并不影响b值

    //引用类型的存储
    var person1={
      ename:"oksana",
      age:18,
    }
    //把person1对象赋值给了person2
    var person2=person1;//此时person2引用的是person1的地址
    //person2改变属性值
    person2.ename="小小";//实际是用过引用的地址,修改了person1的值
    console.log(person1);//{ename: "小小", age: 18}
    console.log(person2);//{ename: "小小", age: 18}
    //person1也要改变属性值
    person1.age=48;//同样是通过引用的地址,修改了里面的内容,但是地址不变
    console.log(person2);//{ename: "小小", age: 48}
    console.log(person1);//{ename: "小小", age: 48}
    //引用类型数据一旦没有被地址所引用,就会销毁
    //null用于手动销毁或是释放引用类型,
    person1=null;//person1不在引用对象
    person2=null;//person2不在引用对象

    03.数组对象——array
        数组是有多个元素组成的集合,每个元素就是一个数据
        1)数组字面量
            [元素1,元素2,...]

    //数组字面量,写什么值输出就是什么值
    var citys=['北京','上海','杭州','广州','深圳']
    console.log(citys);//["北京", "上海", "杭州", "广州", "深圳"]

        2)访问数组中的元素
             数组[下标] 下标从0开始,不存在的元素返回undefined

    //访问数组中的元素
    var markets=['pork','beef','pear','apple','water']
    //访问某个元素,第一个下标是从0开始
    console.log(markets[1]);//打印下标为1的位置的值
    console.log(markets[5]);//打印下标为5的位置的值,下标5是没有值的,所以返回undefined
    //修改元素
    markets[0]='dog';//给0下标重新赋值
    //添加元素
    markets[7]='cat';//给下标7赋值
    console.log(markets);//["dog", "beef", "pear", "apple", "water", empty × 2, "cat"]

        3)内置构造函数——new Array
             new Array(元素1,元素2...)
             new Array(3) 初始化元素个数为3,可以添加更多个元素

    //内置构造函数
    var laptop=new Array('ThinkPad','小米','戴尔');
    var course=new Array(3);
    course[1]='数学';
    course[2]='语文';
    course[3]='英语';
    console.log(laptop);//["ThinkPad", "小米", "戴尔"]
    console.log(course);//[empty, "数学", "语文", "英语"],第一位是空,因为没有在0下标的位置添加值

        4)数组长度——length
             数组.length——获取数组中元素的个数
             在数组的末尾添加元素
             数组[数组.length]=值;

    //数组的长度
    var num=new Array(5);
    num[0]='小前锋';
    num[1]='中锋';
    num[2]='得分后卫';
    num[3]='控球后卫';
    num[4]='前锋';
    //使用长度在数组的末尾添加元素
    num[num.length]='教练';
    num[num.length]='啦啦队';
    console.log(num);// ["小前锋", "中锋", "得分后卫", "控球后卫", "前锋", "教练", "啦啦队"]
    //数组的长度
    console.log(num.length);//7

        5)数组分类
             分为关联数组和索引数组
             索引数组是以0以上的整数作为下标
             关联数组以字符串作为下标,只能单独的添加元素

    //数组分类
    //索引数组
    var score=[23,58,100,98];
    console.log(score);//[23, 58, 100, 98]
    var countrys=new Array();
    countrys[countrys.length]='China';
    countrys[countrys.length]='RS.';
    countrys[countrys.length]='USA';
    console.log(countrys);// ["China", "RS.", "USA"],索引数组的下标是整数,所以也可看作输出为[0:"China",1:"RS.",2:"USA"]
    
    //关联数组,以字符串作为下标
    var emp=[];
    emp['ename']='小然';
    emp['sex']='男';
    console.log(emp);//[ename: "小然", sex: "男"],ename,sex就是下标名称

        6)遍历数组——for-in
             for-in遍历
             for(var key in数组){
             //key代表下标
             //数组[key],下标对应的元素
             }//既可以遍历关联数组,也可以遍历索引数组

    //for-in 遍历数组
    var emp=[];
    emp['ename']='小然';
    emp['sex']='男';
    console.log(emp);//[ename: "小然", sex: "男"]
    //遍历关联数组
    for (var key in emp ){
      console.log(key,emp[key]);//ename 小然,sex 男
    }

    //遍历索引数据
    var score=[78,42,59,67];
    var sum=0;
      for (var key in score ){
        console.log(key,score[key]);//这里会打印每个下标的名称和值
        sum+=score[key];
    }
    console.log(sum/score.length);

             for循环遍历
             for(var i=0;i<数组.length;i++){
             //i代表下标
             //数组[i],下标对应的元素
             }//只能遍历索引数组,后续有其他的遍历关联数组的方式

    //循环遍历
    //使用循环获取数组中的元素
    var score=[23,58,100,98];
    var sum=0;
      for (var i=0 ;i<score.length ;i++ ){
      console.log(i,score[i]); 
      sum+=score[i];
      }
    console.log(sum/i);

    //练习:创建数组,包含多个国家,把所有的中国改为CHINA
    var country=['中国','法国','德国','爱尔兰','芬兰','中国','中国'];
      for (var i=0;i<=country.length ;i++ ){
        if (country[i]==='中国'){
          country[i]='china';
        }
      }
    console.log(country);

        7)数组API——Array-API(方法)
             API 应用程序编程接口,预定义好的一些方法或者函数
             pop() 删除数组末尾的元素,返回删除的元素

    //删除数组中的最后一个元素——pop()
    var arr=['html','css','js','nodejs','ajax','vue','react'];
    console.log(arr.pop());//返回的是删除的数据

             push() 在数组的末尾添加元素,返回数组的长度

    //在数组的末尾添加元素——push() 
    var arr=['html','css','js','nodejs','ajax','vue','react'];
    console.log(arr.push('angular'));//返回的是数组的长度

             shift() 删除数组开头的元素,返回删除的元素

    //删除开头的元素——shift()
    var arr=['html','css','js','nodejs','ajax','vue','react'];
    console.log(arr.shift());//返回删除的元素

             unshift() 在数组的开头添加元素,返回数组的长度

    //在开头添加元素——unshift()
    var arr=['html','css','js','nodejs','ajax','vue','react'];
    console.log(arr.unshift('js'));//返回的是数组长度

             join('-') 将数组中的元素按照指定的字符组合成字符串,默认是逗号,

    //把数组转为字符串带有特殊的分隔符号——join('/')
    var arr=['html','css','js','nodejs','ajax','vue','react'];
    console.log(arr.join());//html,css,js,nodejs,ajax,vue,react,默认符号是「,」
    console.log(arr.join('/'));//html/css/js/nodejs/ajax/vue/react
    console.log(arr.join(''));//htmlcssjsnodejsajaxvuereact

             sort() 对数组元素排序,默认是按照unicode码从小到大排序
             sort(function(a,b){//对数字数组排序
             return a-b;//按照数字从小到大排序
             // return b-a;//按照数字从大到小排序
             });

    //对数组元素排序——sort()
    var arr=[23,9,78,6,45];
    console.log(arr.sort());//默认按照unicode码从小到大;
    //按照数字大小排序,从大到小;
    console.log(arr.sort(function(a,b){
      // return a-b;//从小到大
      return b-a;//从大到小
    }));
    var arr=['html','css','js','nodejs','ajax','vue','react'];
    console.log(arr.sort());//默认是按照unicode码从小到大排序

             reverse() 翻转数据

    //翻转数组元素——reverse()
    var arr=['html','css','js','nodejs','ajax','vue','react'];
    console.log(arr.reverse());//把数组按照从后到前重新排序

             toString() 将数组中的元素按照逗号组合成字符串

    //把数组转为字符串——toString()
    var arr=['html','css','js','nodejs','ajax','vue','react'];
    console.log(arr.toString());//html,css,js,nodejs,ajax,vue,react

             concat(arr1,arr2) 拼接多个数组

    //拼接多个数组——concat(arr1,arr2)
    var arr=['html'];
    var arr1=['css','js','nodejs'];
    var arr2=['ajax','vue','react'];
    console.log(arr.concat(arr1,arr2));// ["html", "css", "js", "nodejs", "ajax", "vue", "react"]

             slice(start,end)
             截取数组中的元素,start是开始的下标,end是结束的下标,不包含end本身,如果是负数,表示倒数,end为空截取到最后。返回为截取的数组。

    //截取元素——slice(start,end)
    var arr=['html','css','js','nodejs','ajax','vue','react'];
    console.log(arr.slice(0,2));//包括开始的下标,但是不包括结束的下标
    console.log(arr);
    console.log(arr.slice(0));//开始结束的下标,到最后
    console.log(arr.slice(-2));//开始结束的下标,到最后
    console.log(arr.slice());//全部截取
    console.log(arr.slice(3,-1));//从开始下标截取到倒数第一位,但不包括倒数第一个
    console.log(arr.slice(-2,-1));//从倒数第二个开始截取,但不包括结束下标

             splice(start,count,value1,value2...)
             删除数组中的元素,start是开始下标,count删除长度,value删除后补充的元素;count为空删除到最后,start为负数表示倒数;返回删除的元素,原数组会发生变化。

    //删除数组中的元素——splice(start,count,value1,value2...)
    var arr=['html','css','js','nodejs','ajax','vue','react'];
    console.log(arr.splice(1));//开始的下标到最后,返回的是删除的数组
    console.log(arr);
    var arr=['html','css','js','nodejs','ajax','vue','react'];
    console.log(arr.splice(1,2));//开始的下标到最后,删除的长度,返回的是删除的数组
    console.log(arr);
    var arr=['html','css','js','nodejs','ajax','vue','react'];
    console.log(arr.splice(-2,1));//删除的是开始下标,和长度,返回的是删除的数组
    console.log(arr);
    var arr=['html','css','js','nodejs','ajax','vue','react'];
    console.log(arr.splice(2,1,'oksana','html5'));//删除开始,长度,补充的的元素,返回的是删除的数组
    console.log(arr);
    var arr=['html','css','js','nodejs','ajax','vue','react'];
    console.log(arr.splice(2,0,'oksana','html5'))//0代表一个元素都不删除,直接插入后面的数据,返回的是删除的数组
    console.log(arr);

       8)二维数组
           数组中的每个元素也是数组
               var arr=[ [],[],[]…]
           访问二维数组中的数据
               arr[下标][下标] 通过两组下标访

   // 二维数组
   var city=[
      ['海淀区','西城区','东城区','丰台区'],
      ['广州','深圳','惠州'],
      ['济南','青岛']
   ];
   console.log(city[1][1]);//深圳  通过两组下标访
   console.log(city[2][0]);//济南  通过两组下标访

 

06.JS对象

全文结束