JavaScript学习笔记(六)-JavaScript 对象

1. 对象

1. 什么是对象？

现实生活中：万物皆为对象

对象是一个 一个具体的事物 ,看得见摸得着的实物

例如：

一本书、一辆汽车、一个人 可以是 “对象”

一个数据库、一个网页、一个与远程服务器的连接也可以是 “对象”

在 JavaScript 中，对象是一组无序的相关属性和方法的集合，所有的事物都是对象，例如字符串、数值、数组、函数等

对象是由属性和方法组成的

• 属性：事物的**特征，在对象中用属性**来表示（常用名词）
• 方法：事物的**行为，在对象中用方法**来表示（常用动词）

2. 为什么需要对象

保存一个值时，可以使用**变量，保存多个值（一组值）时，可以使用数组。**如果要保存一个人的完整信息呢？

例如：将 “张三疯” 的个人信息保存在数组中的方式为：

var arr = ['张三疯', '男', 18, 168];

JS 中的对象表达结构更清晰，更强大。如下：

张三疯.姓名 = '张三疯';
张三疯.性别 = '男';
张三疯.年龄 = '18';
张三疯.身高 = '168';

preson.name = '张三疯';
preson.sex = '男';
preson.age = '18';
preson.height = '168';

2. 创建对象

在 JavaScript 中，可以采用三种方式创建对象（object）

• 利用字面量创建对象
• 利用 new Object 创建对象
• 利用构造函数创建对象

1. 利用字面量创建对象

对象字面量：就是花括号 {} 里面包含了表达这个具体事物（对象）的属性和方法

var obj = {
  uname: '张三疯',
  age: 18,
  sex: '男',
  sayHi: function () {
    alert('hi~');
  },
};

1. 里面的属性或者方法采取键值对的形式 键：属性名 ：值：属性值
2. 多个属性或者方法中间用逗号隔开
3. 方法冒号后面跟的是一个匿名函数

调用对象：

// 调用对象的属性，采取 对象名.属性名
console.log(obj.uname);
// 调用对象还有一种方法 对象名['属性名']
console.log(obj['age']);
// 调用对象的方法 sayHi   对象名.方法名()
obj.sayHi();

变量、属性、函数、方法总结

• 变量：单独声明赋值，单独存在
• 属性：对象里面的变量称为属性，不需要声明，用来描述该对象的特征
• 函数：单独存在的，通过 “函数名()” 的方式调用
• 方法：对象里面的函数称为方法，方法不需要声明，使用 “对象.方法名()” 的方式调用，方法用来描述该对象的行为和功能

2. 利用 new Object 创建对象

利用等号 = 赋值的方法，添加对象的属性和方法

每个属性和方法之间用 分号结束

var obj = new Object(); // 创建了一个空的对象
obj.uname = '张三疯';
obj.age = 18;
obj.sex = '男';
obj.sayHi = function () {
  alert('hi~');
};

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

构造函数：是一种特殊的函数，主要用来初始化对象，即为对象成员变量赋初始值，它经常与 new 运算符一起使用

可以把对象中一些公共的属性和方法抽取出来，然后封装到这个函数里面

语法格式：

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

function Star(uname, age, sex) {
  this.name = uname;
  this.age = age;
  this.sex = sex;
  this.say = function (say) {
    alert(say);
  };
}
var zsf = new Star('张三疯', 18, '男');
console.log(zsf.name); // 输出结果为 张三疯
console.log(zsf.age); // 输出结果为 18
zsf.say('hi~');
var ls = new Star('李四', 19, '男');
console.log(ls.name); // 输出结果为 李四
console.log(ls.age); // 输出结果为 19
ls.say('你好');

• 构造函数名字首字母要大写
• 构造函数不需要 return 就可以返回结果
• 调用构造函数必须使用 new
• 只要 new Star() 调用函数就能创建一个对象
• 属性和方法前面必须加 this

4. 构造函数和对象

构造函数，如 Stars()，抽取了对象的公共部分，封装到函数里面，泛指某一大类（class）

创建对象，如 new Stars()，特指某一个，通过 new 关键字创建对象的过程称为对象实例化

3. new 关键字

new 在执行时会做四件事：

