2023年JS学习记录

2023/1/30 星期一

https://blog.csdn.net/Augenstern_QXL/article/details/119249534

JS的组成

JavaScript 包括 ECMAScript、DOM、BOM
JavaScript语法页面文档对象模型浏览器对象模型

短路运算(逻辑中断)

短路运算的原理：当有多个表达式（值）时，左边的表达式值可以确定结果时，就不再继续运算右边的表达式的值

逻辑与 &&
逻辑或 ||

赋值运算符

流程控制

顺序结构

分支结构

if语句
if else语句
if else if语句
三元表达式
switch表达式

循环结构

for循环
while循环
do while循环（先执行一次循环体代码，再执行表达式，循环）
continue关键字，立即跳出本次循环
break关键字，立即跳出整个循环

数组

创建数组

new Array()
数组字面量 let arr=[1,2,3]

数组索引（下标）

遍历数组

数组长度

数组新增元素

修改length长度
修改数组索引

2023/1/31 星期二

https://blog.csdn.net/Augenstern_QXL/article/details/119250991

函数

函数的使用

声明函数 function 函数a()
调用函数函数a()

函数的参数

形参 - 函数定义
实参 - 函数调用

实参个数小于形参个数，多的形参定义为undefined，结果为Nah

函数返回值 return

return把自身后面的值返回给调用者。没有return，返回undefined。
return 终止函数。
return只返回一个值，以最后一个为准。

break，continue，return的区别

arguments 对象

所有函数都内置的一个对象，存储了传递的所有实参。
伪数组。

函数的声明方式

自定义函数（命名函数） function fn(){}
函数表达式（匿名函数） var fn=function(){}

作用域

作用域分类

全局作用域 script标签内部/独立的js文件
局部（函数）作用域
块级作用域 {}

变量的作用域

全局变量
局部变量

作用域链

作用域链: 内部函数访问外部函数的变量，采取的是链式查找的方式来决定取哪个值，这种结构我们称为作用域链表
就近原则。

预解析

js引擎会把js里面所有的 var 还有 function 提升到当前作用域的最前面。

变量提升

变量的赋值不会提升。

函数提升

2023/2/1-2/2 星期三、四

https://blog.csdn.net/Augenstern_QXL/article/details/119250137

对象

无序的相关属性和方法的合集。

对象类型

自定义对象
内置对象，Math、Date、Array等等
浏览器对象

创建对象

对象字面量
new Object
构造函数 (new 关键字创建对象的过程我们称为对象实例化)

对象的调用

object.name
object['name']
object.sayHi()

构造函数

new 在执行时会做四件事:

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

遍历对象方法 for in

let obj = { name: 'amy' }
for (const key in obj) {
    console.log(key);       // key是属性
    console.log(obj[key]);  //obj[key]是属性值
}

Math对象（非构造函数，不需要实例化）

常用方法

// Math数学对象，不是一个构造函数，所以我们不需要new 来调用，而是直接使用里面的属性和方法即可

Math.PI                 // 圆周率
Math.floor()            // 向下取整
Math.ceil()             // 向上取整
Math.round()            // 四舍五入版 就近取整   注意 -3.5   结果是  -3 
Math.abs()              // 绝对值
Math.max()/Math.min()   // 求最大和最小值 

Math.random()           //随机返回一个小数，其取值范围是 [0，1)，左闭右开 0 <= x < 1

Date对象（构造函数，需要实例化）

获取当前时间

let now = new Date();
// Thu Feb 02 2023 13:51:35 GMT+0800 (中国标准时间)

Date()构造函数的参数

有参数，则返回参数里面的时间。
2种参数形式。

//数字型
let date1 = new Date(2023, 2, 2)
//字符串型
let date1 = new Date("2023/2/2")

手动获取年月日时分秒

getFullYear()
getMonth()
getDate()
getDay()
getHours()
getMinutes()
getSeconds()

数组对象

创建数组对象

字面量
new Array()

判断是否为数组

var arr = [1, 23];

console.log(arr instanceof Array); // true
console.log(Array.isArray(arr));   // true

添加或者删除数组元素

数组末尾：push，pop
数组开头：unshift，shift

数组排序

reverse() 颠倒原数组
sort() 对原数组排序

数组索引

indexOf()
lastIndexOf()

数组转化为字符串

toString()
join('分隔符') 把数组中的所有元素转换为一个字符串

数组截取，合并

