前端入门（一）JavaScript语法、数据类型、运算、函数

前端入门（一）JavaScript语法、数据类型、运算、函数
文章目录
概念
- JavaScript是用于浏览器交互操作的脚本语言。
- 为了确保不同的浏览器上运行的JavaScript标准一致，所以几个公司共同制定了JS的标准命名为ECMAScript
JavaScript编写的位置
- 写在HTML中的script标签中
- 写在.js文件中，然后在script标签中使用src引入
- 写在按钮标签的"onclick"属性中
- 写在超链接标签"href"属性中
JS既有专门的.js文件，在html文件中使用script标签，添加src属性引入js文件，也可在html文件中直接使用，用script标签，script标签必须成对出现

三个简单的JavaScript语句：
- alert(“弹窗信息”)：控制浏览器弹出一个警告框
- document.write()：让计算机在页面中输出一个内容，即向body输出一个内容
- console.log(“控制台输出内容”)：向控制台输出一个内容
js代码也可以写在标签的属性中，但是他们属于结构与行为耦合，不方便维护。

基本语法
- JS中严格区分大小写
- JS中每一条语句都以分号（；）结尾，如果不写分号，浏览器会自动添加，但是会消耗一定的系统资源
- JS中忽略多个空格和换行
JS中只有var类型变量，语句类似于Java。
在浏览器中调试JS需要注意：

Element：元素（html框架）
Console：命令控制台，如console.log(“”/var)，控制台输出，相当于print
Sources：源码
Network：抓包
Application：应用，查看缓存等

 数据类型

JS中共有6大数据类型：
- number：数字类型，JS中不分小数和整数
- string：字符串类型
- boolean：布尔值类型
- object：对象类型
- function：函数类型
- undefined：未定义类型
使用 JavaScript 的 typeof 来确定 JavaScript 变量的类型：
使用instanceof()返回对应类型对象的实例。

变量声明var、let、const

let和const是ES6新增的关键字
var、let、const的区别在于：
- let和var用来声明变量，而const用来声明常量，但是const声明的引用类型是可以改变的
- var是函数作用域，let是块作用域
  - var是函数作用域，在整个函数内都是有效的，在for循环内定义一个var变量，实际上在for循环外，函数内，都是可以访问的
  - let和const是块级作用域，只在代码块内有效，例如for循环内定义的，for循环外不可访问。所谓块级作用域，就是用{}包含的区域，我们常用的有for，while，if等。但是在块级作用域中用let声明变量，那么此变量就有了块级作用域，就必须只有在此块级作用域才能访问此变量。
  - const实际保证的并不是变量的值不可变，而是变量指向的内存地址不可变，有点类似Java中的final，因此，对象不可变，对象的属性是可变的。
  - 如果在全局作用域使用var声明变量，此变量会默认成为window的一个属性
  - var声明的变量有变量提升特性，let声明则没有这个特性，所谓变量提升，就是js引擎把变量的声明部分和函数的声明部分提升到代码开头的行为；变量提升后，会给变量默认赋值为undefined
例如下边代码：
```
console.log(a)
var a = 1
1
2
```
这里会打印undefined，这是因为变量提升后，实际代码是下边这个样子：
```
var a
console.log(a)
a = 1
1
2
3
```
undefined与null的区别
- undefined表示只定义了变量，并没有给变量赋值
- null表示数值为空值，给变量赋了null
undefined 与 null 值相等，但类型不相等

注意：
- == 表示值相等，使用===表示值和类型都相等
- ！= 表示值不相等，使用！==表示值或者类型不相等
```
typeof undefined              // undefined
typeof null                   // object
null === undefined            // false
null == undefined             // true
1
2
3
4
```
数值类型number

