1.作用域
scope 规定了变量访问的范围
1. 局部作用域：函数作用域，块作用域
1. 函数作用域
-
函数内部内部声明的变量，外部无法直接访问
2. 函数的参数也是函数内部的局部变量
3. 不同函数内部声明的变量无法相互访问
-
函数执行完毕后，函数内部的变量实际被清空了
2. 块作用域
在js中用 {} 包裹的代码称为代码块，代码块内部声明的变量外部将 '有可能' 无法被访问
-
'let'声明的变量会产生块作用域， 'var'不会产生块作用域。
2. const声明的常量也会产生块作用域。
3.不同代码块之间的变量无法互相访问。 //因此多个循环都可以用let i=0声明变量。
4.用let&const
<script>
for (let i = 0; i < 3; i++) {
console.log(i);
}
for (var j= 0; j < 3; j++) {
console.log(j);
}
console.log(j);//var不会产生块作用域，所以 {} 外依然能被访问
</script>
2. 全局作用域
<script>标签和 .js文件的 '最外层' 即全局作用域，在此声明的变量在任何其它作用域可以被访问。
1.为window对象动态添加的属性默认也是全局的，不推荐！
2.函数中未使用任何关键字声明的变量为全局变量，不推荐！
3.为防止全局变量被污染，少声明全局变量。
3. 作用域链: 本质是底层的 变量查找机制
-
函数被执行时，会优先在当前作用域查找变量。
-
若当前差不到则会依次查找父级作用域直到全局作用域.
-
嵌套关系的作用域串联起来成了作用域链。
-
子作用域可以访问父作用域，父作用域不能访问子作用域。
4. js垃圾回收机制GC(Garage Collection)
js中 '内存' 的分配和回收都是自动完成的，内存在不使用的时候会被垃圾回收器自动回收
内存的生命周期：
1. 内存分配：当我们声明变量，函数，对象的时候，函数会自动为它们分配内存。
1. 内存使用：即读写内存，也就是使用变量，函数等。
1. 内存回收：使用完毕，由 '垃圾回收器' 自动回收不再使用的内存。
说明：
1. 全局变量一般不会被回收（关闭页面回收）。
2. 一般局部变量不用了会自动回收掉。
内存泄漏：程序中分配的 '内存' 由于某种原因程序 '未释放' 或 '无法释放' 叫做内存泄漏
js回收机制的算法说明
堆栈空间分配区别：
栈(操作系统): 由 '操作系统自动分配释放' 函数的参数值，局部变量等，基本数据类型放到栈里面。
堆(操作系统): 一般由程序员分配释放，否则由 '垃圾回收机制' 回收。'复杂数据类型' 放到堆里面。
tips：复杂数据类型赋值赋的是地址。
两种常用的垃圾回收算法：
-
引用计数法(IE)（已弃用）：定义'内存不再使用'，看一个'对象'是否有指向它的引用，没有引用了就回收对象。
算法：
a. 跟踪记录被引用的次数；b. 如果减少引用它的次数则’-1‘；c. 如果引用次数是1，则释放内存。
eg: 一个数组const arr = [1,2,3,4]，'数组也属于对象'，属于'复杂数据类型'，变放入'堆'里面，为了找到这个数组，便在'栈里面存放这个数组的地址'，于是arr可以通过地址找到数组，同时栈里面的地址指向了数组，那么引用次数记录为1；代码又往下读到 arr = null，null属于简单数据类型，内存里没有地址了，不指向数组了，没有被引用了那么引用次数变为了0，就自动回收了。
缺点：嵌套引用（循环引用）：两个对象 '互相引用'，它们的引用次数永不为0，即便它们不再使用，也不会回收进而导致内存泄漏。
2. 标记清除法：
a. 标记清除法将不再使用的对象，定义为'无法到达的对象'。
b. 从'根部'(js中就是全局对象)出发定时扫描内存中的对象，凡是能从'根部到达'的对象，都是还需要使用的。
c. 那些无法从根部出发触及到的'对象被标记'为不再使用，稍后'进行回收'。
5. 闭包
概念：一个函数对周围状态的引用捆绑在一起，内层函数中访问到其外层函数的作用域。
闭包 = 内层函数 + 外层函数的变量
一个函数能访问另一个函数的作用域。
作用：封闭数据，提供操作，外部也可以访问函数内部的变量。
<script>
function fn() {
const a=1
function g() {
console.log(a);//断点调试，scope(作用域)显示闭包(Closure)
}
g()
}
fn()
</script>
<script>//常见闭包的形式，外部可以访问内部的变量
function outer() {
let i=1
function fn() {
console.log(i);
}
return fn//outer() === fn === function fn(){}
}
const g = outer()//const g = function fn(){}
g()//fn，g是函数本身；fn()是函数的结果。
</script>
应用：实现数据的私有，无法直接修改i，但是一旦i不会，就会导致 '内存泄露'。
eg：统计函数的调用次数，
<script>//这里i是全局变量，很容易被修改
let i=0
function fn() {
i++
console.log(i);
}
</script>
<script>
function outer() {
let i = 0
function fn() {
i++
console.log(i);
}
return fn
}
const fun = outer()//因为fun是全局作用域，因此只有关闭时才会被回收，fun指向了fn函数，fn使用了i，从global可以一路找到i，因此虽然i在局部作用域里，但是不会被回收。
</script>
6. 变量提升
仅对于用var声明变量，它允许在变量声明之前即被访问。
代码执行之前，会在'当前'作用域之下所有var声明的变量提升到'当前'作用域的最前面（只提升声明，不提升赋值）
注意：
-
变量在未声明即被访问会报语法错误
-
变量在var声明之前即被访问，变量的值为undefined
-
let/const声明的变量不存在变量提升
-
变量提升发生在相同作用域中
<script>
//var a //代码执行之前，会在'当前'作用域之下所有var声明的变量提升到'当前'作用域的最前面（只提升声明，不提升赋值）
let c
console.log(c);
console.log(a);//undefined
console.log(b);//error
var a = 1
let b = 2
</script>
2. 函数进阶:
函数参数默认值，动态参数，剩余参数的使用细节，提升函数应用的灵活度，箭头函数
1. 函数提升
a. 会把所有函数声明提升到'当前'作用域的最前面
b. 只提升函数声明，不提升函数调用
c. 函数表达式必须先赋值声明，后调用，否则会报错。
<script>
// fn()
// function fn() {
// console.log(1);
// }
var fun//提升变量声明，没提升赋值
fun()//因为只提升了声明，都不知道fun是个函数
fun = function () {
console.log('函数表达式');
}
</script>
2. 函数参数
动态参数
arguments：函数内部内置的'伪数组'变量，它包含调用函数时传入的所有实参,它只存在于函数中。
<script>
function getSum() {
let sum = 0
for (let i = 0; i < arguments.length; i++) {
sum += arguments[i]
}
console.log(sum);
}
getSum(1,2,3,4,5)
getSum(4,5,6,32,543,6)
</script>
剩余参数（主用）
将一个不定数量的参数表示为一个数组：‘ ...数组名 ’
a. '...' 是语法符号，置于最末函数形参之前，用以获取多余的参数
b. 借助'...'获取的剩余实参，是个'真数组'
<script>
function getSum(a,b,...arr) {//可以用于允许用户至少输入几个
console.log(arr);
}
getSum(2,4,5,3,6,4,5,4,3,3)
</script>
补充：展开运算符：将一个数组进行展开
说明：
a. 不会修改原数组
b. 应用场景：求最大最小值，合并数组。
<script>
const arr = [1,2,3,4,5]
//在console里没有逗号，而实际上： ...arr === 1，2，3，4，5
console.log(...arr);
console.log(Math.max(1,2,3));//求最大值里面不是数组，还需要用，隔开
console.log(Math.max(...arr));
//合并数组
const arr2 = [6,7,8]
const arr3 = [...arr,...arr2]
console.log(arr3);
</script>
对比：剩余参数：函数参数使用，得到真数组。
展开运算符：数组中使用，数组展开。
3. 箭头函数
更简洁的函数写法，且不绑定this
箭头函数不是替代，而是更适用于那些本来'需要匿名函数的地方'
1. 基本语法
a. 箭头函数属于表达式函数，因此不存在函数提升。
b. 箭头函数只有一个参数时可以省略()
c. 箭头函数只有一行代码时可以省略{}，无需return自动为返回值做返回。
d. 加括号的函数体返回对象字面量表达式。
<script>
//普通函数
// function fn() {
// console.log(1);
// }
//a. 箭头函数基本语法
const fn = () => {
console.log(1);
}
fn()
//b. 传入形参实参
const fn1 = (a) => {
console.log(a);
}
fn1(2)
//c. 只有一个形参省略()
const fn2 = a => {
console.log(a);
}
fn2(3)
//d. 只有一行代码省略大括号
const fn3 = a => console.log(a);
fn3(4)
//e. 只有一行代码省略return
// const fn4 = a => {
// return a+1
// }
// console.log(fn5(1));
const fn4 = a => a+1
console.log(fn5(1));
//阻止表单默认提交，省略大括号小括号
// const form = document.querySelector('form')
// form.addEventListener('click', e => e.preventDefault())
//f.箭头函数可以直接返回一个对象
const g = (uname) => ({uname: uname })//里面{}是对象的，外面再包{}易混淆，故({}),数组解构之后可以({uname})
fn('tom')
</script>
2. 箭头函数参数
箭头函数有剩余函数...数组名, 没有动态参数
<script>
//利用箭头函数求和
const getSum = (...arr) => {
let sum=0
for (let i = 0; i < arr.length; i++) {
sum+=arr[i]
}
console.log(sum);
}
getSum(2,3,4)
</script>
3. 箭头函数this
箭头函数不会创建自己的this，它只会从自己的作用域链的上一次层沿用this
箭头函数没有自己的this值，所以它会继承外部的this值
普通函数的this值是在运行时根据函数调用的方式动态确定的，它可以根据函数的调用者不同而指向不同的对象。
dom事件回调函数不推荐箭头函数，尤其需要this。
普通函数的this
<button></button>
<script>
console.log(this);// 指向window
const f1 = function () {
console.log(this);//指向window，因为写全是window.f1,指向this的调用者
}
f1 ()
const btn = document.querySelector('button')
btn.addEventListener('click',function () {
console.log(this);//当前this指向btn
})
const obj = {
name:'a',
fn2:function () {
console.log(this);//指向obj
}
}
obj.fn2()
</script>
箭头函数的this
父级作用域的this值决定。
this所在的局部作用域没有指向，而确实指向window并不是因为window是调用者，而是它作用域链的上一层<script>的this指向的是window
<script>
//普通箭头函数this
const fn = () => {console.log(this);}
fn()
//对象方法的箭头函数this
const obj = {
name:'a',
fn2:() =>{console.log(this)}//指向window，window.obj.fn2()
}
obj.fn2()
const obj2 = {
name:'a',
fn2: function () {
console.log(this);//普通函数this指向调用者obj2
let i=1
const count = () => {
console.log(this);//箭头函数本身局部作用域没this，上一级作用域this指向obj2
}
count()
}
}
obj2.fn2()
</script>
3. 解构赋值
语法分类，使用解构简洁语法快速为变量赋值
1. 数组解构
将数组的单元值（数组元素）'批量' 赋值给一系列变量的简洁语法
基本语法：赋值运算符 = 左侧的[]用于批量声明变量，右侧数组的单元值将被赋值给左侧的变量
基本
<script>
const arr = [100,20,60]
const [] = arr
//const [max,min,avg] = arr
const [max,min,avg] = [100,20,60]
console.log(max);
//交换变量
let a=1
let b=2;//[a,b]q前必须要分号！
[a,b] = [b,a]
console.log(a,b);
</script>
js前必须加分号情况
-
立即执行函数：(function({}))();
-
数组解构：数组开头，前面有语句，必须加分号
<script>
//如若没有分号，就不认为数组换行，而是跟在上一行句子后面，
const c = 1
;[1,2,3].map(function (item) {
console.log(item);
})
</script>
语法
<script>
// 变量多，单元值少
const [a1,b1,c1,d1] = [1,2,3]
console.log(d1);//undefined
// 变量少，单元值多
//用剩余参数,!!!剩余参数只能于最后位。
const [a2,b2,...arr] = [1,2,3,4,5]
console.log(arr);
//防止undefined传递
//类似默认参数
const [a3=0,b3=0] = []
//按需导入，忽略某些返回值
const [a4,,c4,d4] = [1,2,3,4]
//多维数组
const arr1 = [1,2,[[3,4],5]]
console.log(arr1[2][0][1]);//得到4
const [a5,b5,c5] = arr1
console.log(c5);//[[3,4],5]
const [a6,b6,[c6,d6]] = arr1
console.log(c6);//[3,4]
</script>
2. 对象解构
将对象的属性和方法快速批量快速赋值给一系列变量的简洁语法
基本语法
a. 赋值运算符 = 左侧的{}用于批量声明变量，右侧对象的属性值将被复制给左侧的变量。
b. 对象属性的值将被赋给与属性名'相同'的变量
c. 注意解构的变量名不要和外面的变量名冲突否则报错
d. 对象中找不到与变量名属性一致的属性时变量值为undefined
//normal
const obj = {
uname:'tom',
age: 10
}
对象解构
const{uname,age} = {uname:'tom',age: 10}//变量名和属性名必须相同
等同 const uname = obj.uname
更改对象解构的变量名（如若已经有变量名为uname）
const obj1 = {
newname:'tom',
age: 10
}
const newname = 1//对象解构的变量名就不能为newname了,age与上个变量名也有冲突，都需重新命名
const {newname:name1,age:age1} = obj1
数组对象解构
const abc = [//对象放数组里
{
uname: 1,
age:2
}
]
const [{uname:name2,age:age2}] = abc
console.log(name2,age2 );
多级对象解构
const obj2 = {
a1:1,
b1:{
b2:2,
b3:3,
b4:4
},//这里要','
c1:5
}
const {a1,b1:{b2,b3,b4},c1} = obj2
案例：后台真实数据
<script>//对象所有的全都加了""，这个叫做json对象，通过ajax发送过来的数据都是这个格式
const msg = {
"code": 200,//code200经常表示请求成功
"msg": "获取新闻列表成功",//message 返回的一个信息
"data": [ //核心数据都在data里
{
"id": 1,
"title": "5G商用自己，三大运用商收入下降",
"count": 58
},
{
"id": 2,
"title": "国际媒体头条速览",
"count": 56
},
{
"id": 3,
"title": "乌克兰和俄罗斯持续冲突",
"count": 1669
},
]
}
//需求1:解构data信息
const {data} = msg
console.log(data);
//需求2:上面msg是后台传递过来的数据，我们需要把data选出当做参数传递给 函数
//正常写法
// const {data} = msg
// function renden(arr) {
// console.log(arr);
// }
// renden(data)
//更好写法
//const {data} = msg，data就是msg解构而来，因此形参直接{data}，传入参数顺便解构
//msg虽然很多属性，但是我们利用解构只要data
function genden({data}) {
console.log({data});
}
genden(msg)
//需求3:为了防止msg里面的data名字混淆，要求渲染函数里面的数据名改为 myData
// function renden1({data}) {
// const {data:newData} = msg
// console.log(newData);
// }
// renden1(msg)
function renden1({data:myData}) {
console.log(myData);
}
renden1(msg)
</script>
forEach遍历数组
（for循环加强版）适合遍历数组对象！
遍历数组的每个元素，并将元素传递给回调函数（只遍历，不返回值）（只能遍历数组）
语法：（与map()很类似）
被遍历的数组.forEach(function(当前数组元素,当前元素索引号){
//函数体
})
当前数组元素必写,当前元素索引号可选
<script>
const arr = [1,2,3,4,5,6,7,8]
arr.forEach(function (item,index) {
console.log(item);
console.log(index);
})
</script>
4. 深入对象
创建对象三种方式&&构造函数&&实例成员&静态成员
1. 创建对象三种方式
a.利用对象字面量创建对象。
const dxzml = {
uname:1
}
b.利用new Object创建对象。
const nobj = new Object({uname:2})
nobj.uname = 3
console.log(nobj);
c.利用构造函数创建对象。
function Aaa(bbb,ccc,ddd) {
this.bbc = bbb//给对象添加了一个叫bbc的属性，this是空对象
this.ccd = ccc
this.dde = ddd
}
const abc = new Aaa('dkkd',88,'kjqk')
console.log(abc);
2. 构造函数(实例化)
利用构造函数创建对象。
构造函数：一种特殊的函数，用来初始化对象,公共的抽出来封装到函数里。
场景：常规的{...}语法允许创建一个对象，继续创建还需要重写一遍，此时可以通过'构造函数'来'快速创建多个'类似的对象。
规定：
-
名字只能以大写开头；
-
他们只能以'new'操作符来执行
说明：
-
使用new关键字构造函数的行为被称作'实例化'。
-
实例化构造函数时没有参数可以省略()
-
构造函数内部无需写return，返回值即为新创建的对象。
-
构造函数内部的return返回值无效，因此无需写return。
-
new Object() ; new Date() 也是实例化构造函数。
<script>
function Goods(name,price,count) {
this.uname = name
this.price = price
this.count = count
}
const a1 = new Goods('mi',1999,20)
const b1 = new Date('2022-08-01')//系统自带的实例化构造函数
console.log(a1,b1);
</script>
实例化执行过程
-
创建新对象；
-
构造函数this指向新对象；
-
执行构造函数代码，修改this，添加新的属性；
-
返回新对象
3. 实例成员&静态成员
实例成员
通过构造函数创建的对象称为实例对象，实例对象中的属性和方法被称为实例成员（实例属性和实例方法）
说明：
-
为构造函数传入参数，创建结构相同但值'不同的对象'。
-
构造函数创建的对象'彼此独立'互不影响。
<script>
//构造函数
function Fn() {
//构造函数内部的this就是实例对象
//实例对象中动态添加属性
this.name = 'tom'
//实例对象动态添加方法
this.showOn = () => console.log(1)
}
//实例化.p1就是实例对象
//p1实际就是构造函数中的this
const p1 = new Fn()
console.log(p1);
console.log(p1.name);//访问实例属性
p1.showOn();//调用实例方法
</script>
静态成员
构造函数的属性和方法被称为静态成员（静态属性和静态方法）
说明：
-
静态成员只能构造函数来访问。
-
静态方法中的this指向构造函数。比如Date.now() Math.PI Math.Random()
<script>
function Person(name,age) {
this.name = name
}
//静态属性
Person.aaa = 1
Person.bbb = 2
//静态方法
Person.ccc = function() {//箭头函数没有this
console.log(3);
//this 指向Person
console.log(this.bbb);
}
Person.ccc()
</script>
4. 内置构造函数
Object， Array，String，Number
基本数据类型：string,number,boolean,undefined,null
引用类型：object
string, boolean, number等基本数据类型也有对象的使用特征，如具有属性和方法；
因为其是js底层使用Object构造函数"包装"来的，称为'包装类型'
js中几乎所有的数据都可以基于构成函数创建
<script>
//普通字符串也有属性，甚至有些还有方法
const str = 'string'
const num = 1
console.log(str.length);
console.log(num.toFixed(2));
//虽然是简单数据类型，但是内部是如下实例化，被包装成了对象
//const str = new String('string')
//js底层完成，把简单数据类型包装成了引用数据类型
</script>
引用类型：Object, Array, RegExp(正则表达式), Date等
包装类型：String, Number, Boolean等
Object
常用静态方法：只有构造函数Object才可以调用
Object.keys() 静态方法获取对象中所有属性（键），返回的是一个数组
Object.values() 静态方法获取对象中所有属性
Object.assign(待拷贝的,被拷贝的)静态方法常用于对象拷贝；经常使用的场景给对象添加属性。
<script>
const o = {name:'tom',age:1}
for(let k in o){//之前这样这样才能获得所有属性名和属性值
console.log(k);
console.log(o[k]);
}
console.log(Object.keys(o));
console.log(Object.values(o));
//对象拷贝
const obj = {}
Object.assign(obj,o)
console.log(obj);
//对象拷贝经常使用的场景给对象添加属性
Object.assign(obj,{value:1000})
console.log(obj);
</script>
Array
Array是内置的构造函数，用于创建数组。
建议使用字面量创建，而非Array构造函数创建
数组常见实例方法：核心方法
forEach: 遍历数组 不返回数组，用于'查找&遍历'数组元素。
filter: 过滤数组 '返回'新数组，返回的是'满足筛选条件'的数组元素。
map: 迭代数组 '返回'新数组，返回的是'处理之后'的数组元素，想要使用返回的新数组。
reduce: 累计器 返回累计处理的结果，经常用于求和等。
// reduce方法
<script>
//Array构造函数创建array
const arr1 = new Array(3,5)
console.log(arr1);
//reduce 语法
//arr.reduce(function(上一次值,当前值){},初始值)
const arr = [1,2,3,4]
//没有初始值
const total = arr.reduce(function (prev,current) {
return prev+current
})
console.log(total);
//有初始值
const total1 = arr.reduce((prev,current) => prev+current,10)//初始值与之前想加
console.log(total1);
//如果'没有起始值'，则'上一次值'以数组的'第一个数组元素的值'
//每一次循环，把'返回值'给作为 下一次循环的'上一个值'
//如果'有起始值'，则 起始值作为'上一次值'
//无初始值
//上一次值 当前值 返回值 （第一次循环 ）
// 1 2 3
//上一次值 当前值 返回值 （第二次循环 ）
// 3 3 6
//上一次值 当前值 返回值 （第三次循环 ）
// 6 4 10
//对象的reduce
const arr2 = [{
name: '张三',
salary: 10000
}, {
name: '李四',
salary: 10000
}, {
name: '王五',
salary: 20000
},
]
const total2 = arr2.reduce((prev,current)=>{
console.log(prev);
return prev + current.salary
},0)//初始值一定不能省略
console.log(total2);
//在使用 reduce 函数时，第二个参数是初始值，用于对第一次迭代时的 prev 进行初始化，如果没有初始值，第一次迭代时 prev 会是数组中的第一个元素。如果数组是空的，则没有初始值的 reduce 会报错。在这个例子中，初始值是 0，因为我们要对每个元素的薪水进行求和，如果不设置初始值，则第一次迭代时，prev 会是数组中的第一个对象，而不是一个数字，会导致加法运算无法进行。
</script>
数组其他常见实例方法
join：数组元素拼接为字符串，并返回字符串; join()结果是，隔开 ; join('')结果是无分隔。
find：查找元素，返回符合测试条件的第一个数组元素值，如果没有符合条件的返回undefined,
every：检测数组 所有 元素是否 都 符合指定条件，如果 所有元素 都通过检测则返回ture，否则返回false(空数组返ture),
some：检测数组元素是否符合指定条件，如果 有元素 满足条件则返回ture，否则返回false,
concat：合并两个数组，返回生成新数组,
sort：对原数组单元值排序,
splice：删除或替换原数组单元,
reverse：反转数组,
findIndex：查找元素的索引值
伪数组转化为真数组，静态方法：Array.from()
//find
<script>
//find方法接收一个回调函数，用于查找数组中符合条件的第一个元素。在这个例子中，isCherries函数作为回调函数传入，find方法会依次遍历inventory数组中的每一个元素，并将其作为参数传递给isCherries函数。当传入樱桃对象时，isCherries函数返回true，此时find方法停止遍历，并返回这个对象。如果没有符合条件的元素，则返回undefined。
const inventory = [
{ name: "apples", quantity: 2 },
{ name: "bananas", quantity: 0 },
{ name: "cherries", quantity: 5 },
];
function isCherries(fruit) {
return fruit.name === "cherries";
}
console.log(inventory.find(isCherries));
// { name: 'cherries', quantity: 5 }
const che = inventory.find(function (item) {
console.log(item.name);
return item.name === 'cherries'
})
console.log(che);
const che2 = inventory.find(item=>item.name === 'cherries')
console.log(che2);
</script>
//every
<script>
const arr = [1,2,3,4]
const flag = arr.every(item => item >= 10)
console.log(flag);
</script>
//拼接字符串，写入div
<script>
const spec = {size:'40cm*40cm',color:'hei'}
const div = document.createElement('div')
document.body.appendChild(div)
//思路：获得所有的属性值，然后拼接字符串。Object.values()->得到数组，再join拼接
div.innerHTML = Object.values(spec).join('/')
</script>
String
字符串常见实例方法
！length
！split('分隔符')将字符串拆分为数组
！substring(需要截取的第一个字符的索引[,结束的索引号])字符串截取
！startsWith(检测字符串[,检测位置索引号])检测是否以某字符开头
！Includes(搜索的字符串[,检测位置索引号])判断一个字符串是否包含在另一个字符串中，根据情况返回true或false
toUpperCase将字母转换为大写
toLowerCase将字母转换为小写
indexOf检测是否包含某字符
endsWith检测是否以某字符结尾
replace替换字符串，支持正则
Match查找字符串，支持正则
split
分隔符指的是字符串中的分隔符！
<script>
const str1 = '1,2,3,4,5'
console.log(str1.split(','));
const str2 = '1-2-3-4-5'
console.log(str2.split('-'));
</script>
substring
substring(需要截取的第一个字符的索引[,结束的索引号])字符串截取
[]内可省略，返回新字符串
<script>
const arr = 'abcdefghijk'
console.log(arr.substring(3));//defghijk
</script>
里面是索引号，从0开始。
164
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
