JavaScript对象

一、什么是对象？

​对象是一种数据类型（复合数据类型），用来存储数据。数据格式（key:value）。对象是属性和行为的结合体

​ 1. 属性：表示对象的静态特征。使用方式为 “ 对象名.属性名”

​ 2. 方法(函数)：表示对象的行为（动态特征）。使用方式为“对象名.方法名（【参数】）”

二、对象的创建方式

​ 1. 使用字面量创建：{ }

​ let / var / const 对象名 = { }

语法：

let 对象名 = {

​ 属性名：属性值

​ 方法名：function(【参数】){

​ 函数体语句

​ }

​ }

//创建一个对象
        let student = {
            name: '马云',
            sex: '男',
            eat:function(){
                console.log('马云在吃包子')
            },
            sleep: function(){
                console.log('马云在睡觉')
            }
        }
        //对象属性和方法的使用
        console.log('姓名：'+student.name) 
        console.log('性别：'+student.sex)
        student.eat()
        student.sleep()

说明：

 （1）保存数据的格式：键: 值（key：value） —— 称为“键值对”

​ （2）在程序中可以创建空对象：对象名 = { }

​ （3）给空对象添加属性、方法

2. 通过Object来创建对象：

​ （1）Object对象：是JavaScript中所有对象的基类

​ （2）创建空对象：new Object()

语法：

a、let 对象名 = new Object()

​ 对象名.属性名 = 属性值

​ 对象名.方法名 = function(【参数】){

​ 函数体语句

​ }

var person = new Object();
person.name = "孙悟空";
person.age = 18;
console.log(person);

​ b、let 对象名 = new Object({

​ 属性名：属性值

​ 方法名：function(【参数】){

​ 函数体语句

​ }

​ })

var person = {
    name: "孙悟空",
    age: 18
};
console.log(person);

3. 利用构造函数创建对象

​ （1）构造函数：是一个函数（定义方式和普通函数的定义方式一样的）

​ function 构造函数名(【参数】){

​ this.属性名 = 属性值

​ this.方法名 = function(【参数】){

​ 方法体语句

​ }

​ }

​ 建议：构造方法名的首字母要大写，使用new关键字来调用

​ 定义构造方法就是画图纸的过程，通过构造方法创建对象（new 构造方法名()）就是根据图纸生成对象的过程

​ （2）通过构造方法创建对象：new 构造方法名(【参数】)

​ （3）对象使用属性和方法：

​ 对象名.属性

​ 对象名.方法名(【参数】)

// 使用构造函数来创建对象
function Person(name, age) {
    // 设置对象的属性
    this.name = name;
    this.age = age;
    // 设置对象的方法
    this.sayName = function () {
        console.log(this.name);
    };
}

var person1 = new Person("孙悟空", 18);
var person2 = new Person("猪八戒", 19);
var person3 = new Person("沙和尚", 20);

console.log(person1);
console.log(person2);
console.log(person3);

强调：this代表的是由构造方法创建的对象

• 当以函数的形式调用时，this是window
• 当以方法的形式调用时，谁调用方法this就是谁
• 当以构造函数的形式调用时，this就是新创建的那个对象

（4）构造函数是怎么执行创建对象的过程呢？

         1）调用构造函数，它会立刻创建一个新的对象

         2）将新建的对象设置为函数中this，在构造函数中可以使用this来引用新建的对象

         3）逐行执行函数中的代码

         4）将新建的对象作为返回值返回

4. 删除属性

delete 对象.属性名

三、遍历对象的属性和方法

枚举遍历对象中的属性，可以使用for … in语句循环，对象中有几个属性，循环体就会执行几次

语法格式

for (var 变量 in 对象) {

}

对象访问属性或方法的方式：对象名[ ‘属性名或方法名’ ]

四、in运算符：判断对象中是否存在某个属性或方法

 console.log('show' in people) //判断people对象中是否有id这个成员

五、对象数组

数组中存放的是对象（数组中的每个元素都是对象）

定义数组：将s1~s4对象存入该数组
        let arr  = [s1,s2,s3,s4] //arr就是对象数组
        let temp = [s1,s2,s3,s4]
        console.log(temp)
        //4.对数组中的对象按总成绩降序排列
        for(let i=0;i<arr.length;i++){
            for(let j=0;j<arr.length-1;j++){
                if(arr[j].getSum() < arr[j+1].getSum()){
                    let t = arr[j]
                    arr[j] = arr[j+1]
                    arr[j+1] = t
                }
            }
        }
        console.log(arr)

六、JavaScript的内置对象

可以直接使用的对象（不需要使用字面量、Object、构造函数创建的对象，JavaScript已经定义好的对象）

