JavaScript高级程序设计—

文章目录

- 第1章 JavaScript简介
- 第2章在HTML中使用JavaScript
- 第3章基本概念
- 第4章变量、作用域、内存问题
- 第5章引用类型
- 第6章面向对象的程序设计
- 第7章匿名函数
- 第8章 BOM
- 第9章客户端检测
- 第10章 DOM
- 第11章 DOM2和DOM3
- 第12章事件
- 第13章表单脚本
- 第14章错误处理与调试
- 第15章 JavaScript与XML
- 第16章 E4X
- 第17章 Ajax与JSON
- 第18章高级技巧
- 第19章客户端存储
- 第20章最佳实践
- 第21章未来API
- 第22章 JavaScript的未来

第1章 JavaScript简介

想要全面理解和掌握JavaScript，关键在于弄清楚它的本质、历史、局限性。

在这里插入图片描述
ECMAScript
ECMAScript（简称ES）是一种用于编写Web浏览器脚本语言的标准，它定义了JavaScript语言的核心规范。它由Ecma International 标准化组织负责管理和更新。JavaScript是ECMAScript标准的一种实现，其他还有JScript和ActionScript等。ECMAScript的目标是提供一种可以跨平台、可靠、高效、强大的脚本语言。目前最新的版本是ECMAScript 2022。

ECMA-262
ECMA-262是一种标准，定义了ECMAScript语言的规范，也称为JavaScript语言的规范。它是由欧洲计算机制造商协会（European Computer Manufacturers Association，ECMA）委员会制定的，旨在为跨平台、跨供应商的脚本语言提供标准化。ECMA-262规范包括语法、类型、语句、运算符、对象等方面的规定，以及处理器执行ECMAScript代码的标准规则。所有的现代Web浏览器都支持ECMAScript规范，并且通过不断地更新，使其成为当今最流行的编程语言之一。

Web浏览器只是ECMAScript实现可能的宿主环境之一。

DOM

在 Web 开发中，DOM（文档对象模型，Document Object Model）是指用于操作 HTML 和 XML 文档的编程接口，它将文档内容表示为一个树形结构，允许开发者通过编程方式来操作和修改文档的内容、结构和样式。

DOM 树是由节点（Node）组成的层级结构，节点可以是元素（Element）、属性（Attribute）、文本（Text）、注释（Comment）等等。通过 DOM 接口，开发者可以使用 JavaScript 来访问和操作文档中的这些节点，例如添加、删除、移动和修改节点，以及事件监听和响应。

DOM 是由 W3C 组织制定的标准，几乎所有现代浏览器都支持 DOM 接口。在前端开发中，熟练掌握 DOM 编程技巧是非常重要的。
在这里插入图片描述

BOM
BOM (Browser Object Model) 指浏览器对象模型，它是指浏览器提供的 JavaScript 对象集合，用于操作浏览器窗口和框架。BOM 并不是 W3C 标准的一部分，不同浏览器对 BOM 的实现有所差异，但 BOM 中的一些对象和方法已经得到了广泛的支持和应用。BOM 包括 window、navigator、location、screen、history、document 等对象。

小结： JavaScript是一种专为与网页交互而设计的脚本语言。
ECMAScript，由ECMA-262定义，提供核心语言功能。
文档对象模型DOM：提供访问和操作网页的方法和接口。
浏览器对象模型BOM：提供与浏览器交互的方法和接口。

第2章在HTML中使用JavaScript

script元素
在JavaScript中，一个

async：布尔类型的属性，表示该脚本是否应该异步加载，仅适用于外部脚本。
charset：表示使用的字符集，仅适用于外部脚本。
defer：布尔类型的属性，表示该脚本是否应该延迟到页面解析完毕再执行，仅适用于外部脚本。
src：表示外部脚本文件的URL。
type：表示脚本的MIME类型，默认为"text/javascript"。

<script src="script.js" type="text/javascript" async></script>