1. 在内存中创建一个新的空对象
2. 让 this 指向这个新的对象
3. 执行构造函数里面的代码，给这个新对象添加属性和方法
4. 返回这个新对象（所以构造函数里面不需要 return）

4. 遍历对象属性

for…in 语句用于对数组或者对象的属性进行循环操作

var obj = {
  uname: '张三疯',
  age: 18,
  sex: '男',
  sayHi: function () {
    alert('hi~');
  },
};

for (var k in obj) {
  console.log(k); // k 变量 输出，得到的是 属性名
  console.log(obj[k]); // obj[k] 得到的是 属性值
}

5. 内置对象

• JavaScript 中的对象分为 3 种：自定义对象、内置对象、浏览器对象
• 内置对象 就是指 JS 语言自带的一些对象，这些对象供开发者使用，并提供了一些常用的或是最基本而必要的功能（属性和方法）
• 内置对象最大的有点就是帮助我们快速开发
• JavaScript 提供了多个内置对象：Math、Date、Array、String 等

1. Math 对象

Math 是一个内置对象，它拥有一些数学常数属性和数学函数方法。Math 不是一个函数对象。

与其他全局对象不同的是，Math 不是一个构造器。Math 的所有属性与方法都是静态的。引用圆周率的写法是 Math.PI，调用正余弦函数的写法是 Math.sin(x)，x 是要传入的参数。Math 的常量是使用 JavaScript 中的全精度浮点数来定义的。

MDN 文档

Math.PI; // 圆周率
Math.floor(); // 向下取整
Math.ceil(); // 向上取整
Math.round(); // 四舍五入 就近取整
Math.abs(); // 取绝对值
Math.max(); // 取最大值
Math.min(); // 取最小值

console.log(Math.PI); // 返回结果 3.141592653589793
console.log(Math.max(1, 2, 3, 4, 5, 6, 7, 8, 9)); // 返回结果 9
console.log(Math.min(1, 2, 3, 4, 5, 6, 7, 8, 9)); // 返回结果 1

1. 绝对值

console.log(Math.abs(1)); // 1
console.log(Math.abs(-1)); // 1
console.log(Math.abs('1')); // 1 隐式转换,会把字符串型转换为数字型
console.log(Math.abs('Hello')); // NaN

2. 取整

// Math.floor 向下取整
console.log(Math.floor(1.1)); // 1
console.log(Math.floor(1.9)); // 1
// Math.ceil 向上取整
console.log(Math.ceil(1.1)); // 2
console.log(Math.ceil(1.9)); // 2
// Math.round 四舍五入
console.log(Math.round(1.1)); // 1
console.log(Math.round(1.5)); // 2
console.log(Math.round(1.9)); // 2
console.log(Math.round(-1.1)); // -1
console.log(Math.round(-1.5)); // -1

3. 利用函数封装数学对象

var myMath = {
  PI: 3.141592653,
  max: function () {
    var max = arguments[0];
    for (var i = 1; i < arguments.length; i++) {
      if (arguments[i] > max) {
        max = arguments[i];
      }
    }
    return max;
  },
  min: function () {
    var min = arguments[0];
    for (var i = 1; i < arguments.length; i++) {
      if (arguments[i] < min) {
        min = arguments[i];
      }
    }
    return min;
  },
};
console.log(myMath.PI); // 返回结果 3.141592653
console.log(myMath.max(10, 20, 30)); // 返回结果 30
console.log(myMath.min(10, 20, 30)); // 返回结果 10

4. 随机数 random()

Math.random() 函数返回一个浮点数, 伪随机数在范围从0 到小于1，也就是说，从 0（包括 0）往上，但是不包括 1（排除 1），然后您可以缩放到所需的范围。实现将初始种子选择到随机数生成算法;它不能被用户选择或重置。

console.log(Math.random()); // 随机返回一个小数

1. 得到两个数之间的随机整数(包含这两个整数)

function getRandom(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}
console.log(getRandom(1, 10)); // 随机返回一个1 - 10 之间的整数，包含 1 - 10

2. 随机点名

var names = ['张三', '李四', '小黄', '小红', '小黑', '小白'];
function getRandom(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}
console.log(names[getRandom(0, names.length - 1)]); // 随机返回一个姓名

3. 猜数字游戏

程序随机生成一个 1 - 10 之间的数字，并让用户输入一个数字