1. 使用MDN（web开发文档的网站）查询资料：MDN 是 Mozilla基金会的开发者网络平台。提供了大量关于各种HTML、CSS和JavaScript功能的开放、详细的文档，以及广泛的Web API参考资料。（https://developer.mozilla.org/zh-CN/）

​ 2. Math对象：是一个内置对象，用于数学运算的。不是一个函数对象（通过构造函数创建的对象称为函数对象），在创建Math对象不能使用new运算符（即不能 new Math()）,它的属性和方法在使用时采用:

​ Math.属性名

​ Math.方法名（【参数】）

​ （1）属性：

​ Math.PI ：表示圆周率

​ （2）方法：

​ Math.abs(x) ：返回参数x的绝对值

​ Math.floor(x)：返回小于等于形参x的最大整数。向下取整

​ Math.ceil(x)：返回大于等于形参x的最小整数。向上取整

​ Math.max(x,y,z…)：返回所有参数的最大值

​ Math.min(x,y,z…)：返回所有参数的最小值

​ Math.pow(x,y)：返回x的y次方

​ Math.sqrt(x)：返回x的算术平方根

​ Math.round(x)：取整，x四舍五入后的整数

​ Math.random()：返回0.0~1.0之间的随机数（不包含1.0）

​ Math.trunc()：给定数字的整数部分

/*固定值*/
console.log("PI = " + Math.PI);
console.log("E  = " + Math.E);
console.log("===============");
/*正数*/
console.log(Math.abs(1));        //可以用来计算一个数的绝对值
console.log(Math.ceil(1.1));     //可以对一个数进行向上取整，小数位只有有值就自动进1
console.log(Math.floor(1.99));   //可以对一个数进行向下取整，小数部分会被舍掉
console.log(Math.round(1.4));    //可以对一个数进行四舍五入取整
console.log("===============");
/*负数*/
console.log(Math.abs(-1));       //可以用来计算一个数的绝对值
console.log(Math.ceil(-1.1));    //可以对一个数进行向上取整，小数部分会被舍掉
console.log(Math.floor(-1.99));  //可以对一个数进行向下取整，小数位只有有值就自动进1
console.log(Math.round(-1.4));   //可以对一个数进行四舍五入取整
console.log("===============");
/*随机数*/
//Math.random()：可以用来生成一个0-1之间的随机数
//生成一个0-x之间的随机数：Math.round(Math.random()*x)
//生成一个x-y之间的随机数：Math.round(Math.random()*(y-x)+x)
console.log(Math.round(Math.random() * 10));            //生成一个0-10之间的随机数
console.log(Math.round(Math.random() * (10 - 1) + 1));  //生成一个1-10之间的随机数
console.log("===============");
/*数学运算*/
console.log(Math.pow(12, 3));   //Math.pow(x,y)：返回x的y次幂
console.log(Math.sqrt(4));      //Math.sqrt(x) ：返回x的平方根

3. Date对象

一个函数对象，使用new 运算符创建对象

（1）构造函数：

​ a、无参的构造函数：new Date() —->使用的日期格式是月日年

​ b、传入年月日、时分秒：new Date（年，月，日，时，分，秒） —->月份值应该在0~11之间，0表示1月，11表示12月

​ c、传入字符串表示日期和时间：new Date(‘字符串’)

​ d、传入整数：new Date(整数) —->整数表示毫秒数

​ （2）其他函数：

​ a、getFullYear()：获取年份（4位）

​ b、getMonth()：获取月份（0~11）

​ c、getDate()：获取日期（月份中的某一天，1~31）

​ d、getDay()：获取星期（0~6,0表示星期天）

​ e、getHours()：获取小时数

​ f、getMinutes（）：获取分钟数

​ g、getTime()：获取1970年1月1日0时0分0秒到当前日期时间之间的毫秒数

​ h、toLocaleDateString()：返回该日期对象日期部分的字符串（即将年月日转换为字符串）

​ i、toLocaleString()：返回该日期对象的字符串（即将日期对象转换为字符串）

​ j、toLocaleTimeString()：返回该日期对象时间部分的字符串（将时分秒转换为字符串）

​ k、toTimeString()：以人类易读形式返回一个日期对象时间部分的字符串

var date = new Date();
console.log(date);

console.log(date.getFullYear());//获取当前日期对象的年份(四位数字年份)
console.log(date.getMonth());//获取当前日期对象的月份(0 ~ 11)
console.log(date.getDate());//获取当前日期对象的日数(1 ~ 31)
console.log(date.getHours());//获取当前日期对象的小时(0 ~ 23)
console.log(date.getMinutes());//获取当前日期对象的分钟(0 ~ 59)
console.log(date.getSeconds());//获取当前日期对象的秒钟(0 ~ 59)
console.log(date.getMilliseconds());//获取当前日期对象的毫秒(0 ~ 999)