concat()
slice()
splice()

字符串对象

字符串的操作方法

concat()
substr(start, length) //从 start 位置开始(索引号), 取length 个字符。
slice()
substring(start, end) //从 start 位置开始，截取到 end 位置，end 取不到 (基本和 slice 相同，但是不接受负)
replace('被替换的字符', '替换为的字符')

//只会替换第一个字符
var str = 'andyandy';
console.log(str.replace('a','o'));
// 'ondyandy'

split('分隔符') //将字符串切分我数组
toUpperCase()
toLowerCase()

数据类型

值类型：简单数据类型/基本数据类型，在存储时变量中存储的是值本身，因此叫做值类型
string ，number，boolean，undefined，null。
简单数据类型存放到栈里面。
引用类型：复杂数据类型，在存储时变量中存储的仅仅是地址（引用），因此叫做引用数据类型
通过 new 关键字创建的对象（系统对象、自定义对象），如 Object、Array、Date等
复杂数据类型存放到堆里面。

2023/2/3 星期五

https://blog.csdn.net/Augenstern_QXL/article/details/115416921

DOM

获取元素

根据ID

document.getElementById('id')

根据标签名

// 返回带有指定标签名的对象的集合
document.getElementsByTagName('id')

// 还可以根据标签名获取某个元素（父元素）内部所有指定标签名的子元素，获取的时候不包括父元素自己
ol.getElementsByTagName('li');

通过 HTML5 新增的方法获取

// 返回元素对象合集
document.getElementsByClassName('类名'); 
// 返回第一个元素对象
document.querySelector('.box');
// 返回所有元素对象
document.querySelectorAll('选择器');

特殊元素获取

// 获取body元素
document.body;
// 获取html元素
document.documentElement;

事件

执行事件的步骤

<script>
    // 执行事件步骤
    // 点击div 控制台输出 我被选中了
    // 1. 获取事件源
    var div = document.querySelector('div');
    // 2.绑定事件 注册事件
    // div.onclick 
    // 3.添加事件处理程序 
    div.onclick = function() {
        console.log('我被选中了');
    }
</script>

回调函数

普通函数是按照代码顺序直接调用，而比如setTimeout函数，需要等待事件，事件到了才会去调用这个函数，因此称为回调函数。

鼠标事件

绑定事件（注册事件）

注册事件有2种方法

传统：<button onclick = 'alert(1)'></button>
同一个元素同一个事件只能设置一个处理函数，后面注册的会覆盖前面的。
方法监听：addEventListener() IE9之前使用 attachEvent()
同一个元素同一个事件可以注册多个监听器，按注册顺序依次执行。

addEventListener()

eventTarget.addEventListener(type,listener,[useCapture])

btns[1].addEventListener('click', function() {
            alert(22);
        })

type:事件类型字符串，比如click,mouseover,注意这里不要带on
listener：事件处理函数，事件发生时，会调用该监听函数
useCapture：可选参数，是一个布尔值，默认是 false。 true 则处于捕获阶段，false 则处于冒泡阶段。

删除事件

removeEventListener()

eventTarget.removeEventListener(type,listener,[useCapture])

事件流

事件流描述的是从页面中接收事件的顺序。
3个阶段：

捕获阶段（外到内）
当前目标阶段
冒泡阶段（内到外）

JS 代码中只能执行捕获或者冒泡其中的一个阶段。

事件对象

eventTarget.onclick = function(event) {
   // 这个 event 就是事件对象，我们还喜欢的写成 e 或者 evt 
} 
eventTarget.addEventListener('click', function(event) {
   // 这个 event 就是事件对象，我们还喜欢的写成 e 或者 evt  
})

事件发生后，跟事件相关的一系列信息数据的集合都放到这个对象里面。

这个对象就是事件对象 event，它有很多属性和方法，比如

谁绑定了这个事件
鼠标触发事件的话，会得到鼠标的相关信息，如鼠标位置
键盘触发事件的话，会得到键盘的相关信息，如按了哪个键

这个 event 是个形参，系统帮我们设定为事件对象，不需要传递实参过去。

当我们注册事件时， event 对象就会被系统自动创建，并依次传递给事件监听器（事件处理函数）

事件对象兼容性

e = e || window.event;

事件对象的常用属性和方法

e.target 返回触发事件的对象
e.preventDeafult 阻止默认行为，让链接不跳转或者让提交按钮不提交
e.stopPropagation() 阻止冒泡