Js中只有一种数值类型
写数值时，不用小数点即可，超大或者超小的数使用科学计数法
```
var x1 = 34.00;     // 带小数点
var x2 = 34;        // 不带小数点
var y = 123e5;      // 12300000
var z = 123e-5;     // 0.00123
1
2
3
4
```
字符串类型string
- 字符串类型用单引号或者双引号包裹
- 可以使用转译字符’'，或者字符模板${变量名}，在字符串中引用字符串
- JS中的字符串是不可变的
JS中数值和字符串相加时，JS将把数值视为字符串：
```
var x = 911 + "Porsche"; // "911Porsche"
var x = "Porsche" + 911; // "Porsche911"
var x = 911 + 7 + "Porsche";  // "918Porsche"
var x = "Porsche" + 911 + 7; // "Porsche9117"
1
2
3
4
```
Js中可以使用模板字符串
```
let name = "lzy";
let hello = "你好鸭！ ${name}";
1
2
```
- 字符串长度：每个字符串都有length属性，str.length
- 字符串转换为大写：str.toUpperCase()
- 字符串转换为小写：str.toLowerCase()
- 获取某个字符（‘a’）所在位置：str.indexOf(‘a’)
- 截取字符串：str.substr(1)，从第一个字符串截取到最后，str.substr(1,3)，截取[1,3)
- 特殊字符：
- 更多字符串方法：
数组