练习   倒计时（2023年元旦的倒计时），格式是：距离2023年元旦还有 X 天 X 时 X 分 X 秒

​ （1）创建两个日期对象：当前日期对象、创建2023-1-1日期对象

​ （2）计算它们之间相差的毫秒数

​ （3）将该毫秒数转换成天、时、分、秒

//1.创建日期对象
        let end = new Date('2023-1-1') 
        let start = new Date()
        //2.计算得到两个日期对象之间的毫秒数之差,转换成秒钟
        let times = (end - start)/1000
        //3.计算得到天、时、分、秒
        let d = parseInt(times/60/60/24)  //转换成天数
            d = d < 10 ? ('0'+d):d //如果天数是个位数，则在前面补0
        let h = parseInt(times/60/60%24)
            h = h < 10? ('0'+h):h
        let m = parseInt(times/60%60)
            m = m < 10? ('0'+m):m
        let s = parseInt(times%60)
            s = s < 10? ('0'+s):s
        let info = `距离2023年元旦还有 ${d} 天 ${h} 时 ${m} 分 ${s} 秒`  
        console.log(info)

4. String对象

字符串。用单引号（’’) 或双引号（””）括起来的字符序列

字符串属性

1）length —— 表示字符串的长度（字符串中字符的个数）
  字符串对象名.length

2）constructor——返回创建字符串对象的原型函数
  字符串对象名.constructor

字符编码：

ASCII码：是美国做的字符编码 （’a’:97…..) ——— 只支持英文字符。表示一个字符使用1个字节(byte),即8个二进制位(bit)

​ Unicode码：国际标准化组织做的一套编码。表示一个字符使用2个字节,即16个二进制位(bit) —— 支持中文

​ ISO-8859-1码：不支持中文

​ GBK：支持中文

​ GB2312：支持简体中文

 （1）charAt( index )：返回字符串中index位置上的字符。参数index代表索引值（下标），若没有找到则返回空

​ （2）charCodeAt(index)：返回字符串中index位置上的字符的Unicode编码

 （3）concat(字符串)：将两个及两个以上的字符串进行连接

​ （4）endsWith(字符串)：判断字符串是否是以给定的子串结尾。是则返回true，不是则返回false

​ （5）indexOf(子串)：返回子串在字符串中首次出现的位置（下标）。若返回-1，表示没有找到子串

​ （6）lastIndexOf(子串)：返回子串在字符串中最后出现的位置（下标）

​ （7）includes(子串)：查找字符串中是否包含指定的子串。若包含返回true，不包含返回false

​ （8）startsWith(子串)：判断字符串是否以给定子串开头。是则返回true，不是则返回false

​ （9）split(分隔字符)：将字符串分割成字符串数组，一个字符串作为参数，将会根据该字符串去拆分数组

​ （10）replace(oldStr，newStr)：在字符中查找oldStr第一次出现的位置，并用newStr替换它

​ （11）substr(start，length)：截取字符串中从start开始的连续length个字符。当参数length省略时，截取从start开始到串末尾的所有字符

​ （12）substring(start，end)：截取start到end之间的子串，不包含end

            slice()：从字符串中截取指定的内容，不会影响原字符串，而是将截取到内容返回

​ （13）trim()：去掉字符串两端的空白字符

​ （14）trimEnd()：去掉字符串末尾的空白字符

​ （15）trimStart()：去掉字符串前面的空白字符

​ （16）toLowerCase()：将字符串中的所有字母转换为小写字母并返回

​ （17）toUpperCase()：将字符串中的所有字母转换为大写字母并返回

​ （18）toString()：将字符串对象转换成字符串

字符串的不可变性：指当一个字符串被定义后，它的内容是不变的。虽然通过调用相关函数看似改变了串的内容，实际是在内存中新开辟了一个空间存放新的串。

练习    统计字符串中出现最多的字符和次数

let str = "abcoefooaa";
        let k = {}  //定义一个空对象：用于保存字符串中字符及统计该字符出现的次数
        for(let i=0;i<str.length;i++){
            let chars = str.charAt(i)  //将下标为i的字符取出赋给变量chars
            if(k[chars]){ //若对象k中存在属性chars(chars变量代表某个字符)
                k[chars]++
            }else{  //对象k中不存在属性chars(chars变量代表某个字符)
                k[chars] = 1
            }
        }
        //遍历对象的属性：for...in循环
        let max = 0
        let ch = ''
        for(let t in k){ //t='a',k[t]<=>k['a']<=>k.'a'  == 1
            if(k[t]>max){
                max = k[t] //max = a
                ch = t //ch = 'a'
            }
        }
        console.log(`出现次数最多的字母是${ ch } ：${ max }`)