• 如果大于该数字，提示：数字大了，继续猜
• 如果小于该数字，提示：数字小了，继续猜
• 如果等于该数字，提示：猜对了，结束程序

var op = prompt("猜猜答案是数字几");
for (var i = 1; i <= max; i++) {
    if (op < getRandom(1, 10)) {
        alert('小了');
    } else if (op > getRandom(1, 10)) {
        alert('大了');
    } else {
        alert(猜对啦，游戏结束);
        break;
    }
}
function getRandom(min, max) {
    return Math.floor(Math.random() * (max - min + 1)) + min;
}

2. Date 日期对象

Date() 日期对象 是一个构造函数，用于处理日期和时间

必须使用 new 来创建

// 使用 Date() 如果没有参数，返回系统当前的时间
var date = new Date();
console.log(date); // 返回系统当前时间

1. Date() 构造函数的参数

参数常用的写法

• 数字型：2021, 7, 29
• 字符串型：’2021-7-29 00:00:00’

如果括号里面有时间，就返回参数里面的时间

例如 日期格式字符串为 ‘2021-7-29’，可以写成 new Date(‘2021-7-29’)，或者 new Date(‘2021/7/29’)

var date1 = new Date(2021, 7, 29);
console.log(date1); // 返回的是 八月 而不是 七月
var date2 = new Date('2021-7-29 00:00:00');
console.log(date2);

2. 日期格式化

方法名	说明	代码
getFullYear()	获取当年	dObj.getFullYear()
getMonth()	获取当月(0 - 11)	dObj.getMonth()
getDate()	获取当天日期	dObj.getDate()
getDay()	获取星期几( 周日(0)到周六(6) )	dObj.getDay()
getHours()	获取当前小时	dObj.getHours()
getMinutes()	获取当前分钟	dObj.getMinutes()
getSeconds()	获取当前秒钟	dObj.getSeconds()

1. 格式化日期 - 年月日

var date = new Date(); // 创建一个日期对象
var year = date.getFullYear(); // 当前年份
var month = date.getMonth() + 1; // 当前月份，月份从 0 开始，返回的月份小一个月，所以要 + 1
var dates = date.getDate(); // 当前日期 几号
// 星期返回的是数字，所以创建一个数组通过索引号访问星期
var arr = [
  '星期日',
  '星期一',
  '星期二',
  '星期三',
  '星期四',
  '星期五',
  '星期六',
];
var day = date.getDay(); // 当前星期 返回的是数字 从 0 开始
var today = '今天是：' + year + '年' + month + '月' + dates + '日' + arr[day];
console.log(today);

2. 格式化日期 - 时分秒

// 封装一个函数返回当前的 时分秒 格式为 00:00:00
function getTime() {
  var time = new Date(); // 创建一个日期对象
  var h = time.getHours(); // 时
  var m = time.getMinutes(); // 分
  var s = time.getSeconds(); // 秒
  return h + ':' + m + ':' + s;
}
console.log(getTime());

当时间为个位数时，会出现这种情况 1:1:1
因此需要改进代码，实现思路，当时间小于 10，在时间前添加一个 0

function getTime() {
  var time = new Date(); // 创建一个日期对象
  var h = time.getHours(); // 时
  h = h < 10 ? '0' + h : h; // 三元运算符，当时间小于 10 时在时间前添加 0
  var m = time.getMinutes(); // 分
  m = m < 10 ? '0' + m : m;
  var s = time.getSeconds(); // 秒
  s = s < 10 ? '0' + s : s;
  return h + ':' + m + ':' + s;
}
console.log(getTime());

3. Date 总的毫秒数（时间戳）

Date 对象是基于 1970 年 1 月 1 日（世界标准时间）起的毫秒数

我们经常利用总的毫秒数来计算时间，因为它更精确

获得 Date 总的毫秒数（时间戳），不是当前时间的毫秒数，而是距离 1970 年 1 月 1 日过了多少毫秒数

// 1.通过valueOf()  getTime()
var date = new Date();
console.log(date.valueOf()); // 返回的是当前时间距离 1970.1.1 总的毫秒数
console.log(date.getTime());
// 2.简单写法
var date1 = +new Date(); // +new Date()  返回的是总的毫秒数
console.log(date1);
// 3.H5 新增
console.log(Date.now());

