JavaScript：对象
七．对象
7.1初识对象
7.1.1 什么是对象
JavaScript中的所有事物都是对象：如字符串、数值、数组、函数等......
在这些之外，JavaScript允许自定义对象
对象是带有属性和方法的特殊数据类型。
7.1.2对象的特征
定义变量name来描述学生的姓名。
定义变量age来描述学生的年龄。
定义变量sex来描述学生的性别等。
但是，当需要描述多个学生时，如果每个学生的姓名、年龄和性别都通过变量来描述，会 使程序出现大量的变量，导致程序难以维护。 此时，我们可以通过 JavaScript 中的对象（一种数据类型）来描述学生，将学生的特征保 存在对象中。
7.1.3属性和方法
对象只是一种特殊的数据，对象拥有属性和方法
在 JavaScript 中，对象属于复杂数据类型，它是由属性和方法组成的一个集合。
属性是指对象的特征。
方法是指对象的行为。
a.访问对象的属性
属性是与对象相关的值。 .属性没有括号
访问对象属性的语法为：
objectName.propertyName
例子：
这个例子使用了 String 对象的 length 属性来获得字符串的长度：
<script>
var message="Hello World!"
var x=message.length
console.log(x)
</script>
b.访问对象的方法
方法是能够在对象上执行的动作。 .方法（）有括号
可以通过以下语法来调用方法：
objectName.methodName()
例子：
这个例子使用了 String 对象的 toUpperCase() 方法来将文本转换为大写：
<script>
var message="Hello World!"
var x=message.toUpperCase()
console.log(x)
</script>
7.2对象的创建
通过JavaScript，能够定义并创建自己的对象
创建新对象常见的三种不同的方法：
a. 利用字面量创建对象
b. 使用Object（）定义并创建对象
c. 使用构造函数来定义对象
创建新对象不常见的三种方法
a.原型对象（prototype关键字）
b.混合模式(原型和构造函数)
c.动态原型的方式
7.2.1使用字面量创建对象
在 JavaScript 中，使用对象的字面量创建对象，就是用大括号“{}”来标注对象成员，每个对象成员使用键值对的形式保存，即 “key: value”的形式。
对象字面量的语法格式如下。
*注：当对象不需要成员时，键值对可以省略，此时表示空对象。
(1)使用对象成员
案例演示：
<script>
var obj={} //创建空对象
var stu1={ //创建一个学生对象
name:'小明', //创建对象属性
age:18, …
sex:'男', …
sayHello:function(){ //创建对象属性
console.log('Hello')
}
}
console.log(stu1.name)
stu1.sayHello()
console.log(stu1['age'])
stu1['sayHello']()
</script>
使用对象成员的两种方式：
- 使用 ”.” 访问对象成员
- 使用 “[]” 访问对象的成员
如果对象的成员名中包含特殊字符，则可以用字符串来表示成员名，通过“[]”来访问，示例代码如下 。
(2) 添加对象成员
添加对象成员：对象创建完成后，用户可以通过为属性或方法赋值的方式来添加对象成员。
<script>
var obj1={}
var obj={}
obj.name='Jack' //为对象添加name属性
obj['age']=18 //为对象添加age属性
obj.sayHello=function(){ //为对象添加sayHello（）方法
console.log('Hello')
}
obj['sing']=function(){ //为对象添加sing（）方法
console.log('我爱你中国')
}
console.log(obj.name) //访问name属性，输出：jack
console.log(obj.age) //访问age属性，输出：18
obj.sayHello() //调用sayHello()方法，输出：hello
obj.sing() //调用sing ()方法，输出：我爱你中国
//如果访问对象中不存在的成员时，会返回 undefined
console.log(obj1.name) //访问obj1中的name属性，没有被定义
</script>
7.2.2利用 new Object（）创建对象
在JavaScript中，几乎所有的对象都是Object类型的实例，它们都会从Object.prototype继承属性和方法。
Object构造函数创建一个对象包装器。
Object 构造函数，会根据给定的参数创建对象，具体有以下情况：
a.如果给定值是null或undefined,将会创建并返回一个空对象
b.如果传进去的是一个基本类型的值，则会构造其包装类型的对象。
c.如果传进去的是引用类型的值，仍然会返回这个值，经他们复制的变量保有和源对象相同的引用地址。
当以非构造函数形式被调用时，Object 的行为等同于 new Object()。
语法格式：
//以构造函数形式来调用
new Object（[value]）
value可以是任何值
以下示例使用Object生成布尔对象：
//等价于o=new Boolean(true)
var o=new Object(true)
例子：
<script>
person=new Object()
person.firstname='Jhon'
person.lastname='Doe'
person.age=50
person.eyecolor="blue"
console.log("姓氏是："+person.firstname+"名字是："
+person.lastname+"年龄是："+person.age+"眼睛的颜色是:"+person.eyecolor)
</script>
例子：
<script>
var obj=new Object()
obj.name='小明'
obj.age=18
obj.sayHello=function(){
console.log('Hello')
};
console.log(obj.name)
obj.sayHello()
console.log(obj.age)
</script>
也可以使用对象字面量来创建对象，语法格式如下：
var myObject={
key1:value1,
key2:value2,
//更多键值对….
}
*注：
a. myObject: 变量名，用于引用整个对象。
b. key1, key2: 属性名称，可以是字符串或标识符。
c. value1, value2: 属性的值，可以是任意 JavaScript 数据类型，包括数字、字符串、布尔值、函数、数组、甚至其他对象
7.2.3使用函数构建对象
在JavaScript中，this通常指向的是我们正在执行的函数本身，或者是指向该函数所属的对象（运行时）
在构造函数的函数体中可以为新创建的对象添加成员，其语法格式如下
var 变量名 = new 构造函数名([参数1, 参数2, …]);
例子：
<script>
function Person(name){
// 添加实例成员：name属性和say()方法
this.name=name
this.say=function(){
console.log('Hello')
}
}
// 添加静态成员：class属性和run()方法
Person.class='102班'
Person.run=function(){
console.log('run')
}
// 使用静态成员
console.log(Person.class)
Person.run()
// 使用实例成员
var p1=new Person('小明')
console.log(p1.name)
p1.say()
</script>
7.3对象的遍历
在开发中，有时需要查询一个对象拥有哪些属性和方法，这时就需要进行对象的遍历。
对象的遍历是指遍历对象中所有的成员。
使用 for…in 语法可以进行对象的遍历，其语法格式如下。
for … in 循环遍历对象自身的和继承的可枚举属性(循环遍历对象自身的和继承的可枚举属性(不含Symbol属性).)
<script>
var obj={0:'a',1:'b',2:'c',3:'d'}
for(var i in obj){
console.log(i+':'+obj[i])
}
</script>
7.3.1值类型和引用类型
javascript中变量类型分为值类型（基本数据类型）和引用类型
值类型：String(字符串)，Number(数值)，Boolean(布尔值)，Undefined，Null
引用类型：Array(数组)，Object(对象)，Function(函数)
值类型和引用类型的区别
(1) 存储位置不一样
值类型占用空间固定，保存在栈中，保存与复制的是值本身，可以使用 typeOf()检测值的类型.
引用类型占用空间不固定，保存在堆中，保存与复制的是指向对象的一个指针,需要使用 instanceof() 检测数据类型,使用 new() 方法构造出的对象是引用型.
(2) 复制方式不一样
值类型的变量直接赋值就是深复制，如 var a = 10; var b = a;那么a的值就复制给b了，b修改值不会影响a,两份数据在内存中是完全独立的。
引用类型的变量直接赋值实际上是传递引用，只是浅复制.是将变量中的存储的地址赋值一份单独存储，但是两个变量中修改其中一个对象，另外一个引用来访问的时候，也会访问到修改后的值。
(3) 值类型无法添加属性和方法，引用类型可以添加属性和方法。
(4) 值类型的比较是值的比较，只有当它们的值相等的时候它们才相等。引用类型的比较是引用地址的比较
比较的时候注意双等号在做比较的时候做了类型转换，而全等号是值和类型相等是才能相等.
<script>
// 值类型
var num = 10;
function print(num) {
num = 100;
console.log(num); // 100
}
console.log(num); // 10
// 引用类型
var obj = {
name: 'jone'
}
function printObj(obj) {
obj.name = 'lucy';
console.log(JSON.stringify(obj)); // {"name":"lucy"}
}
console.log(JSON.stringify(obj)); // {"name":"lucy"}
</script>
7.4 常用的内置对象
常用的内置对象有四种：
a. 数值对象：Math
b. 日期对象：Date
c. 数组对象：Array
d. 字符串对象：String
7.4.1Math对象
Math对象表示数学对象，进行数学相关的运算。
1.Math常用属性及方法
（1）PI获取圆周率，可以计算半径为5的圆的周长
console.log(2*Math.PI*5);
输出结果为：31.415926（2）abs()可以计算-5的绝对值
console.log(Math.abs(-5));
输出结果为：5（3）max()和min()可以计算“1 3 7 18”里的最大值最小值
console.log(Math.max(1 3 7 18);
console.log(Math.min(1 3 7 18);
输出结果分别为18 1（4）pow()可以计算5的2次幂，然后可以用sqrt()进行求平方根
var w = Math.pow(5,2);
console.log(w);
console.log(Math.sqrt(w));
输出结果为25 5（5）random()随机生成一个大于等于0小于1的数
console.log(Math.random());
输出结果为 0.5874362接下来让我们通过一个案例来掌握Math知识点
案例：猜数字游戏
随机抽一个1到10之间的数字，猜对了提示你猜的真准，猜大了提示你猜的数字大了，猜小了提示你猜的数字小了。
<script>
// 生成随机整数的函数
// 使用Math.random()生成一个0到1之间的随机数（不包括1），然后乘以(max - min + 1)，得到一个0到(max - min + 1)之间的随机数（不包括(max - min + 1)），最后通Math.floor()向下取整并加上min，确保结果在min到max之间（包括min和max）
function getRandom(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
// 获得1到50的随机整数
var random = getRandom(1, 50);
var flag = 0;
// 初始化一个计数器flag，用来记录玩家已经猜了多少次。
// 使用while (true)创建一个无限循环，
// 游戏会一直进行直到玩家猜对数字或者用完5次机会。
while (true) {
var num = prompt('请猜一个1-50的数字：');
if (num > random) {
flag++;
alert('太大了！你还有' + (5 - flag) + '次机会');
} else if (num < random) {
flag++;
alert('太小了！你还有' + (5 - flag) + '次机会');
} else {
alert('恭喜你，猜对了！数字是' + random);
break;
}
if (flag == 5) {
alert('太菜了！机会用完了！正确数字是' + random);
break;
}
}
</script>
7.4.2Data对象
7.4.1 Data对象的创建
1.Date 对象用于处理日期与时间。
创建 Date 对象： new Date()
以下四种方法同样可以创建 Date 对象：
var d= new Date()
var d=new Date(milliseconds) //参数为毫秒
var d=new Date(dateString)
var d=new Date(year,month,day,hours,minutes,second,millisends)
*注：
milliseconds 参数是一个 Unix 时间戳（Unix Time Stamp），它是一个整数值，表示自 1970 年 1 月 1 日 00:00:00 UTC（the Unix epoch）以来的毫秒数。
dateString 参数表示日期的字符串值。
year, month, day, hours, minutes, seconds, milliseconds 分别表示年、月、日、时、分、秒、毫秒。
2.Data()构建函数形式：
Date()构造函数的 3 种使用形式如下。
3.构造函数传入数字型参数，规则如下：
a. 当传入以数字表示的年、月、日、时、分、秒时，最少需要指定年、月两个参数，后面的参数若省略会自动使用默认值，且月的取值范围是 0~11，0 表示 1 月，1 表示 2 月，以此类推。
b.当传入的数字大于合理范围时，会自动转换成相邻数字，将月份设为-1 表示去年12 月，设为 12 表示明年 1 月。构造函数传入数字型参数的示例代码如下
var date2 = new Date(2021, 7, 14, 10, 30, 45);
// 输出结果：Sat Aug 14 2021 10:30:45 GMT+0800 (中国标准时间)
console.log(date2);构造函数传入字符串型参数。当传入以字符串表示的日期和时间时最少需要指定年份，需 要注意的是，日期和时间的格式有多种，这里以“年-月-日 时:分:秒”格式为例。 为Date()构造函数传入字符串型参数的示例代码如下。
var date3 = new Date('2021-08-15 10:30:45');
// 输出结果：Sun Aug 15 2021 10:30:45 GMT+0800 (中国标准时间)
console.log(date3);7.4.2Date 对象的使用
创建Date对象后，对象中存放的是一个以字符串表示的日期和时间。如果想要单独获取或 设置年、月、日、时、分、秒中的某一项，可以通过调用Date对象的相关方法来实现。
一 .日期对象的创建
1、直接通过new Date()获取当前时间
var time=new Date()
console.log(time)
2、可以传入参数得到一个传入的参数的时间
var time=new Date('2024-10-24 19:09:09' )
console.log(time)
3可以传入一个通过new Date获取的时间，表示复制时间对象。
var time1=new Date('2024-10-24 20:09:09')
var time2=new Date(time1)
console.log(time1)
console.log(time2)
new Date()的传参情况
1、传一个参数,传一个参数表示毫秒数。
var time=new Date(3000)
console.log(time)
2、传两个参数,传递两个参数，第一个表示年，第二个表示月份
var time =new Date(2019,0)
console.log(time)
//2018-12-31T16:00:00.000Z，在时间+8之后，正好是2019-01-01的00时
// 注意：JS中月份从0开始，0表示1月，11表示12月。
3、传递三个数字，分别表示年、月、日,日的显示是正常的，从1-31。
var time =new Date(2019,1,20)
console.log(time)
4、六个参数，分别表示年、月、日、时、分、秒
var time =new Date(2020,4,20,19,20,30)
console.log(time)
5、可以直接传时间的字符串
var time=new Date("2022-05-20 10:10:10")
console.log(time)
var time2=new Date("2022/05/20 10:10:10")
console.log(time2)
//以上两种格式都可以
7.4.3newDate传递时间字符串获取时间的坑
上面有说到可以传递两种格式的时间字符串：
var time=new Date("2022-05-20 10:10:10")
var time2=new Date("2022/05/20 10:10:10")'
但是，第一种方法有个bug：
在只写年月日，不写时分秒的前提下：
1）、如果月份是个位数，且前缀为0的情况下，得到的时间会多出8小时；
2）、如果月份是两位数，但号数是个位数且前缀为0的话，得到的时间也会多出八小时。
var time=new Date("2022-02-12") // 得到的时间会多出八小时
var time2=new Date("2022-2-02") // 得到的时间 不 会多出八小时
var time3=new Date("2022-12-02") // 得到的时间会多出八小时
var time4=new Date("2022-12-2"); // 得到的时间 不 会多出八小时
7.4.4时间对象的常用get方法
1、getFullYear()--获取当前年份
var date=new Date()
console.log(date.getFullYear())//2022
'
2、getMonth()--获取当前月份
var date=new Date()
console.log(date.getMonth()) //月份是从0开始的
'
3、getDate()--获取当前是几号
var date=new Date()
console.log(date.getDate())
'
4、getDay()--获取当前是周几
var date=new Date()
console.log(date.getDay())
注意：周日是0，周一至周六是1-6。
5、getHours--获取当前的小时
var date=new Date()
console.log(date.getHours())
'
6、getMinutes()--获取分钟
var date=new Date()
console.log(date.getMinutes())
'
7、getSeconds()--获取秒数
var date=new Date()
console.log(date.getSeconds())
'
8、getTime()--获取时间戳
获取Date总的毫秒数(时间戳)
其实时间戳表示的是从1970年1月1号到当前时间的总的毫秒数。
在我们javascript中获取时间戳有三种方法。
//获取Date总的毫秒数(时间戳)，是从1970年1月1号到当前的总的毫秒数
//1.通过 valueOf() 或者 getTime() 方法
//得到的是我们当前时间距离1970 1.1的总的毫秒数
var date = new Date();
console.log(date.valueOf());
console.log(date.getTime());
2.简单的写法（最常用的写法）
var date = +new Date();
console.log(date);
//3.H5 新增的,ie9以下不适用
console.log(Date.now())
原文链接：https://blog.csdn.net/qq_57421630/article/details/1232083197.4.5时间对象的常用set方法
上述的是所有get方法，除了getDay()之外，都有对应的set方法，作用是分别单独设置时间。
var date=new Date()
console.log(date)
date.setFullYear(2025)
date.setMonth(5)
date.setDate(20)
date.setHours(13)
date.setMinutes(20)
date.setSeconds(10)
console.log(date)
//setDay没有，因为具体的某一天有规定的星期几，不能随便更改,否则时间就乱套了
'
时间是可以做算术运算的，时间进行算数运算的原理是通过时间戳进行运算得出结果；
var date=new Date()
date.setMinutes(date.getMinutes+10)
console.log(date)
'
时间是可以自动进制的，比如1小时最多只有60分钟，但如果你写90分钟，会自动进制；
var date=new Date()
date.setMinutes(90)
console.log(date)
7.4.6日期格式化
date.toLocaleString()：会转为一个本地日期格式的【字符串】，虽然不能自动进制，也不能用日期的API，但是可以用字符串的API了。
看似很牛，其实比较垃圾：具有兼容性问题，老IE输出的和主流浏览器输出的东西不一样。
解决：自定义format函数
function timeFormat(date) {
var year = date.getFullYear();
var month = date.getMonth() + 1;
var dte = date.getDate();
var hours = date.getHours();
var minutes = date.getMinutes();
var seconds = date.getSeconds();
var day = date.getDay();
month < 10 && (month = "0" + month);
hours < 10 && (hours = "0" + hours);
minutes < 10 && (minutes = "0" + minutes);
seconds < 10 && (seconds = "0" + seconds);
var dayarr = [
"星期日",
"星期一",
"星期二",
"星期三",
"星期四",
"星期五",
"星期六",
];
return (
year +
"年" +
month +
"月" +
dte +
"日 " +
hours +
":" +
minutes +
":" +
seconds +
" " +
dayarr[day]
);
}Arrary对象
Array 对象用于在单个的变量中存储多个值。
Arrary对象创建
new Arrary()：新建一个数组对象，数组里面的内容为空
new Arrary(size)： size 是期望的数组元素个数。返回的数组，length 字段将被设为 size 的值。
new Arrary(element0, element1, ..., elementn)：参数 element …, elementn 是参数列表。当使用这些参数来调用构造函数 Array() 时，新创建的数组的元素就会被初始化为这些值。它的 length 字段也会被设置为参数的个数。
例如
let a = new Array();
let b = new Array(2) // size 是期望的数组元素个数。返回的数组，length 字段将被设为 size 的值。
let c = new Array(1, 2, 4)
console.log(a);
console.log(b);
console.log(c);
当把构造函数作为函数调用，不使用 new 运算符时，它的行为与使用 new 运算符调用它时的行为完全一样。
例如
let e = new Array(5)
console.log(e);
let d = Array(5)
console.log(d);
Arrary对象属性
Length
1.属性描述
length 属性可设置或返回数组中元素的数目。
length 属性是可读可写的，设置 length 属性可改变数组的大小。如果设置的值比其当前值小，数组将被截断，其尾部的元素将丢失。如果设置的值比它的当前值大，数组将增大，新的元素被添加到数组的尾部，它们的值为 undefined
Arrary对象方法
push（）、pop（）
arrayObject.push(ele1,ele2,....,eleX)：向数组的末尾添加一个或多个元素，并返回新的长度。
push() 方法可把它的参数顺序添加到 arrayObject 的尾部。它直接修改 arrayObject，而不是创建一个新的数组。push() 方法和 pop() 方法使用数组提供的先进后出栈的功能。
arrayObject.pop()：用于删除并返回数组的最后一个元素。
pop() 方法将删除 arrayObject 的最后一个元素，把数组长度减 1，并且返回它删除的元素的值。如果数组已经为空，则 pop() 不改变数组，并返回 undefined 值。
例如
let d = [1, 2, 3];
console.log(d.push(9)); // 输出 4
console.log(d); // 输出 [1, 2, 3, 9]
console.log(d.pop()); // 输出 9
console.log(d); // 输出 [1, 2, 3]
unshift()、shift()
arrayObject.unshift(elet1,ele2,....,eleX)：可向数组的开头添加一个或更多元素，并返回新的长度。
unshift() 方法将把它的参数插入 arrayObject 的头部，并将已经存在的元素顺次地移到较高的下标处，以便留出空间。该方法的第一个参数将成为数组的新元素 0，如果还有第二个参数，它将成为新的元素 1，以此类推。unshift() 方法不创建新的创建，而是直接修改原有的数组。
arrayObject.shift()：用于把数组的第一个元素从其中删除，并返回第一个元素的值。
如果数组是空的，那么 shift() 方法将不进行任何操作，返回 undefined 值。该方法不创建新数组，而是直接修改原有的 arrayObject。
例如
let d = [1, 2, 3];
console.log(d.unshift(9)); // 输出 4
console.log(d); // 输出 [9, 1, 2, 3]
console.log(d.shift()); // 输出 9
console.log(d); // 输出 [1, 2, 3]
toString()、join()
arrayObject.toString()：把数组转换为字符串，并返回结果。
数组中的元素之间用英文逗号分隔。
arrayObject.join(separator)：把数组中的所有元素放入一个字符串。元素是通过指定的分隔符separator进行分隔。
返回一个字符串。该字符串是通过把 arrayObject 的每个元素转换为字符串，然后把这些字符串连接起来，在两个元素之间插入 separator 字符串而生成的。
例如
let a = [1, 2, 3, 4];
console.log(a.toString()); // 输出 "1,2,3,4"
console.log(a.join('-')); // 输出 "1-2-3-4"
concat()、splice()
arrayObject.concat(arrayX,arrayX,......,arrayX)：用于连接两个或多个数组。同样也可以将参数与原数组进行拼接。
返回一个新的数组，不改变原数组。该数组是通过把所有 arrayX 参数添加到 arrayObject 中生成的。如果要进行 concat() 操作的参数是数组，那么添加的是数组中的元素，而不是数组。
arrayObject.splice(index,howmany,item1,.....,itemX)：从数组中添加/删除项目，然后返回被删除的项目。
index：必需。整数，规定添加/删除项目的位置，使用负数可从数组结尾处规定位置。
howmany： 必需。要删除的项目数量。如果设置为 0，则不会删除项目。
item1, ..., itemX： 可选。向数组添加的新项目。
splice() 方法可删除从 index 处开始的零个或多个元素，并且用参数列表中声明的一个或多个值来替换那些被删除的元素。
如果从 arrayObject 中删除了元素，则返回的是含有被删除的元素的数组。
reverse()、sort()
arrayObject.reverse()：用于颠倒数组中元素的顺序。
该方法会改变原来的数组，而不会创建新的数组。
arrayObject.sort(sortby)：用于对数组的元素进行排序。
sortby：可选。规定排序顺序。必须是函数。
该方法数组在原数组上进行排序，不生成副本。
如果调用该方法时没有使用参数，将按字母顺序对数组中的元素进行排序，说得更精确点，是按照字符编码的顺序进行排序。要实现这一点，首先应把数组的元素都转换成字符串（如有必要），以便进行比较。
如果想按照其他标准进行排序，就需要提供比较函数，该函数要比较两个值，然后返回一个用于说明这两个值的相对顺序的数字。
比较函数应该具有两个参数 a 和 b，其返回值如下：
若 a 小于 b，在排序后的数组中 a 应该出现在 b 之前，则返回一个小于 0 的值。
若a等于 b，则返回 0。
若 a 大于 b，则返回一个大于 0 的值。
比较函数的逻辑如下：如果 a 是字符串且 b 是数字，则返回 1，表示 a 应该排在 b 之后。
如果 a 是数字且 b 是字符串，则返回 -1，表示 a 应该排在 b 之前。
否则，按数值大小进行比较，返回 a - b。
let a = [1, 2, 3, 4];
a.reverse(); console.log(a); // 输出 [4, 3, 2, 1]
let b = [0, 1, 2, '1', '2', 'a', 'b'];
b.sort(); // 默认被转换为同一类型进行排序
console.log(b); // 输出 [0, 1, 1, 2, 2, "a", "b"]
let c = [0, 1, 2, '1', '2', 'a', 'b'];
c.sort((a, b) => { // 希望字符串大于数字
if (typeof a === 'string' && typeof b === 'number') {
return 1;
} else if (typeof a === 'number' && typeof b === 'string') {
return -1;
} else {
return a - b;
}
});
console.log(c); // 输出 [0, 1, 2, 1, 2, "a", "b"]
slice()
arrayObject.slice(start,end)：从已有的数组中返回选定的元素。
start：必需。规定从何处开始选取。如果是负数，那么它规定从数组尾部开始算起的位置。也就是说，-1 指最后一个元素，-2 指倒数第二个元素，以此类推。
end：可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数，那么切分的数组包含从 start 到数组结束的所有元素。如果这个参数是负数，那么它规定的是从数组尾部开始算起的元素。（不包含结束元素）
该方法并不会修改数组，而是返回一个子数组。
let d = [1, 2, 3, 4, 5]
console.log(d.slice(1, 3));
String对象
String对象的创建
JavaScript 中，String 对象表示字符串对象，使用 String()构造函数来创建。 在 String()构造函数中传入字符串，就会在创建出来的 String 对象中保存传入的字符串。
示例代码如下：
var str = new String('apple'); // 创建 String 对象
console.log(str); // 输出结果：String {"apple"}通过前面的学习，我们已经掌握了如何定义字符串类型的变量，那么字符串类型的变量和 String 对象有什么区别呢？ 字符串类型的变量也可以像 String 对象一样访问属性和方法，但是字符串类型的变量并不是一个对象，它只是一个字符串类型的数据。通过代码演示字符串变量和 String 对象的区别。
示例代码如下：
var str = 'apple';
var str1 = new String('apple');
console.log(str.length); // 输出结果：5
console.log(str1.length); // 输出结果：5
console.log(typeof (str));// 输出结果：string
console.log(typeof (str1)); // 输出结果：objec字符串的连接
语法：
sencat(str1[ str2, str3...])
连接一个或多个字符串
示例代码：使用 concat()方法连接字符串'Hello'和'World'
var str = 'Hello';
var str1 = 'World';
console.log(str.concat(str1)); // 输出结果：HelloWorld获取字符串长度
在JavaScript中，我们可以使用length属性来获取字符串的长度。
语法：
字符串名.length
说明：
调用对象的属性，我们用的是点（.）运算符，可以将它理解为“的”，例如str.length可以看成是“str的length（长度）”。
字符串对象的属性有好几个，不过我们要掌握的也只有length这一个。获取字符串长度在实际开发中用得非常多。
举例：获取字符串长度
var str = "I Love Study"
document.write("字符串长度是："+str.length);分析：
对于str这个字符串，其实空格本身也是作为一个字符串来处理的，这一点我们很容易忽略。
举例：获取一个数字的长度
function getlength(n){ var str = n + ""; return str.length } var result = "12345678是" + getlength(12345678) + "位数"; document.write(result)
大小写转换
在JavaScript中，我们可以使用toLowerCase（）方法将大写字符串转化为小写字符串，也可以使用toUpperCase（）方法将小写字符串转化为大写字符串。
语法：
字符串名 .toLowerCase()
字符串名 .toUpperCase()
说明：
调用对象的属性，我们用的也是(.)运算符。不过属性和方法不太一样，方法后面需要加上小括号(),而属性则不需要。
JavaScript还有两种大小写转换的方法：toLocalLowerCase()和toLocalUpperCase()。不过这两种方法很少用。
举例：
var str = "Hello World";
document.write("正常："+ str + "<br/>");
document.write("小写："+str.toLowerCase()+"<br/>");
document.write("大写："+str.toUpperCase()+"<br/>");
根据索引返回字符串
| 方法 | 作用 |
| charAt(index) | 获取index索引的字符，字符串第1个字符的索引为0 |
| charCodeAt(index) | 获取index索引的字符的ASCII码 |
通过代码演示 charAt()方法和 charCodeAt()方法的使用。
查找字符串'Apple'中索引为 2 的字符，以及索引为 0 的字符的 ASCII 码。
示例代码如下。
var str = 'Apple';
console.log(str.charAt(2)); //输出结果：p
console.log(str.charCodeAt(0));// 输出结果：65（字符A的 ASCII 码为 65）截取字符串
| 方法 | 作用 |
| slice（start[,end]） | 截取从起始(start)索引到终止(end)索引之间的1个子字符串，若省略end则表示从起始(start)索引开始截取到字符串末尾。 |
| substring(start[, end]) | 截取从起始(start)索引到终止(end)索引之间的1个子字符串，基本和slice相同，但是不接收负值 |
| substr(start[, length]) | 截取从起始(start)索引开始到length长度的子字符串，若省略length则表示从起始(start)索引开始截取到字符串末尾 |
分别使用 slice()、substring()以及 substr()方法从字符串'HelloWorld'中截取出字符串'el'和 'World'，示例代码如下。
var str = 'HelloWorld';
// 利用 slice()方法实现
console.log(str.slice(1,3)); //输出结果：el
console.log(str.slice(5)); // 输出结果：World
// 利用 substring()方法实现
console.log(str.substring(1,3)); //输出结果：el
console.log(str.substring(5)); // 输出结果：World
// 利用 substr()方法实现
console.log(str.substr(1,2)); //输出结果：el
console.log(str.substr(5)); 从// 输出结果：World替换字符串
在JavaScript中，我们可以使用replace()方法来用一个字符串替换另外一个字符串的某一部分。
语法：
字符串名.replace(原字符串str1, 替换字符串str2)
说明：使用str2替换字符串中的str1，返回替换结果，只会替换第一次出现的str1。
举例： 使用 replace()方法将字符串'RainyDay and SunnyDay'中的第 1 个'Day'替换成'天'
var str = 'RainyDay and SunnyDay';
console.log(str.replace('Day', '天')); // 输出结果：Rainy 天 and SunnyDay分割字符串
在JavaScript中，我们可以使用split()方法把一个字符串分割成一个数组，这个数组存放的是原来字符串的所有字符片段。有多少个片段，数组元素个数就是多少。
语法：
字符串名.split("分割符")
说明：
分割符可以是一个字符、多个字符或一个正则表达式。此外，分割符并不作为返回数组元素的一部分。
举例：
var str = "HTML,CSS,JavaScript";
var arr = str.split(",");
document.write("数组第1个元素是：" + arr[0] + "<br/>");
document.write("数组第2个元素是：" + arr[1] + "<br/>");
document.write("数组第3个元素是：" + arr[2]);分析：
str.split(" ")表示用空格来分割字符串。在字符串中，空格也是作为一个字符来处理的。
str.split(" ")两个引号之间是有一个空格的。str.split(" ")（有空格）是带有一个字符的字符串。
str.split("")（无空格）是一个带有0个字符的字符串，也叫空字符串。两者是不一样的，我们可以通过下面这个例子对比一下。
举例：str.split("")（无空格）
var str = "study";
var arr = str.split("");
document.write("数组第1个元素是：" + arr[0] + "<br/>");
document.write("数组第2个元素是：" + arr[1] + "<br/>");
document.write("数组第3个元素是：" + arr[2] + "<br/>");
document.write("数组第4个元素是：" + arr[3] + "<br/>");
document.write("数组第5个元素是：" + arr[4]);
检索字符串的位置
在JavaScript中，可以使用indexOf()方法来找出“某个指定字符串”在字符串中首次出现的下标位置，也可以使用lastIndexOf()来找出“某个指定字符串”在字符串中最后出现的下标位置。
语法：
字符串名.indexOf(指定字符串)
字符串名.lastIndexOf(指定字符串)
说明：
如果字符串中包含“指定字符串”，indexOf()就会返回指定字符串首次出现的下标，而lastIndexOf()就会返回指定字符串最后出现的下标；如果字符串中不包含“指定字符串”，indexOf()或lastIndexOf()就会返回-1。
举例：
var str = "Hello World!";
document.write(str.indexOf("world") + "<br/>");
document.write(str.indexOf("World") + "<br/>");
document.write(str.indexOf("Worlds"));分析：
对于str.indexOf("world")，由于str不包含“world”，所以返回-1；
对于str.indexOf("World")，由于str包含“World”，所以返回“World”首次出现的下标位置。字符串的位置是从0开始的。
对于str.indexOf("Worlds")，由于str不包含“Worlds”，所以返回-1。特别注意一下，str包含“World”，但不包含“Worlds”。
在实际开发中，indexOf()用得非常多，我们要重点掌握一下。对于检索字符串，除了indexOf()这个方法外，JavaScript还为我们提供了另外2种方法：match()和search()。
不过3种方法都大同小异，我们只需要掌握indexOf()一个就够用了。为了减轻记忆负担，对于match()和search()，我们可以直接忽略掉。
举例：
var str = "Hello world!";
document.write("l首次出现的下标是：" + str.indexOf("l") + "<br/>");
document.write("l最后出现的下标是：" + str.lastIndexOf("l")); 分析：
indexOf()和lastIndexOf()不仅可以用于检索字符串，还可以用于检索单个字符。
案例：统计字符串中有多少个数字
一个任意字符串，然后统计一下里面有多少个数字。使用for循环结合charAt()方法来获取字符串中的每一个字符，然后判断该字符是否是数字。
实现代码如下：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>统计字符串中有多少个数字</title>
</head>
<body>
<script>
function getNum(str) {
var num = 0;
for (var i = 0; i < str.length; i++) {
var char = str.charAt(i);
//isNaN()对空格字符会转化为0，需要加个判断charAt(i)不能为空格
if (char != " " && !isNaN(char)) {
num++;
}
}
return num;
}
document.write(getNum("1d3sdsg"));
</script>
</body>
</html>
原文地址：https://blog.csdn.net/2401_86036532/article/details/143790811
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！