script放在head还是body？

在HTML页面中，script标签可以放在或中。但是放在中的脚本会在页面渲染之前执行，因此可能会导致页面加载变慢。而将脚本放在底部会使得页面加载较快，因为浏览器会先渲染页面内容，再加载和执行JavaScript。但是在一些情况下，必须在中引入脚本，比如在脚本中使用了document.write()来直接在页面中输出内容。因此，放置

head标签
在HTML中，head元素包含了文档的元数据，这些元数据通常不会在页面中直接显示，而是提供给浏览器和搜索引擎等外部应用程序使用。

以下是head标签中可能包含的一些标签及其含义：

title：指定文档的标题，会显示在浏览器的标题栏上和书签中。
meta：提供文档的元数据，如描述、关键词、字符集、作者、视口等。
link：引入外部资源，如样式表、图标等
style：内部样式表，用于定义文档的样式。
script：脚本标签，用于引入或嵌入JavaScript代码。

需要注意的是，元素中的标签并不会直接呈现在页面上，而是在页面加载时被浏览器读取和处理。因此，head标签通常被放置在body标签的前面，以确保页面加载时先处理元数据等信息，再加载和呈现页面的主要内容。

XHTML
XHTML (eXtensible HyperText Markup Language) 是一种基于 XML 的 HTML 扩展语言，它的语法更加严格和规范化，更符合 XML 的语法要求，而且可以和其他的 XML 语言（如 SVG、MathML）一起使用。

XHTML 被设计用来取代 HTML 4.01 和之前的版本，提供更加一致和可靠的标记语言，同时兼容所有的 Web 浏览器和设备。XHTML 可以充分利用 XML 的优点，如可扩展性、可重用性、可维护性和可读性，并且更好地支持 Web 服务、数据交换和语义 Web。

总的来说，XHTML 的出现可以说是对 HTML 标准化和 Web 语义化发展的重要里程碑，为 Web 技术的发展带来了更加规范和健康的方向。

js嵌入代码还是引用外部文件
在选择将JavaScript代码嵌入到HTML页面还是将其作为外部文件引用时，通常需要考虑以下因素：

代码的复用性：将代码作为外部文件引用可以在多个页面之间共享代码，提高代码复用性和可维护性。
缓存：浏览器会缓存外部JavaScript文件，如果多个页面使用相同的文件，则可以从缓存中快速加载文件，提高页面加载速度。
可维护性：将JavaScript代码与HTML代码分开，可以使代码更易于维护和管理。
加载顺序：将JavaScript代码放在页面的头部可以确保代码在页面其他元素加载之前执行，但这可能会导致页面加载速度变慢。将代码放在页面的底部可以加快页面加载速度，但可能会导致页面在代码加载之前出现一些问题。

综合考虑以上因素，通常建议将JavaScript代码作为外部文件引用，可以提高代码复用性和可维护性，同时通过优化缓存和加载顺序，也可以加快页面加载速度。但在某些情况下，如只有一小段JavaScript代码需要使用，或者需要动态生成代码，嵌入到HTML页面中可能更为适合。

js标准模式
JavaScript标准模式（Strict Mode）是 ECMAScript 5 引入的一种限制 JavaScript 变体的方式。通过指定 “use strict”，可以选择性地启用该模式。在该模式下，编写代码的方式更严格，某些在早期版本中可以容忍的代码错误将被抛出错误或警告。

在标准模式下，JavaScript 引擎会执行以下操作：

防止使用未声明的变量；
禁止删除变量、函数、arguments 等；
防止重复属性名；
禁止使用八进制数字；
防止使用保留字作为变量名；
禁止使用 eval() 等函数的隐式调用；
严格模式下 this 的值不再指向全局对象；
严格模式下禁止在函数外部使用 this。
使用 JavaScript 标准模式可以帮助开发者更好地编写可读性更高、可维护性更好、更安全的代码。