4. 倒计时

核心算法：

• 输入的时间（将来的时间）减去现在的时间就是剩余的时间，即倒计时。但是不能直接用时分秒相减，比如 05 分减去 25 分，结果会是负数

• 利用时间戳。用户输入时间总的毫秒数减去现在时间总的毫秒数，得到的就是剩余时间的毫秒数

• 将剩余时间总的毫秒数转换为 天、时、分、秒（时间戳转换为 时分秒）

  转换公式如下：

  • d = parseInt(总秒数/60/60/24); // 计算天数
  • h = parseInt(总秒数/60/60%24); // 计算小时
  • m = parseInt(总秒数/60%60); // 计算分钟
  • s = parseInt(总秒数%60); // 计算秒数

// 封装一个倒计时函数 countDown 倒计时
function countDown(time) {
  var nowTime = +new Date(); // 当前时间
  var inputTime = +new Date(time); // 输入的时间（将来的时间）
  // 将来时间总毫秒数减去当前时间总毫秒数，1 秒 = 1000 毫秒
  var times = (inputTime - nowTime) / 1000;
  var d = parseInt(times / 60 / 60 / 24); // 计算天数
  d = d < 10 ? '0' + d : d;
  var h = parseInt((times / 60 / 60) % 24); // 计算小时
  h = h < 10 ? '0' + h : h;
  var m = parseInt((times / 60) % 60); // 计算分钟
  m = m < 10 ? '0' + m : m;
  var s = parseInt(times % 60); // 计算秒数
  s = s < 10 ? '0' + s : s;
  return '截止' + time + '还剩' + d + '天' + h + '时' + m + '分' + s + '秒';
}
console.log(countDown('2021-08-13 10:00:00'));

3. 数组对象

1. 数组对象的创建

1. 利用数组字面量

var arr = [1, 2, 3];
console.log(arr[0]);

2. 利用 new Array()

var arr = new Array(); // 创建一个空的数组
console.log(arr);
var arr1 = new Array(2); // 这里 2 表示数组的长度为 2，里面有两个空的数组元素
console.log(arr1);
var arr2 = new Array(2, 3); // 相当于数组 [2, 3]
console.log(arr2);

2. 检测是否为数组

1. instanceop 运算符

instanceop 运算符 用来检测是否为数组

返回结果为布尔值 true 或 false

var arr = []; // 创建一个空数组
var obj = {}; // 创建一个空对象
console.log(arr instanceof Array); // 结果返回 true
console.log(obj instanceof Array); // 结果返回 false

2. Array.isArray()

Array.isArray() 用于确定传递的值是否是一个 Array 数组

返回结果为布尔值 true 或 false

• H5 新增 ie9 以上版本支持

var arr = []; // 创建一个空数组
var obj = {}; // 创建一个空对象
console.log(Array.isArray(arr)); // 结果返回 true
console.log(Array.isArray(obj)); // 结果返回 false

3. 添加或删除数组元素

方法名	说明	返回值
push(参数 1…)	末尾添加一个或多个元素，注意修改原数组	返回新的长度
pop()	删除数组最后一个元素，将数组长度减 1，无参数、修改原数组	返回它删除的元素的值
unshift(参数 1…)	向数组的开头添加一个或更多元素，注意修改原数组	返回新的长度
shift()	删除数组的第一个元素，数组长度减 1，无参数、修改原数组	返回第一个元素的值

1. push()

• push 在数组末尾追加新的元素
• push() 参数直接写数组元素
• push 执行完毕后，返回的结果是新数组的长度
• 原数组也会发生变化

var arr = [1, 2, 3];
console.log(arr.push(4, 'hello')); // 在数组末尾追加新数组 返回结果为新数组的长度
console.log(arr); // 返回新数组 [1, 2, 3, 4, 'hello']

2. unshift()

• unshift 在数组前面追加新的元素
• unshift() 参数直接写数组元素
• unshift 执行完毕后，返回的结果是新数组的长度
• 原数组也会发生变化

var arr = [4, 5, 6];
console.log(arr.unshift(1, 2, 3)); // 在数组开头添加新数组，返回结果为新数组的长度
console.log(arr); // 返回新数组 [1, 2, 3, 4, 5, 6]

3. pop()