e.target 和 this 的区别：

this 是事件绑定的元素，这个函数的调用者（绑定这个事件的元素）
e.target 是事件触发的元素。

事件委托

不在每个子节点单独设置事件监听器，而是把事件监听器设置在其父节点上，利用冒泡原理影响设置的每一个子节点。

鼠标事件

常用鼠标事件

onclick, onmouseover, onmouseout, onfocus, onblur ...
禁止鼠标右键

document.addEventListener('contextmenu', function(e){
    e.preventDefault();
})

禁止鼠标选中
document.addEventListener('selectstart', function(e){
e.preventDefault();
})

鼠标事件对象

返回鼠标相对于浏览器窗口可视区的坐标 e.clientX e.clientY
返回鼠标相对于文档页面的坐标 IE9+ 支持 e.pageY e.pageX
返回鼠标相对于电脑屏幕的坐标 e.screenX e.screenY

键盘事件

常用键盘事件

onkeyup, onkeydown, onkeypress
onkeypress 和前面2个的区别是，它不识别功能键，比如左右箭头，shift 等
三个事件的执行顺序是： keydown – keypress — keyup

键盘对象属性 keyCode

onkeydown和 onkeyup 不区分字母大小写，onkeypress 区分字母大小写。
更多的使用keydown和keyup，它能识别所有的键（包括功能键）。
keyCode属性能区分大小写，返回不同的ASCII值

元素

改变元素内容

// innerText 和 innerHTML的区别 

/ 1. innerText 不识别html标签,去除空格和换行
div.innerText = '<strong>今天是：</strong> 2019';

// 2. innerHTML 识别html标签 保留空格和换行的
div.innerHTML = '<strong>今天是：</strong> 2019';
// 这两个属性是可读写的  可以获取元素里面的内容

改变元素属性（常见元素，表单元素）

input.value = **
input.checked = **
input.type = **

改变样式属性

js里的样式用驼峰命名法

div.style.backgroundColor = **
div.style.width = **

// 当前元素的类名改为了 change
div.className = 'change'

自定义属性

element.setAttribute('属性','值');
element.removeAttribute('属性');

H5自定义属性

设置

H5规定自定义属性 data-开头作为属性名并赋值。

<div data-index = "1"></>
// 或者使用JavaScript设置
div.setAttribute('data-index',1);

获取

兼容性获取 element.getAttribute('data-index')
H5新增的：element.dataset.index 或element.dataset['index'] IE11才开始支持

节点

网页中的所有内容都是节点（标签、属性、文本、注释等），在DOM 中，节点使用 node 来表示。
HTML DOM 树中的所有节点均可通过 JavaScript 进行访问，所有 HTML 元素（节点）均可被修改，也可以创建或删除。

节点基本属性

一般的，节点至少拥有nodeType（节点类型）、nodeName（节点名称）和nodeValue（节点值）这三个基本属性。

元素节点：nodeType 为1
属性节点：nodeType 为2
文本节点：nodeType 为3(文本节点包括文字、空格、换行等)

父级节点

div.paranetNode 离元素最近的父级节点(亲爸爸) 如果找不到父节点就返回为 null

子节点

parentNode.childrenNodes 返回包含指定节点的子节点的集合，返回值包含了所有的子结点，包括元素节点，文本节点等
parentNode.children 只读属性，返回所有的子元素节点，只返回子元素节点，其余节点不返回

ul.childrenNodes[0].nodeType

parentNode.firstChild 返回第一个子节点（包含所有的节点），找不到则返回null，
parentNode.lastChild 同上

以下返回元素节点（不包含属性和文本），但有兼容性，IE9以上支持：
parentNode.firstElementChild
parentNode.lastElementChild

获取第一个/最后一个子元素节点

parentNode.children[0]
parentNode.children[parentNode.children.length-1]

兄弟节点

node.nextSibling 所有节点，null
node.previousSibling 所有节点，null

以下返回元素节点（不包含属性和文本），但有兼容性，IE9以上支持：
node.nextElementSibling
node.previousElementSibling

解决兼容性问题

function getNextElementSibling(element) {
    var el = element;
    while(el = el.nextSibling) {
        if(el.nodeType === 1){
            return el;
        }
    }
    return null;
}

创建节点

document.createElement('tagName');

三种动态创建元素的区别

doucument.write()
element.innerHTML
document.createElement()