小结：

要求把type属性设置成text/javascript，以表明使用的脚本语言是javascript。
包含外部js文件时，必须src属性执行文件的URL。所有script元素会按照他们在页面中出现的先后顺序依次解析。
浏览器呈现后面的页面内容之前，必须先解析完前面的script元素中的代码。为此，一般要把script元素放在页面的末尾，内容之后和结束/body之前。

第3章基本概念

ECMA-262第三版中定义的ECMAScript是各浏览器实现最多的版本。
语法：

区分大小写
标识符：第一个字符必须是字母、下划线、美元符号；
标识符：使用小驼峰大小写格式，第一个字母小写，剩下的每个有意义的单词首字母大写。
注释：单行// 多行/**/
语句：单条语句分号结尾；多条语句{}
关键字：不能作为标识符。
保留字：不能作为标识符。

js中的关键字：
以下是 JavaScript 中的一些关键字：

break：用于终止循环或 switch 语句的执行。
case：在 switch 语句中用于定义不同的分支。
catch：用于捕获异常并执行相应的代码块。
class：在 ES6 中引入的关键字，用于声明类。
const：用于声明常量，创建一个只读的常量变量。 const PI=3.1415;
continue：用于跳过当前循环的剩余代码并进入下一次循环。
debugger：用于在代码中设置断点，以便在调试过程中进行暂停。
default：在 switch 语句中用于定义默认分支。
delete：用于删除对象的属性或数组中的元素。
do：用于创建一个循环，至少执行一次循环体。
else：在条件语句中表示一个替代分支。
export：在模块化 JavaScript 中用于导出变量、函数或对象。
extends：在 ES6 中引入的关键字，用于实现类的继承。
finally：在 try-catch 语句中用于定义无论是否发生异常都要执行的代码块。
for：用于创建一个循环，执行特定次数的循环体。
function：用于声明一个函数。
if：用于创建一个条件语句，根据条件执行特定的代码块。
import：在模块化 JavaScript 中用于导入变量、函数或对象。
instanceof：用于检测对象是否属于特定类或构造函数的实例。 animal instanceof Dog
let：用于声明块级作用域的变量。
new：用于创建对象实例。 let obj = new Constructor();
return：用于从函数中返回值。
switch：用于创建一个多路分支的选择语句。
this：用于引用当前对象。 this.age = age;
throw：用于抛出异常。
try：用于包含可能会抛出异常的代码块。
typeof：用于检测变量或表达式的数据类型。 console.log(typeof undefined);  // "undefined"
var：用于声明变量。
void：用于指定表达式没有返回值。
while：用于创建一个循环，根据条件重复执行循环体。
with：已被废弃，不推荐使用。

js关键字：

保留的未来使用关键字：enum, implements, interface, let, package, private, protected, public, static保留的特定上下文关键字：await, as, async, get, set需要注意的是，保留字和关键字的列表可能会随着 JavaScript 语言的不断发展而有所变化和更新。因此，最好在编写代码时参考最新的 JavaScript 文档和规范。

数据类型：

基本数据类型（Primitive Data Types）：
undefined: 表示未定义的值。
null: 表示空值。
boolean: 表示布尔值，可以是 true 或 false。
number: 表示数字，包括整数和浮点数。
string: 表示字符串，用单引号或双引号括起来的字符序列。
引用数据类型（Reference Data Types）：
object: 表示对象，可以是由键值对组成的集合，也可以是数组、函数等。
array: 表示数组，是一种特殊的对象，用于存储多个值。
function: 表示函数，可以执行特定的操作。
除了以上基本数据类型和引用数据类型，还有一种特殊的数据类型：
symbol: 表示唯一的标识符，用于创建对象的唯一属性键。

JavaScript 是一种动态类型的语言，变量的数据类型可以在运行时自动推断或改变。可以使用typeof运算符来检测变量的数据类型。