• pop 可以删除数组的最后一个元素，一次只能删除一个元素
• pop() 没有参数
• pop 执行完毕后，返回的结果是 删除的那个元素
• 原数组也会发生变化

var arr = ['red', 'blue', 'pink', 'green'];
console.log(arr.pop()); // 返回结果为 green 被删除的元素
console.log(arr); // 返回新数组 ['red', 'blue', 'pink']

4. shift()

• shift 可以删除数组的第一个元素，一次只能删除一个元素
• shift() 没有参数
• shift 执行完毕后，返回的结果是 删除的那个元素
• 原数组也会发生变化

var arr = ['red', 'blue', 'pink', 'green'];
console.log(arr.shift()); // 返回结果为 red 被删除的元素
console.log(arr); // 返回新数组 ['blue', 'pink', 'green']

4. 数组排序

方法名	说明	是否修改原数组
reverse()	颠倒数组中元素的顺序，无参数	该方法会改变原来的数组，返回新数组
sort()	对数组的元素进行排序	该方法会改变原来的数组，返回新数组

1. 翻转数组 reverse()

var arr = ['red', 'blue', 'pink'];
arr.reverse(); // 翻转数组
console.log(arr); // 返回结果为 ['pink', 'blue', 'red']

2. 数组排序（冒泡排序）

var arr = [6, 8, 4, 2, 5];
arr.sort(function (a, b) {
  return a - b; // 升序的顺序排列
  //return b - a; 	// 降序的顺序排列
});
console.log(arr); // 返回结果为数组 [2, 4, 5, 6, 8];

4. 数组索引

方法名	说明	返回值
indexOf()	数组中查找给定元素的第一个索引	如果存在返回索引号，不存在返回 -1
lastIndexOf()	在数组中的最后一个索引	如果存在返回索引号，不存在返回 -1

// 只返回第一个满足条件的索引号
// 如果在该数组中找不到元素，返回 -1
// indexOf() 返回该数组元素的索引号，从前面开始查找
var arr = ['red', 'green', 'blue', 'pink', 'blue'];
console.log(arr.indexOf('blue')); // 返回 2，'blue' 索引号为 2
console.log(arr.indexOf('yellow')); // 返回 -1，当前数组中找不到 'yellow' 元素

// lastIndexOf() 返回该数组元素的索引号，从后面开始查找
console.log(arr.lastIndexOf('blue')); // 返回 4 ,数组中最后一个元素为 'blue'，索引号为 4

数组去重案例

有一个数组 [‘c’, ‘a’, ‘z’, ‘a’, ‘x’, ‘a’, ‘x’, ‘c’, ‘b’]，要求去除数组中重复的元素

• 目标：将旧数组里面不重复的元素选出来放到新数组中，重复的元素只留一个，放到新数组中去重
• 核心算法：遍历旧数组，用旧数组元素查询新数组，如果该元素在新数组中没有，就添加，否则不添加
• 利用 indexOf() 如果返回 -1，说明新数组中没有该元素

// 封装一个去重的函数 unique（独一无二的）
function unique(arr) {
  var newArr = []; // 创建一个新的空数组
  for (var i = 0; i < arr.length; i++) {
    if (newArr.indexOf(arr[i]) === -1) {
      newArr.push(arr[i]);
    }
  }
  return newArr;
}
var demo = unique(['c', 'a', 'z', 'a', 'x', 'a', 'x', 'c', 'b']);
console.log(demo);

5. 数组转换为字符串

方法名	说明	返回值
toString()	将数组转换成字符串，逗号分隔每一项	返回一个字符串
join(‘分隔符’)	将数组中所有的元素转换为一个字符串	返回一个字符串

var arr = [1, 2, 3];
console.log(arr.toString()); // 返回结果为 1,2,3

console.log(arr.join()); // 返回结果为 1,2,3 分隔符默认为 逗号
console.log(arr.join('-')); // 返回结果为 1-2-3

4. 字符串对象

1. 基本包装类型

为了方便操作基本数据类型，javascript 提供了三个特殊的引用类型：String、Number 和 Boolean

基本包装类型 就是把简单数据类型包装成复杂数据类型，这样基本数据类型就有了属性和方法