document.write() 是直接将内容写入页面的内容流，但是文档流执行完毕，则它会导致页面全部重绘
innerHTML 是将内容写入某个 DOM 节点，不会导致页面全部重绘
创建多个元素效率更高（不要拼接字符串，采取数组形式拼接），结构稍微复杂
createElement()创建多个元素效率稍低一点点，但是结构更清晰

<body>
    <div class="innner"></div>
    <div class="create"></div>
    <script>
        // 2. innerHTML 创建元素
        var inner = document.querySelector('.inner');
        // 2.1 innerHTML 用拼接字符串方法
        for (var i = 0; i <= 100; i++) {
            inner.innerHTML += '<a href="#">百度</a>';
        }
        // 2.2 innerHTML 用数组形式拼接
        var arr = [];
        for (var i = 0; i <= 100; i++) {
            arr.push('<a href="#">百度</a>');
        }
        inner.innerHTML = arr.join('');

        // 3.document.createElement() 创建元素
        var create = document.querySelector('.create');
        var a = document.createElement('a');
        create.appendChild(a);
    </script>
</body>

添加节点

node.appendChild(child) 添加到指定父节点的子节点列表末尾
node.insertBefore(child,指定元素) 添加到父节点的指定子节点前面

删除节点

node.removeChild(child)

克隆/复制节点

node.cloneNode()

2023/2/9 星期四

https://blog.csdn.net/Augenstern_QXL/article/details/115406408

BOM 浏览器对象模型

与浏览器窗口进行交互的对象，其核心对象是 window

BOM构成

顶级对象是window，
下级有 document，location，navigation，screen，history。
调用方法可以省略window，window下的一个特殊属性 window.name。

window常用事件

window.onload 页面内容全部加载完毕，再去执行处理函数，只写一次，多个以最后一个为准

window.onresize 只要窗口大小发生像素变化，就会触发这个事件
window.innerWidth 当前屏幕的宽度

定时器

setTimeOut()

定时器到期后执行。

function callback() {
            console.log('爆炸了');
            }
var timer1 = setTimeout(callback, 3000);

清除定时器 clearTimeOut()

<body>
    <button>点击停止定时器</button>
    <script>
        var btn = document.querySelector('button');
        var timer = setTimeout(function() {
            console.log('爆炸了');
        }, 5000);
        btn.addEventListener('click', function() {
            clearTimeout(timer);
        })
    </script>
</body>

setInterval()

重复调用一个函数，每隔这个时间，就去调用一次回调函数。
清除定时器 clearInterval()

this指向

全局作用域或者普通函数中this指向全局对象window(注意定时器里面的this指向window)
方法调用中谁调用this指向谁
构造函数中this指向构造函数实例

JS执行机制

JS是单线程。
所有任务需要排队，前一个任务结束，才会执行后一个任务。这样所导致的问题是：如果 JS 执行的时间过长，这样就会造成页面的渲染不连贯，导致页面渲染加载阻塞的感觉。

同步和异步

HTML5 提出 Web Worker 标准，允许 JavaScript 脚本创建多个线程，于是，JS 中出现了同步和异步。

JS中的异步是通过回调函数实现的。

异步任务有以下三种类型：

普通事件，如click,resize等
资源加载，如load,error等
定时器，包括setInterval,setTimeout等

事件循环

同步任务放在执行栈中执行，异步任务由异步进程处理放到任务队列中，执行栈中的任务执行完毕会去任务队列中查看是否有异步任务执行，由于主线程不断的重复获得任务、执行任务、再获取任务、再执行，所以这种机制被称为事件循环（ event loop）。

location对象

获取或者设置窗体的url，并且可以解析url

url

统一资源定位符（uniform resouce locator），互联网上标准资源的地址。互联网上的每个文件都有一个唯一的 URL，它包含的信息指出文件的位置以及浏览器应该怎么处理它。

语法格式：protocal://host[:port]/pat/[?query]#fragment

location对象属性

location.href
location.host port pathname hash(返回片段，常用于链接锚点)
location.search(参数)

location对象方法

location.assign() 跟href一样，可以跳转页面（也称为重定向页面）
location.replace()
location.reload() 重新加载页面，相当于刷新按钮或者 f5 ，如果参数为true 强制刷新 ctrl+f5

获取url参数