undefined类型：
undefined 是 JavaScript 中的一种特殊值，表示一个未定义或未赋值的变量或属性。

当一个变量被声明但没有被赋值时，它的默认值是 undefined。

let myVariable;
console.log(myVariable); // 输出: undefined

当访问一个对象的属性时，如果该属性不存在，则返回 undefined。

let myObj = { name: "John", age: 30 };
console.log(myObj.address); // 输出: undefined

需要注意的是，undefined 是一个全局变量，它的值本身就是 undefined。但是，不推荐将其作为变量的值来赋值，应该使用 null 来表示一个空值。

null类型：
null 是 JavaScript 中的一种特殊值，表示为空值或缺少值。它被视为一个空的对象引用。

let myVariable = null;
console.log(myVariable); // 输出: null

null 是一个字面量，不是一个对象。因此，尝试访问 null 的属性或方法会导致错误。

let obj = null;
console.log(obj.property); // 抛出 TypeError: Cannot read property 'property' of null

需要注意的是，null 是一种数据类型，不同于 undefined。undefined 表示一个未定义的值，而 null 表示一个空值。

数值转换：
在 JavaScript 中，可以使用一些内置的方法和操作符来进行数值转换。下面是一些常用的数值转换方法：

parseInt(): 用于将字符串转换为整数。它解析一个字符串中的数字部分，忽略前导空格，并返回整数值。

let str = "123";
let num = parseInt(str);
console.log(num); // 输出: 123// 可以指定基数
let binaryStr = "1010"; // 二进制数
let decimal = parseInt(binaryStr, 2);
console.log(decimal); // 输出: 10let octalStr = "17"; // 八进制数
let decimal = parseInt(octalStr, 8);
console.log(decimal); // 输出: 15let hexStr = "FF"; // 十六进制数
let decimal = parseInt(hexStr, 16);
console.log(decimal); // 输出: 255

parseFloat(): 用于将字符串转换为浮点数。它解析一个字符串中的数字部分，并返回浮点数值。

let str = "3.14";
let num = parseFloat(str);
console.log(num); // 输出: 3.14// toFixed() 
//指定小数位数，可以使用 toFixed() 方法对浮点数进行格式化，以获得特定位数的小数部分。
//toFixed() 方法将返回一个字符串，表示指定小数位数的浮点数。
//返回的是一个字符串，而不是浮点数。如果需要执行数学计算，使用 parseFloat() 转换回浮点数。
let num = 3.14159;
let fixedNum = num.toFixed(2); // 保留两位小数
console.log(fixedNum); // 输出: "3.14"

需要注意的是，如果字符串不能完全转换为有效的数字，则上述方法的返回结果可能是 NaN（Not a Number）。在进行数值转换时，始终要确保输入的字符串符合预期的格式，以避免意外的结果。

Object类型：

constructor: 表示创建对象的构造函数。

const person = { name: "John" };
console.log(person.constructor); // 输出: Object

prototype: 表示对象的原型，可以用于添加共享的属性和方法。

const person = { name: "John" };
console.log(person.prototype); // 输出: undefined

hasOwnProperty(propertyName): 检查对象是否具有指定名称的属性，而不是从原型链继承而来的。

const person = { name: "John" };
console.log(person.hasOwnProperty("name")); // 输出: true
console.log(person.hasOwnProperty("age")); // 输出: false

isPrototypeOf(object): 检查对象是否是指定对象的原型。

const person = { name: "John" };
const obj = Object.create(person);
console.log(person.isPrototypeOf(obj)); // 输出: true

propertyIsEnumerable(propertyName): 检查对象是否具有指定名称的可枚举属性。

const person = { name: "John" };
console.log(person.propertyIsEnumerable("name")); // 输出: true
console.log(person.propertyIsEnumerable("toString")); // 输出: false

操作符：

算术操作符（Arithmetic Operators）：

+：加法
-：减法
*：乘法
/：除法
%：取模（求余）
++：自增
--：自减