var str = 'andy';
console.log(str.length);
// 对象才有属性和方法，复杂数据类型有属性和方法
// 相当于执行了以下操作：
// 1.将简单数据类型包装为复杂数据类型
var temp = new String('andy');
// 2.将临时变量的值给 str
str = temp;
// 3.销毁这个临时变量
temp = null;

2. 字符串的不可变

指的是里面的值不可变，虽然看上去可以改变内容，但其实是地址变了，在内存中新开辟了一个内存空间

var str = 'abc';
str = 'hello';
// 当重新给 str 赋值的时候，常量 'abc' 不会被修改，依然在内存中
// 重新给字符串赋值，会重新在内存中开辟空间，这个特点就是字符串的不可变
// 由于字符串的不可变，在大量拼接字符串的时候会有效率问题
var str = '';
for (var i = 0; i < 10000000; i++) {
  str += i;
}
console.log(str); // 这个结果需要花费大量时间来显示，因为需要不断的开辟新的空间
// 电脑配置不好的请勿尝试！！！

3. 根据字符串返回位置

字符串所有的方法，都不会修改字符串本身（字符串是不可变的），操作完成会返回一个新的字符串

方法名	说明
indexOf(‘要查找的字符’, 开始的位置)	返回指定内容在原字符串中的位置，如果找不到返回 -1，开始的位置是 index 索引号
lastIndexOf()	从后往前找，只找第一个匹配的

// 字符串对象，根据字符返回位置
// str.indexOf('要查找的字符', [起始的位置])
var str = 'Hello,World';
console.log(str.indexOf('o')); // 返回 4 第一个'o' 在索引号为 4 的位置
// 从索引号 5 的位置开始往后查找
console.log(str.indexOf('o', 5)); // 返回 7 第二个'o' 在索引号为 7 的位置

4. 根据位置返回字符（重点）

方法名	说明	使用
charAt(index)	返回指定位置的字符(index 为字符串的索引号)	str.charAt(0)
charCodeAt(index)	获取指定位置处字符的 ASCII 码(index 索引号)	str.charCodeAt(0)
str[index]	获取指定位置处字符	HTML5, IE8+支持 和 charAt() 等效

// 1.charAt(index) 根据位置返回字符
var str = 'andy';
console.log(str.charAt(3)); // 返回 y
// 遍历所有的字符
for (var i = 0; i < str.length; i++) {
  console.log(str.charAt(i));
}
// 2.charCodeAt(index) 返回相应索引号的字符ASCII值 目的：判断用户按下了哪个键
console.log(str.charCodeAt(0)); // 返回 97 索引号 0 的字符为 a, a 的 ASCII 值为 97
// 3.str[index] H5新增
console.log(str[3]); // 返回 y

5. 字符串操作方法（重点）

方法名	说明
concat(str1, str2, str3…)	用于连接两个或多个字符串。拼接字符串，等效于+，+更常用
substr(start, length)	从 start 位置开始(索引号)，length 取的个数
slice(start, end)	从 start 位置开始，截取到 end 的位置，end 取不到(他们两个都是索引号)
substring(start, end)	从 start 开始，截取到 end 位置，end 取不到。基本和 slice 相同，但是不接受负值

// 1.concat()
var str = 'Hello';
console.log(str.concat('World')); // 输出结果为 HelloWorld

// 2.substr()
var str1 = 'Hello World';
// 从第4个索引号开始取后面4个字符，空格也算一个字符
console.log(str1.substr(4, 4)); // 输出结果为 o wo

6. 替换字符

// 1.替换字符 replace('被替换的字符', '替换为的字符') 只替换第一个字符
var str = 'hello';
console.log(str.replace('h', 'y')); // 输出结果为 yello
// 2.字符转换为数组 split('分隔符')
var str1 = 'red, pink, blue';
console.log(str1.split(',')); // 输出结果为数组 ['red', 'pink', 'blue']
var str2 = 'red&pink&blue';
console.log(str2.split('&')); // 输出结果为数组 ['red', 'pink', 'blue']

7. 转换大小写

• toUpperCase() // 转换大写
• toLowerCase() // 转换小写

var str = 'abcdefg';
console.log(str.toUpperCase()); // 输出结果为大写 ABCDEFG
var str1 = 'Hello,World';
console.log(str1.toLowerCase()); // 输出结果为小写 hello,world