1、创建一个数组：
- 常规方式，新建数组
```
var myCars=new Array();
myCars[0]="Saab";      
myCars[1]="Volvo";
myCars[2]="BMW";
1
2
3
4
```
- 简洁方式，利用构造函数：
```
var myCars = new Array("Saab","Volvo","BMW");
1
```
- 字面值方式，直接用中括号初始化赋值：
```
var myCars=["Saab","Volvo","BMW"];
1
```
2、数组常用api
- 返回数组长度：arr.length
- 通过元素获取下标：arr.indexof(“Saab”)
- 截取数组的一部分，返回给一个新数组：arr.slice(left)，arr.slice(left, right);
- 向数组尾部压入或者弹出一个元素，push(),pop()
- 向数组头部插入或者弹出一个元素，unshift()，shift()
- 排序：sort(）
- 反转：reverse()
- 数组合并：arr1.concat(arr2); 注意：concat没有修改数组，会返回一个新的数组。
- join()，打印拼接数组，使用特定的字符将数组拼接为字符串。
- 多维数组。
Date

Date（timestamp）可由时间戳返回时间

 Map和Set

创建一个map：
```
var map = new Map([['Tom', 18], ['jack', 19], ['haha', 80]]);
var name = map.get('Tom');  // 查找
map.set('admin');  // 新增或者修改
map.delete('Tom');  // 删除
1
2
3
4
```
Set：无序无重复的集合
```
set.add(2);
set.delete(1);
console.log(set.has(3));
1
2
3
```
对象属性

对象声明用花括号：
```
var car = {name:"fiat", model:500, color:"white"};
1
```
也可多行使用：
```
var person = {
    firstName:"John",
    lastName:"Doe",
    age:50,
    eyeColor:"blue"
};
1
2
3
4
5
6
```
类型转换

JS中有6种不同的数据类型：
- string
- number
- boolean
- object
- function
- symbol
3种对象类型：
- Object
- Data
- Array
2种不包含任何值的类型
- undefined
- null
类型转换常用API：
- number转为string：
  - 1、使用String(）：String(x)，String(123)
  - 2、使用number方法的toString()
- 布尔转为字符串
  - false.toString()
  - true.toString()
  - String(false)
  - String(true)
- 日期转为字符串
  - String(new Data())
函数

 函数定义
- 定义方式1：使用function声明
```
function abs(x) {
	if (x >= 0) {
	return x
	} else {
		return -x;
	}
}
1
2
3
4
5
6
7
```
- 定义方式2：匿名函数赋值
```
var abs = function(x) {
	if (x >= 0) {
		return x;
	} else {
		return -x;
	}
}
1
2
3
4
5
6
7
```
- 定义方式3：Function()构造函数
```
var mul = new Function("a", "b", "return a * b");
var x = mul(4, 3); // 12
1
2
```
函数参数

ES5 中如果函数在调用时未提供隐式参数，参数会默认设置为： undefined

有时这是可以接受的，但是建议最好为参数设置一个默认值：
```
function myFunction(x, y) {
    if (y === undefined) {
          y = 0;
    } 
}
1
2
3
4
5
```
或者，更简单的方式：
```
function myFunction(x, y) {
    y = y || 0;
}
1
2
3
```
ES6 函数可以自带参数
ES6 支持函数带有默认参数，就判断 undefined 和 || 的操作：
```
function myFunction(x, y = 10) {
    // y is 10 if not passed or undefined
    return x + y;
}
 
myFunction(0, 2) // 输出 2
myFunction(5); // 输出 15, y 参数的默认值
1
2
3
4
5
6
7
```
```
function myFunction(x, y = 10) {
    // y is 10 if not passed or undefined
    return x + y;
}
 
myFunction(0, 2) // 输出 2
myFunction(5); // 输出 15, y 参数的默认值
1
2
3
4
5
6
7
```
arguments对象

arguments 对象包含了函数调用的参数数组。

通过这种方式你可以很方便的找到最大的一个参数的值：
```
x = findMax(1, 123, 500, 115, 44, 88);
 
function findMax() {
    var i, max = arguments[0];
    
    if(arguments.length < 2) return max;
 
    for (i = 0; i < arguments.length; i++) {
        if (arguments[i] > max) {
            max = arguments[i];
        }
    }
    return max;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
```
变量的作用域
- let声明变量，作用于代码块
- var声明变量，作用于函数内
对象和函数同样也是变量，变量在函数内声明为局部变量，具有局部作用域。

变量在函数外定义，即为全局变量，全局变量具有全局作用域，网页和所有脚本和函数中均可以使用。
```
var carName = " Volvo";
 
// 此处可调用 carName 变量
function myFunction() {
    // 函数内可调用 carName 变量
}
1
2
3
4
5
6
```
方法的定义与调用
```
var person = {
    name: "lzy",
    birth: 1999,
    age: function () {
        var y = new Date().getFullYear();
        return y - this.birth;
    }
}

console.log(person.age());
console.log(person.name);
1
2
3
4
5
6
7
8
9
10
11
```
apply

可以使用apply，将方法应用到某个对象上：

方法.apply（对象1，参数）
apply修饰方法，可以将方法中的this指向为apply的第一个参数，对象名，apply的第二的参数是给方法输入参数赋值
```
function getAge() {
    var now = new Date().getFullYear();
    return now - this.birth;
}

console.log(getAge.apply(person));
1
2
3
4
5
6
```
注意这里getAge的调用没有()，apply是函数对象的一个方法。

call

call与apply非常像，区别在于当函数有参数时，apply传入的是参数列表数组，而call，直接按顺序填入参数。

JS常用API操作

 对象操作

 对象增删改查
- 创建对象 let obj = {}
- 新增属性 obj.a = 1 、obj[a] = 1
- 修改属性 obj.a = ‘a’
- 查询属性 obj.a 、obj[a]
- 删除属性 delete obj.a
注：对象的key属性也可以是数字，当为数字时，只能使用中括号[]访问。

对象遍历：
```
for (const key in obj) {
	console.log(key + "=" obj[key]);
}
1
2
3
```
js深拷贝、浅拷贝

js中对象直接使用=赋值拷贝是浅拷贝，即赋值前后的对象是相关关联的，如果修改其中一个的属性，另外一个属性也会变。

js实现深拷贝的方式
- 使用Object.assign(des, src)函数，给目标赋值属性，其中des是目标对象，src是源对象。
```
let user1 = {};
user1.name = "小米";
user1.age = 18;
user1.sex = "女";

let teacher1 = {};
Object.assign(teacher1, user1);
// 也可合并上边两句为一句
let teacher2 = Object.assign({}, user1);
1
2
3
4
5
6
7
8
9
```
- 使用jscon序列化对象再parse的方式也是可以实现深拷贝的。
```
let teacher3 = JSON.parse(JSON.stringify(user1));
1
```
安全访问

?
```
let a = {};
let b = a?.x;  // 如果a是undefined或者null，b则是undefined，不会报错
1
2
```
??
```
let a = null;
let b = 1;
let c = a ?? b;  // 如果a为null或者undefined则用b赋值，否则用a赋值
console.log(c);  // 打印c为1
1
2
3
4
```
例子：从localStorage拿出一个对象，对象可能为空，此时赋值默认值。
```
let d = localStorage.getItem('user') ?? {};  // 如果没有user字段，则赋值空
1
```
||

||类似??，但是??仅在前边是null或者undefined时，返回右边。
而||的含义是，在前边判断逻辑值为false时，返回右边，一般而言，0，null，undefined都是逻辑false。
```
const x = null;
const y = x ?? "default";
console.log(y); // null

const x = 0;
const y = x ?? 42;
console.log(y); // 0

const x = 0;
const y = x || 42;
console.log(y); // 42
1
2
3
4
5
6
7
8
9
10
11
```
数组操作

1、数组创建：
```
let arr1 = [];
let arr2 = new Array();
1
2
```
2、数组插入：
数组是一个动态数组，默认是有容量的，里边的内容是undefined。
```
arr3.push(1);
arr3[2] = 2;
1
2
```
3、数组删除：splice
- splice(left, right)：删除数组[left, right)之间的元素
- shift()：弹出数组头元素
- pop():弹出数组尾部元素
4、数组截取：slice
- slice(left, right) ：截取[left, right)之间的数组部分，并且返回一个新的数组，对原数组无影响。
5、数组合并：concat
arr1.concat(arr2)：将arr1与arr2数组合并，随后返回合并后的新数组，对原数组arr1和arr2并无影响。

6、数组排序：sort
arr.sort()，默认是按Unicode编码排序，最后使用lambda编写排序规则。

7、数组反转：reverse

8、数组过滤：filter
```
let users = [{name : "lzy", age : 20}, {name : "jhc", age : 24}];
let res1 = [];
user.forEach(aaa => {
	if (aaa.age > 20) {
		res1.push(aaa);
	}
})
console.log(res1);

// 用filter函数可以一句搞定
let res2 = users.filter(aaa => aa.age > 20);
console.log(res2);
1
2
3
4
5
6
7
8
9
10
11
12
```
9、数组查找：find、findIndex
```
let res = user.find(v => v.name === "lzy");
let resIdx = user.findIndex(v => v.name === "lzy");
1
2
```
10、数组映射修改：map
令每个名字都以#结尾
```
let names = user.map(v => "#" + v.name);
console.log(names);
1
2
```
11、数组归类：reduce
reduce（）方法最常见的场景就是，计算数组中的每一项的总和。

reduce方法遍历数组每一项，他接收两个参数：
- 参数1：每次遍历都会调用的函数，函数可以接收4个参数
  - 前一个值
  - 当前值
  - 项目索引
  - 数组对象
- 参数2：归并基础的初始值
```
 let arr = [1,2,3,4,5]
 arr.reduce((prev,cur)=>{
      return prev+cur
 })
 // 最后的结果就是累加每一项的值
1
2
3
4
5
```
上面的这段代码，是用来计算数组总和的，reduce（）方法中，只传了第一个参数，也就是只传了一个函数，但第二个参数、初始值没有传，当第二个值没有传的时候，第一次循环，prev的值，默认为数组的第一项，而cur的值为数组的第二项，也就是第一次循环，会return 1+2，这个时候，第一次循环返回的结果回传给下一次循环中方法的第一个参数，也就是说、第二次循环方法中prev的值，是第一次循环方法返回的结果.
```
let arr = [1,2,3,4,5]
arr.reduce((prev,cur)=>{
    return prev+cur
},10)
1
2
3
4
```
我们传入一下第二个参数，第一个循环，prev的值为reduce的第二个参数，也就是"归并基础的初始值"，而cur的值为数组的第一项，第一项循环会返回10+1。

JS类（未完）
```
class Runoob {
  constructor(name, url) {
    this.name = name;
    this.url = url;
  }
}
 
let site = new Runoob("菜鸟教程",  "https://www.runoob.com");
1
2
3
4
5
6
7
8
```
类继承
```
class Site {
  constructor(name) {
    this.sitename = name;
  }
  present() {
    return '我喜欢' + this.sitename;
  }
}
 
class Runoob extends Site {
  constructor(name, age) {
    super(name);
    this.age = age;
  }
  show() {
    return this.present() + ', 它创建了 ' + this.age + ' 年。';
  }
}
 
let noob = new Runoob("菜鸟教程", 5);
document.getElementById("demo").innerHTML = noob.show();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
```
DOM（Document Object Model，文档对象模型）

当网页被加载时，浏览器会创建页面的文档对象模型（Document Object Model，DOM）。HTML DOM 模型被构造为对象的树：

通过可编程的对象模型，JavaScript 获得了足够的能力来创建动态的 HTML：
- JavaScript 能够改变页面中的所有 HTML 元素
- JavaScript 能够改变页面中的所有 HTML 属性
- JavaScript 能够改变页面中的所有 CSS 样式
- JavaScript 能够对页面中的所有事件做出反应
查找HTML元素

通常，通过 JavaScript，您需要操作 HTML 元素。

为了做到这件事情，您必须首先找到该元素。有三种方法来做这件事：
- 1、通过 id 找到 HTML 元素
- 2、通过标签名找到 HTML 元素
- 3、通过类名找到 HTML 元素
```
var x=document.getElementById("intro");  // id查找

var x=document.getElementById("main");
var y=x.getElementsByTagName("p");  // 标签名查找

var x=document.getElementsByClassName("intro");  // 通过类名查找
1
2
3
4
5
6
```
改变HTML元素

1、改变HTML输出流

JavaScript 能够创建动态的 HTML 内容：

今天的日期是： Sat Nov 04 2023 17:25:41 GMT+0800 (中国标准时间)

在 JavaScript 中，document.write() 可用于直接向 HTML 输出流写内容。
```
<!DOCTYPE html><html>
	<body>
		<script>
		document.write(Date());
		</script>
	</body>
</html>
1
2
3
4
5
6
7
```
2、改变HTML内容
修改 HTML 内容的最简单的方法是使用 innerHTML 属性。
如需改变 HTML 元素的内容，请使用这个语法：
```
document.getElementById(id).innerHTML=新的 HTML
1
```
本例改变了 < p >元素的内容：
```
<html>
<body>
<p id="p1">Hello World!</p>
<script>
document.getElementById("p1").innerHTML="新文本!";
</script>
</body>
</html>
1
2
3
4
5
6
7
8
```
3、改变HTML属性
如需改变 HTML 元素的属性，请使用这个语法：document.getElementById(id).attribute=新属性值
本例改变了 < img > 元素的 src 属性：
```
<!DOCTYPE html><html>
<body>
<img id="image" src="smiley.gif">
<script>
document.getElementById("image").src="landscape.jpg";
</script>
</body>
</html>
1
2
3
4
5
6
7
8
```
改变CSS

如需改变 HTML 元素的样式，请使用这个语法：

document.getElementById(id).style.property=新样式
下面的例子会改变 < p > 元素的样式：
```
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>菜鸟教程(runoob.com)</title>
</head>
<body>
 
<p id="p1">Hello World!</p>
<p id="p2">Hello World!</p>
<script>
document.getElementById("p2").style.color="blue";
document.getElementById("p2").style.fontFamily="Arial";
document.getElementById("p2").style.fontSize="larger";
</script>
<p>以上段落通过脚本修改。</p>
</body>
</html>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
```
事件

HTML DOM 使 JavaScript 有能力对 HTML 事件做出反应，常见的事件有：
- 鼠标点击
- 页面加载
- 图像已经加载
- 鼠标移动到元素
- 输入字段改变
- 提交HTML表单
- 用户触发按键
在本例中，当用户在 < h1 > 元素上点击时，会改变其内容：
```
<!DOCTYPE html>
<html>
<body>
<h1 onclick="this.innerHTML='触发点击事件!'">点击文本!</h1>
</body>
</html>
1
2
3
4
5
6
```
本例从事件处理器调用一个函数：
```
<!DOCTYPE html><html>
<head>
<script>
function changetext(id)
{
    id.innerHTML="点击事件!";
}
</script>
</head>
<body>
<h1 onclick="changetext(this)">点击文本!</h1>
</body>
</html>
1
2
3
4
5
6
7
8
9
10
11
12
13
```
也可使用 HTML DOM 来分配事件：
```
<script>document.getElementById("myBtn").onclick=function(){displayDate()};
	</script>
1
2
```
onload 和 onunload 事件：
onload 和 onunload 事件会在用户进入或离开页面时被触发。

onload 事件可用于检测访问者的浏览器类型和浏览器版本，并基于这些信息来加载网页的正确版本。

onload 和 onunload 事件可用于处理 cookie
```
<body onload="checkCookies()">
1
```
onchange 事件：
onchange 事件常结合对输入字段的验证来使用。

下面是一个如何使用 onchange 的例子。当用户改变输入字段的内容时，会调用 upperCase() 函数。
```
<input type="text" id="fname"
onchange="upperCase()">
1
2
```
onmouseover 和 onmouseout 事件：
onmouseover 和 onmouseout 事件可用于在用户的鼠标移至 HTML 元素上方或移出元素时触发函数。

事件冒泡与事件捕获
- 事件冒泡（Event Bubbling）是指当一个元素触发了某个事件时，该事件会从最具体的元素开始逐级向上传播到较为不具体的元素（也就是从子元素向父元素方向传播），直到传播到文档的根节点为止。这种传播方式就像气泡从水底冒出水面一样，所以叫做事件冒泡。
- 事件捕获（Event Capturing）是一种处理事件的方式，与事件冒泡相反。事件捕获从文档根节点开始，逐级向下传播到最具体的元素，也就是从父元素向子元素方向传播。
使用事件冒泡和事件捕获可以实现：
- 事件委托：可以将事件处理程序绑定到父元素而不是子元素上。当子元素触发该事件时，事件将沿着冒泡路径传递到父元素，由父元素的事件处理程序进行处理。这样可以减少事件处理程序的数量，提高性能和可维护性。
- 事件拦截：通过在事件处理程序中调用 event.stopPropagation() 方法，可以阻止事件继续传播，从而避免不必要的事件触发和处理。
- 多个事件处理程序的执行顺序控制：通过在捕获或冒泡阶段注册事件处理程序，并控制其在事件传播路径上的位置，可以控制多个事件处理程序的执行顺序。
事件监听器

1、addEventListener() 方法
- addEventListener() 方法用于向指定元素添加事件句柄。
- addEventListener() 方法添加的事件句柄不会覆盖已存在的事件句柄。
- 你可以向一个元素添加多个事件句柄。你可以向同个元素添加多个同类型的事件句柄，如：两个 “click” 事件。
- 你可以使用 removeEventListener() 方法来移除事件的监听。
使用语法：
```
element.addEventListener(event, function, useCapture);
1
```
- 第一个参数是事件的类型 (如 “click” 或 “mousedown”).
- 第二个参数是事件触发后调用的函数。
- 第三个参数是个布尔值用于描述事件是冒泡还是捕获。该参数是可选的。
例子：
```
document.getElementById("myBtn").addEventListener("click", displayDate);

element.addEventListener("click", myFunction);

function myFunction() {    
alert ("Hello World!");
}
1
2
3
4
5
6
7
```
2、向 Window 对象添加事件句柄
addEventListener() 方法允许你在 HTML DOM 对象添加事件监听， HTML DOM 对象如： HTML 元素, HTML 文档, window 对象。或者其他支持的事件对象如: xmlHttpRequest 对象。
```
window.addEventListener("resize", function(){
    document.getElementById("demo").innerHTML = sometext;
	});
1
2
3
```
DOM元素增删改查

appendChild()：
```
<div id="div1">
<p id="p1">这是一个段落。</p>
<p id="p2">这是另外一个段落。</p>
</div>
 
<script>
var para = document.createElement("p");
var node = document.createTextNode("这是一个新的段落。");
para.appendChild(node);
 
var element = document.getElementById("div1");
element.appendChild(para);
</script>
1
2
3
4
5
6
7
8
9
10
11
12
13
```
以上的实例我们使用了 appendChild() 方法，它用于添加新元素到尾部。

如果我们需要将新元素添加到开始位置，可以使用 insertBefore() 方法:
```
<div id="div1">
<p id="p1">这是一个段落。</p>
<p id="p2">这是另外一个段落。</p>
</div>
 
<script>
var para = document.createElement("p");
var node = document.createTextNode("这是一个新的段落。");
para.appendChild(node);
 
var element = document.getElementById("div1");
var child = document.getElementById("p1");
element.insertBefore(para, child);
</script>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
```
removeChild()移除已经存在的元素：
```
<div id="div1">
<p id="p1">这是一个段落。</p>
<p id="p2">这是另外一个段落。</p>
</div>
 
<script>
var parent = document.getElementById("div1");
var child = document.getElementById("p1");
parent.removeChild(child);
</script>
1
2
3
4
5
6
7
8
9
10
```
替换 HTML 元素 - replaceChild()
```
<div id="div1">
<p id="p1">这是一个段落。</p>
<p id="p2">这是另外一个段落。</p>
</div>
 
<script>
var para = document.createElement("p");
var node = document.createTextNode("这是一个新的段落。");
para.appendChild(node);
 
var parent = document.getElementById("div1");
var child = document.getElementById("p1");
parent.replaceChild(para, child);
</script>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
```
Collection与NodeList

HTMLCollection 对象类似包含 HTML 元素的一个数组。
- HTMLCollection 不是一个数组！
- HTMLCollection 看起来可能是一个数组，但其实不是。
- 你可以像数组一样，使用索引来获取元素。
- HTMLCollection 无法使用数组的方法： valueOf(), pop(), push(), 或 join() 。
以下代码获取文档所有的 < p > 元素：
```
var x = document.getElementsByTagName("p");
1
```
NodeList 对象是一个从文档中获取的节点列表 (集合) 。

NodeList 对象类似 HTMLCollection 对象。

一些旧版本浏览器中的方法（如：getElementsByClassName()）返回的是 NodeList 对象，而不是 HTMLCollection 对象。
```
var myNodeList = document.querySelectorAll("p");
1
```
BOM（Browser Object Model，浏览器对象模型）

Window
相关阅读:
WordPress多语言翻译插件小语种互译
 使用Hexo从0到1搭建个人博客详细教程（超详细，超简单）
【uniapp】确认弹出框，选择确定和取消
 人工智能中的文本分类：技术突破与实战指导
 LSTM 词语模型上的动态量化
 Python---pyecharts地图案例
 使用 oh-my-posh 美化 windows terminal，让其接近oh-my-zsh
Linux：Jenkins：GitLab+Maven+Jenkins的部署
 跑步运动蓝牙耳机哪个好？跑步无线运动蓝牙耳机推荐
 Elasticsearch 进阶
原文地址：https://blog.csdn.net/baiduwaimai/article/details/134064152

文章目录

概念

JavaScript编写的位置

基本语法

数据类型

变量声明var、let、const

undefined与null的区别

数值类型number

字符串类型string

数组

Date

Map和Set

对象属性

类型转换

函数

函数定义

函数参数

arguments对象

变量的作用域

方法的定义与调用

apply

call

JS常用API操作

对象操作

对象增删改查

js深拷贝、浅拷贝

js实现深拷贝的方式

安全访问

数组操作

JS类（未完）

类继承

DOM（Document Object Model，文档对象模型）

查找HTML元素

改变HTML元素

改变CSS

事件

事件冒泡与事件捕获

事件监听器

DOM元素增删改查

Collection与NodeList

BOM（Browser Object Model，浏览器对象模型）

Window