赋值操作符（Assignment Operators）：

=：赋值
+=：加法赋值
-=：减法赋值
*=：乘法赋值
/=：除法赋值
%=：取模赋值

比较操作符（Comparison Operators）：

==：等于（值相等）
===：严格等于（值和类型均相等）
!=：不等于
!==：严格不等于
>：大于
<：小于
>=：大于等于
<=：小于等于

逻辑操作符（Logical Operators）：

&&：逻辑与（and）
||：逻辑或（or）
!：逻辑非（not）

位操作符（Bitwise Operators）：

&：按位与
|：按位或
^：按位异或
~：按位非
<<：左移
>>：右移
>>>：无符号右移

条件（三元）操作符（Conditional (Ternary) Operator）：

condition ? expression1 : expression2：如果条件为真，则返回表达式1，否则返回表达式2。

语句：

表达式语句（Expression Statement）

由一个或多个表达式组成，以分号结尾。例如：x = 5;、console.log(“Hello!”);
声明语句（Declaration Statement）: 用于声明变量、函数和类等。常见的声明语句有：

变量声明语句：var x;、let y;、const z = 10;
函数声明语句：function add(a, b) { return a + b; }
类声明语句：class MyClass { /* 类定义 */ }

条件语句（Conditional Statement）：用于根据条件执行不同的代码块。

if语句：根据条件执行代码块，可配合else或else if使用。
switch语句：根据表达式的值执行不同的代码块。

循环语句（Loop Statement）：用于重复执行一段代码块，直到满足指定条件为止。

for循环：在循环开始前初始化变量，定义循环条件，指定每次循环后执行的操作。
while循环：在循环开始前判断条件，只要条件为真，就重复执行循环体。
do...while循环：在循环体执行后判断条件，至少会执行一次循环体。
for...in..迭代：

控制语句（Control Statement）：用于控制程序的执行流程。

break语句：用于终止循环或switch语句的执行。
continue语句：用于跳过当前循环中的剩余代码，进入下一次循环迭代。
return语句：用于从函数中返回值，并终止函数的执行。

函数：
函数的定义使用function关键字，后面跟着函数名、参数列表和函数体。

function functionName(parameter1, parameter2, ...) {// 函数体// 执行特定的任务或操作return result; // 可选，返回一个值
}

参数：
函数可以有零个或多个参数，参数是可选的，可以根据函数的需要来定义。
函数的参数定义在函数名后的圆括号 () 内，多个参数之间使用逗号 , 分隔。

// 默认参数值
function greet(name = "Guest") {console.log("Hello, " + name + "!");
}
greet(); // 输出：Hello, Guest!
greet("Alice"); // 输出：Hello, Alice!

第4章变量、作用域、内存问题

数据类型——基本类型：

字符串（String）：表示文本数据，使用引号（单引号或双引号）括起来，例如 ‘Hello’ 或 “World”。
数字（Number）：表示数值数据，包括整数和浮点数，例如 42 或 3.14。
布尔值（Boolean）：表示逻辑值，只有两个取值：true（真）和 false（假）。
空值（Null）：表示空或不存在的值，只有一个取值 null。
未定义（Undefined）：表示未赋值的变量，只有一个取值 undefined。

这些基本类型是不可变的，也就是说，变量存储的值是不可改变的，对基本类型的操作总是返回一个新的值。

数据类型——引用类型：

对象（Object）：表示复杂的数据结构，可以包含多个键值对（属性和对应的值）。对象可以通过字面量表示法 {} 或 new
Object() 创建。
数组（Array）：表示一组有序的数据集合，可以包含多个值。数组可以通过字面量表示法 [] 或 new Array() 创建。
函数（Function）：表示可执行的代码块，可以接受参数并返回一个值。函数可以通过定义函数表达式或函数声明的方式创建。