<body>
    <div></div>
    <script>
        console.log(location.search); // ?uname=andy
        // 1.先去掉？  substr('起始的位置'，截取几个字符);
        var params = location.search.substr(1); // uname=andy
        console.log(params);
        // 2. 利用=把字符串分割为数组 split('=');
        var arr = params.split('=');
        console.log(arr); // ["uname", "ANDY"]
        var div = document.querySelector('div');
        // 3.把数据写入div中
        div.innerHTML = arr[1] + '欢迎您';
    </script>
</body>

navigator对象

history对象

history对象方法

back()
forward()
go(参数) 前进后退功能，参数如果是 1 前进1个页面如果是 -1 后退1个页面

2023/2/13 星期一

https://blog.csdn.net/Augenstern_QXL/article/details/115219073

面向对象

抽取，封装
实例化，获取

对象

类

构造函数

类中添加方法

class Person {
  constructor(name,age) {   
      // constructor 称为构造器或者构造函数
      this.name = name;
      this.age = age;
    }
   say() {
      console.log(this.name + '你好');
   }
}      
var ldh = new Person('刘德华', 18); 
ldh.say()

注意：方法之间不能加逗号分隔，同时方法不需要添加 function 关键字。
类的共有属性放到constructor 里面

类的继承

super 关键字用于访问和调用对象父类上的函数

super 必须在子类this之前调用

原型

构造函数原型 prototype

每一个构造函数都有一个prototype属性，指向另一个对象，注意这个prototype就是一个对象，这个对象的所有属性和方法，都会被构造函数所拥有。

原型是一个对象，我们也称为 prototype 为原型对象。

原型的作用是共享方法。

对象原型 proto

对象都会有一个属性 proto 指向构造函数的prototype原型对象，之所以我们对象可以使用构造函数prototype 原型对象的属性和方法，就是因为对象有_proto_原型的存在。

_proto_对象原型和原型对象 prototype 是等价的

_proto_对象原型的意义就在于为对象的查找机制提供一个方向，或者说一条路线，但是它是一个非标准属性，因此实际开发中，不可以使用这个属性，它只是内部指向原型对象 prototype

原型链查找规则

原型对象this指向

this指向的是这个方法的调用者，也就是这个实例对象

ES5新增方法

数组方法

遍历方法
forEach 没有return
map
some 如果找到第一个满足条件的元素，则终止循环，不再继续查找
every
filter
字符串方法
trim 从一个字符串的两端删除空白字符，返回新字符
对象方法
Object.keys() 获取对象自身所有的属性，类似for...in，返回数组
Object.defineProperty() 定义对象中新属性或修改原有的属性(了解)

2023/2/14 星期二

https://blog.csdn.net/Augenstern_QXL/article/details/115344398

严格模式

为脚本开启严格模式在所有语句之前放
为函数开启严格模式声明放在函数体所有语句之前

<body>
    <!-- 为整个脚本(script标签)开启严格模式 -->
    <script>
        'use strict';
        //   下面的js 代码就会按照严格模式执行代码
    </script>
    <script>
        (function() {
            'use strict';
        })();
    </script>
    <!-- 为某个函数开启严格模式 -->
    <script>
        // 此时只是给fn函数开启严格模式
        function fn() {
            'use strict';
            // 下面的代码按照严格模式执行
        }

        function fun() {
            // 里面的还是按照普通模式执行
        }
    </script>
</body>

严格模式中的变化

变量规定
变量声明后再使用。不能删除已经声明的变量。
严格模式下this指向问题
严格模式下全局作用域中函数中的this 是 undefined。
构造函数不加 new 调用，this指向的是 undefined
函数变化
函数不能有重名的参数。
函数必须声明在顶层。

高阶函数

对其他函数进行操作的函数，它接收函数作为参数或将函数作为返回值输出

function fn(a, b, callback) {
    console.log(a + b);
    callback && callback();
}

function fn(){
    return function() {}
}

闭包

闭包指有权访问另一个函数作用域中的变量的函数

简单理解：一个作用域可以访问另外一个函数内部的局部变量

<body>
    <script>
        // 闭包（closure）指有权访问另一个函数作用域中变量的函数。
        // 闭包: 我们fn2 这个函数作用域 访问了另外一个函数 fn1 里面的局部变量 num
        function fn1() {		// fn1就是闭包函数
            var num = 10;
            function fn2() {
                console.log(num); 	//10
            }
            fn2();
        }
        fn1();
    </script>
</body>