引用类型的变量存储的是对象的引用（内存地址），而不是实际的对象本身。对于引用类型的操作，实际上是操作对象的引用，因此改变引用类型的属性会影响到所有引用该对象的变量。

传递参数——值传递：
当将基本类型的值作为参数传递给函数时，会将该值的副本传递给函数内部。在函数内部对参数进行修改不会影响到原始值。

function updateValue(value) {value = 42; // 修改参数值
}var num = 10;
updateValue(num);
console.log(num); // 输出: 10，原始值未被修改

传递参数——引用传递：
当将引用类型（对象、数组等）作为参数传递给函数时，实际上传递的是对象的引用（内存地址）。在函数内部对参数进行修改会影响到原始对象。

function updateArray(arr) {arr.push(4); // 修改参数对象
}var myArray = [1, 2, 3];
updateArray(myArray);
console.log(myArray); // 输出: [1, 2, 3, 4]，原始数组被修改

需要注意的是，虽然引用传递会影响到原始对象，但是将参数重新赋值为一个新的对象时，不会影响到原始对象。

function updateObj(obj) {obj = { name: 'John', age: 25 }; // 将参数赋值为新对象
}var myObj = { name: 'Alice', age: 30 };
updateObj(myObj);
console.log(myObj); // 输出: { name: 'Alice', age: 30 }，原始对象未被修改

js检查类型：

typeof 操作符：typeof 操作符返回一个字符串，表示操作数的数据类型。

typeof 42; // 返回 "number"
typeof 'Hello'; // 返回 "string"
typeof true; // 返回 "boolean"
typeof undefined; // 返回 "undefined"
typeof null; // 返回 "object"（注意：null 被错误地判断为对象类型）
typeof []; // 返回 "object"
typeof {}; // 返回 "object"
typeof function() {}; // 返回 "function"

需要注意的是，typeof 对于数组和对象会返回 “object”，对于 null 会返回 “object”，对于函数会返回 “function”。

instanceof 操作符：instanceof 操作符用于检查对象是否属于某个特定类的实例。

 var arr = [1, 2, 3];
var obj = {};
var date = new Date();arr instanceof Array; // 返回 true
obj instanceof Object; // 返回 true
date instanceof Date; // 返回 true

instanceof 操作符会检查对象的原型链，因此可以准确地判断对象是否是某个类的实例。

Object.prototype.toString() 方法：toString() 方法返回一个表示对象的类型的字符串。

Object.prototype.toString.call(42); // 返回 "[object Number]"
Object.prototype.toString.call('Hello'); // 返回 "[object String]"
Object.prototype.toString.call(true); // 返回 "[object Boolean]"
Object.prototype.toString.call(undefined); // 返回 "[object Undefined]"
Object.prototype.toString.call(null); // 返回 "[object Null]"
Object.prototype.toString.call([]); // 返回 "[object Array]"
Object.prototype.toString.call({}); // 返回 "[object Object]"
Object.prototype.toString.call(function() {}); // 返回 "[object Function]"

Object.prototype.toString() 方法可以精确地返回对象的类型，并且对于特殊类型（如 null 和数组）也能正确判断。

执行环境：
执行环境（Execution Context）是 JavaScript 中执行代码的环境。每当 JavaScript 代码执行时，都会创建一个执行环境，用于管理代码的执行。

执行环境由以下三个重要的组成部分组成：

变量对象（VariableObject）：
变量对象是执行环境中的一个特殊对象，它存储了在该环境中定义的变量和函数。变量对象可以理解为一个存储变量和函数的容器。在全局执行环境中，变量对象就是全局对象（例如浏览器环境中的
window 对象）。在函数执行环境中，变量对象是活动对象（Active Object），它包含了函数的参数、局部变量和内部函数。
作用域链（Scope Chain）：
作用域链是一个指向变量对象的链表，用于解析变量的访问权限。当访问一个变量时，JavaScript
引擎会从当前执行环境的作用域链中查找该变量，如果找到则使用，否则继续向上级作用域链查找，直到找到变量或到达最外层的全局执行环境。
this 值：
this 值指向当前执行环境所属的对象。在全局执行环境中，this 指向全局对象。在函数执行环境中，this
的值取决于函数的调用方式。