变量作用域

全局变量，局部变量

闭包作用

延伸变量的作用范围

递归

一个函数在内部可以调用其本身，那么这个函数就是递归函数。

由于递归很容易发生"栈溢出"错误，所以必须要加退出条件 return。

浅拷贝和深拷贝

浅拷贝只是拷贝一层，更深层次对象级别的只拷贝引用

深拷贝拷贝多层，每一级别的数据都会拷贝

浅拷贝

// 浅拷贝只是拷贝一层，更深层次对象级别的只拷贝引用
var obj = {
    id: 1,
    name: 'andy',
    msg: {
        age: 18
    }
};
var o = {}
for(var k in obj){
    // k是属性名，obj[k]是属性值
    o[k] = obj.[k];
}
console.log(o);
// 浅拷贝语法糖
Object.assign(o,obj);

深拷贝

function deepClone(obj) {
  //判断传进来的参数类型不是对象数组 或者是null时 直接返回
  if (typeof obj !== "object" || obj == null) {
    return obj
  }
  //定义返回值
  let result;
  // 判断传进来的数据类型 是数组/对象 就给result一个数组/对象
  if (obj instanceof Array) {
    result = []
  } else {
    result = {}
  }
  //循环遍历方便拷贝
  for (let key in obj) {
    //判读自有属性
    if (obj.hasOwnProperty(key)) {
      //函数递归实现深层拷贝
      result[key] = deepClone(obj[key])
    }
  }
  //返回出去
  return result
}

正则表达式

创建正则表达式

调用 RegExp 对象的构造函数创建
字面量创建

var 变量名 = new RegExp(/表达式/);
var 变量名 = /表达式/;

test()

检测字符串是否符合该规则，该对象会返回true或false，其参数是测试字符串

let regexObj = /123/
regexObj.test('123456')

正则表达式中的特殊在字符

边界符

^ 表示匹配行首的文本(以谁开始)
$ 表示匹配行尾的文本(以谁结束)

^ 和 $ 在一起，表示必须是精确匹配

字符类

字符类表示有一系列字符可供选择，只要匹配其中一个就可以了
所有可供选择的字符都放在方括号内

①[] 方括号

/[abc]/.test('andy');     // true

后面的字符串只要包含 abc 中任意一个字符,都返回true

②[-]方括号内部范围符

/^[a-z]$/.test()

方括号内部加上 - 表示范围，这里表示 a - z 26个英文字母都可以

③[^] 方括号内部取反符 ^

/[^abc]/.test('andy')   // false

方括号内部加上 ^ 表示取反，只要包含方括号内的字符，都返回 false

注意和边界符 ^ 区别，边界符写到方括号外面

④字符组合

/[a-z1-9]/.test('andy')    // true

方括号内部可以使用字符组合，这里表示包含 a 到 z的26个英文字母和1到9的数字都可以

量词符

* 重复零次或更多次
+ 重复一次或更多次
? 重复零次或一次
{n} 重复n次
{n,} 重复n次或更多次
{n,m} 重复n到m次

括号总结

大括号量词符里面面表示重复次数

中括号字符集合匹配方括号中的任意字符

小括号表示优先级

预定义类

\d 匹配0-9之间的任一数字，相当于[0-9]
\D 匹配所有0-9以外的字符，相当于[ ^ 0-9]
\w 匹配任意的字母、数字和下划线,相当于[A-Za-z0-9_ ]
\W 除所有字母、数字、和下划线以外的字符，相当于[ ^A-Za-z0-9_ ]
\s 匹配空格（包括换行符，制表符，空格符等），相当于[\t\t\n\v\f]
\S 匹配非空格的字符，相当于[ ^ \t\r\n\v\f]

正则表达式参数

g: 全局匹配
i: 忽略大小写
gi: 全局匹配 + 忽略大小写

let reg = /amy/i

replace() 替换

第一个参数: 被替换的字符串或者正则表达式

第二个参数：替换为的字符串

返回值是一个替换完毕的新字符串

var str = 'andy和red';
var newStr = str.replace('andy','baby');
var newStr = str.replace(/andy/,'baby');

posted @ 2023-02-01 15:35 杰克不爱阅读(118) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 2023年uniapp学习记录

· Javascript基础（三）

· JavaScript

· 新的前端面试题

· javascript学习

公告

昵称：杰克不爱
园龄： 2年1个月
粉丝： 0
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六