JavaScript 中存在多种执行环境，包括全局执行环境和函数执行环境。每当进入一个新的函数时，都会创建一个新的函数执行环境，形成一个执行环境的栈（Execution Context Stack），称为执行上下文栈。
执行上下文栈的顶部始终是当前正在执行的代码所在的执行环境。

块级作用域：
在早期的 JavaScript 版本中，确实没有块级作用域。块级作用域是指由一对花括号 {} 所包裹的代码块，在该代码块内声明的变量在代码块外部是不可访问的。

然而，在== ECMAScript 6 (ES6) 中引入了 let 和 const 关键字==，它们可以用于声明块级作用域的变量和常量。使用 let 或 const 声明的变量将在声明的块级作用域内有效，超出该作用域则无法访问。

function example() {if (true) {let x = 10;const y = 20;console.log(x); // 输出: 10console.log(y); // 输出: 20}console.log(x); // 报错: x is not definedconsole.log(y); // 报错: y is not defined
}example();

性能问题：

在JavaScript中，性能问题可能出现在多个方面，包括代码执行效率、内存使用和网络请求等。以下是一些常见的性能问题和优化建议：

循环和迭代：避免过多的嵌套循环和迭代，尽量使用更高效的算法和数据结构来优化代码。
避免不必要的全局变量：全局变量会占用内存，并且对性能有负面影响。尽量将变量限制在局部作用域内，避免滥用全局变量。
减少DOM操作：频繁的DOM操作会导致页面重绘和重排，影响性能。可以通过缓存DOM查询结果、使用文档片段进行批量操作等方式来减少DOM操作次数。
事件处理：合理使用事件委托和事件冒泡，避免在每个元素上都绑定事件处理器，以减少事件处理器的数量和内存占用。
图片优化：对于图片资源，可以优化图片大小和格式，使用适当的压缩算法，以减少网络传输和页面加载时间。
异步编程：使用异步编程模式，如回调函数、Promise、async/await等，可以避免阻塞主线程，提高页面响应速度。
缓存和资源管理：合理使用缓存机制，避免重复请求相同的资源。对于大型的数据集合，可以考虑使用分页加载或延迟加载的方式，以优化内存使用和加载时间。
性能监测和优化：使用开发者工具进行性能分析和监测，识别代码中的性能瓶颈，并进行相应的优化。
编译和打包工具：使用优化的编译和打包工具，如Webpack、Rollup等，可以对代码进行压缩、合并和模块化管理，以提高代码执行效率和加载速度。

第5章引用类型

Object类型

//创建方法一
var person=new Object();
person.name='test';
person.age=14;
console.log(person);//{name: 'test', age: 14}//创建方法二
var person={name='test',age=11};
console.log(person);//{name: 'test', age: 14}

Array类型

const myList=[1,2,3,4,50];
console.log(myList);//VM542:1 (5) [1, 2, 3, 4, 50]//栈 先进后出
//队列 先进先出

Date类型

let now=new Date(); // Mon Jul 03 2023 16:05:10 GMT+0800 (中国标准时间)
now.getFullYear(); // 2023
now.getMonth(); // 6  月份0-11 需要加1
now.getDay(); // 1
now.getHours();// 16
now.getMinutes();// 5
now.getSeconds();//10

RegExp类型
RegExp（正则表达式）是一种内置对象类型，用于处理字符串的模式匹配和替换。

//创建RegExp对象的语法是new RegExp(pattern, flags)
//其中pattern是要匹配的模式字符串，flags是可选的修饰符字符串
const regex = new RegExp("pattern", "g"); // 使用RegExp构造函数