类型、值与变量
计算机程序的本质就是处理各种各样的数据。无论是表示学生成绩的数字90，还是表示问候语的文本"你好世界"，这些都是程序中的值。 而类型，就是对这些值进行分类的方式，它告诉我们某个值能做什么、不能做什么。在JavaScript的世界里，理解类型系统是掌握这门语言的关键所在。
当程序需要保存一个值以备将来使用时，就需要将这个值赋给一个变量。变量就像是一个带有标签的容器，让我们可以通过一个有意义的名字来引用存储的值。
比如我们可以用studentAge这个变量名来存储学生的年龄，用welcomeMessage来存储欢迎信息。
JavaScript作为一门动态类型语言，其类型系统既灵活又强大。 与其他一些编程语言不同，JavaScript在运行时才确定变量的类型，这给开发者带来了很大的便利，但同时也需要我们对类型系统有更深入的理解。
JavaScript将所有的数据类型划分为两个主要类别：原始类型和对象类型。这种分类方式反映了数据在内存中的存储方式和操作特点的根本差异。
原始类型包括数字、字符串、布尔值这三种基本类型，以及两个特殊的值null和undefined。
这些类型的值都是不可变的，也就是说，你无法改变一个数字本身的值，比如你不能让数字5变成数字6，你只能用6这个新值替换原来存储5的变量。
对象类型则截然不同。对象是属性的集合，每个属性都有一个名字和对应的值。这个值可以是原始类型，也可以是另一个对象。 数组是一种特殊的对象，它表示有序的数值集合。函数也是对象的一种，只不过它们包含可执行的代码。
这种类型系统的设计让JavaScript既能处理简单的数值计算，又能构建复杂的数据结构和程序逻辑。理解这一点，将帮助我们更好地运用JavaScript的各种特性。
数字类型
JavaScript对数字的处理方式相当独特。与许多编程语言不同，JavaScript不区分整数和浮点数，所有的数字都以64位浮点数的形式存储。
这意味着无论你写的是42还是3.14159，在JavaScript内部它们都以相同的格式处理。
这种统一的数字表示方法简化了程序员的工作，你不需要为选择合适的数字类型而烦恼。然而，这种设计也带来了一些需要注意的特点。 JavaScript能够准确表示的整数范围是从负9007199254740992到正9007199254740992，超出这个范围的整数可能会失去精度。
数字的字面量表示
在编写JavaScript代码时，我们可以用多种方式来表示数字。最常见的是十进制表示法：
let price = 199;
let temperature = -15;
let pi = 3.14159;JavaScript还支持十六进制数字，这在处理颜色值或底层编程时特别有用：
let hexColor = 0xFF6600; // 表示橙色，相当于十进制的16737280
let memoryAddress = 0xABCD;对于科学计算，JavaScript支持科学记数法：
let avogadroNumber = 6.022e23; // 阿伏伽德罗常数
let electronMass = 9.109e-31; // 电子质量（千克）数学运算与Math对象
JavaScript提供了基本的算术运算符，包括加、减、乘、除和取余。除此之外，Math对象还包含了大量的数学函数和常数：
// 基本运算
let total = 100 + 200;
let difference = 500 - 200;
let product = 25 * 4;
let quotient = 100 / 4;
let remainder = 17 % 5; // 结果是2
// 使用Math对象
let squareRoot =
特殊的数字值
JavaScript定义了几个特殊的数字值来处理异常情况。当数字运算的结果超出了可表示的范围时，JavaScript会返回Infinity（正无穷）或-Infinity（负无穷）：
let tooLarge = 1.7976931348623157e308 * 2; // Infinity
let divisionByZero = 1 / 0; // Infinity
let negativeInfinity = -1 / 0; // -Infinity当运算无法产生有意义的数值结果时，JavaScript返回NaN（Not a Number）：
let impossible = Math.sqrt(-1); // NaN
let meaningless = 0 / 0; // NaN
let invalidConversion = "hello" - 5; // NaNNaN有一个特殊的性质：它不等于任何值，包括它自己。要检测一个值是否为NaN，需要使用isNaN()函数：
let result = "text" * 2;
console.log(result === NaN); // false（不能这样检测）
console.log(isNaN(result)); // true（正确的检测方法）浮点数的精度问题
由于JavaScript使用二进制浮点数表示，某些十进制小数无法精确表示。这在进行财务计算时需要特别注意：
let cost1 = 0.2;
let cost2 = 0.1;
let total = cost1 + cost2;
console.log(total); // 0.30000000000000004（而不是0.3）
console.log(total === 0.3); // false
// 解决方案：使用整数进行计算
let cents1 = 20; // 20分
let cents2 = 10; // 10分
文本
在JavaScript中，字符串是表示和处理文本的基本数据类型。字符串是由一系列字符组成的不可变序列，每个字符都采用UTF-16编码存储。这意味着JavaScript能够处理世界上几乎所有的文字系统，从英文字母到中文汉字，从阿拉伯数字到各种符号。
字符串的创建与表示
在JavaScript中，创建字符串最基本的方法是用引号将文本包裹起来。你可以使用单引号（'...'）或双引号（"..."）来定义字符串，这两种方式在功能上没有区别。例如，'hello' 和 "hello" 都是合法且等价的字符串。选择哪种引号主要取决于个人习惯或字符串内容本身（比如字符串内部是否包含某种引号）。此外，字符串中的内容可以是任意字符，包括中文、英文字母、数字、符号等。需要注意的是，字符串一旦创建，其内容是不可变的，不能像数组那样直接修改其中的某个字符。如果需要在字符串中包含引号本身，可以使用另一种类型的引号包裹，或者使用转义字符（\）来实现，具体方法会在后文详细介绍。
let greeting = "欢迎来到JavaScript的世界";
let name = '张三';
let message = "今天是个好日子";当字符串内容本身包含引号时，有几种常用的处理方式。首先，可以选择不同类型的引号包裹字符串内容：如果字符串内部有双引号，可以用单引号包裹，反之亦然。例如，'他说："学习编程很有趣"' 或 "我同意你的观点，编程确实'很有趣'"。如果字符串内部既有单引号又有双引号，或者想统一使用某一种引号，也可以使用反斜杠（\）作为转义字符，将引号进行转义，例如："她问：\"你今天学了什么？\""。通过这些方法，可以灵活地在字符串中包含各种引号而不会引起语法错误。
let quote = '他说："学习编程很有趣"';
let response = "我同意你的观点，编程确实'很有趣'";
let escaped = "她问：\"你今天学了什么？\"";在字符串中，如果需要表示一些无法直接输入或具有特殊含义的字符（比如换行、制表符、引号、反斜杠等），JavaScript允许使用“转义序列”来实现。转义序列是由反斜杠（\）开头，后面跟一个或多个特定字符组成的。例如，\n表示换行，\t表示制表符，\\表示反斜杠本身。通过这些转义序列，可以在字符串中灵活地嵌入各种特殊字符，使字符串内容更加丰富和可控。
let multiLine = "第一行\n第二行"; // \n表示换行
let tabSeparated = "姓名\t年龄\t城市"; // \t表示制表符
let backslash = "文件路径：C:\\Users"; // \\表示反斜杠字符串的属性与方法
每个字符串都有一个length属性，表示字符串中字符的数量：
let cityName = "北京";
console.log(cityName.length); // 2
let englishCity = "Beijing";
console.log(englishCity.length); // 7JavaScript为字符串提供了丰富的方法来进行各种文本处理操作：
let sentence = "JavaScript是一门强大的编程语言";
// 获取特定位置的字符
let firstChar = sentence.charAt(0); // "J"
let lastChar = sentence.charAt(sentence.length - 1); // "言"
// 提取子字符串
let substring = sentence.substring(0, 10); // "JavaScript"
let slice
字符串的连接与模板
在编程中，经常需要将多个字符串拼接在一起以构建更复杂的文本内容。JavaScript为字符串连接提供了多种方法，常见的有使用加号（+）运算符直接拼接、
通过concat()方法合并多个字符串，以及利用模板字符串（Template Literals）实现更灵活、可读性更强的字符串组合。下面将详细介绍这些常用的字符串连接方式：
let firstName = "李";
let lastName = "明";
let fullName = firstName + lastName; // "李明"
let age = 25;
let introduction = "我叫" + fullName + "，今年" + age + "岁";
// 使用模板字符串（推荐方式）
let modernIntro = `我叫${
模板字符串（Template Literals）是用反引号（`）包裹的字符串，可以在其中直接嵌入变量或任意表达式，语法为${表达式}。与传统的字符串拼接方式相比，模板字符串不仅支持多行文本，还能在字符串中灵活地插入变量、计算结果或函数调用，使代码更简洁、可读性更强。例如：
JavaScript 字符串实验室
布尔值
布尔值（Boolean）是编程中用于表示“真”或“假”两种状态的基本数据类型。在JavaScript中，布尔值只有两个取值：true（表示真）和false（表示假）。布尔值常用于条件判断、流程控制等场景。例如，在if语句、循环、函数返回值等地方，布尔值都扮演着决定程序执行路径的关键角色。通过布尔值，程序可以根据不同的条件做出相应的反应，实现复杂的逻辑控制。
布尔值通常来源于比较运算的结果：
let score = 85;
let isPassing = score >= 60; // true
let isPerfect = score === 100; // false
let needsImprovement = score < 70; // false类型转换与真假性
JavaScript的一个强大特性是它能够将任何值转换为布尔值。这在条件判断中特别有用。某些值在转换为布尔值时会变成false，我们称这些值为"假值"：
// 假值包括：
Boolean(undefined); // false
Boolean(null); // false
Boolean(0); // false
Boolean(-0); // false
Boolean(NaN); // false
Boolean(""); // false（空字符串）除了这些假值之外，所有其他值都会转换为true，包括对象和数组：
Boolean("hello"); // true
Boolean(42); // true
Boolean(-1); // true
Boolean([]); // true（空数组也是真值）
Boolean({}); // true（空对象也是真值）这种特性让我们可以编写更简洁的条件判断代码：
let userInput = "张三";
// 传统方式
if (userInput !== null && userInput !== undefined && userInput !== "") {
console.log("用户输入了内容");
}
// 利用真假性的简洁方式
if (userInput) {
console.log("用户输入了内容");
}逻辑运算符
JavaScript提供了三个逻辑运算符来组合和操作布尔值：
逻辑与（&&）运算符用于判断多个条件是否同时为真。只有当它左侧和右侧的操作数都为真时，整个表达式的结果才为真。
如果有任意一个操作数为假，结果就是假。例如：true && true 结果为 true，而 true && false 或 false && true 结果都为 false。在实际编程中，常用它来确保多个条件都满足时才执行某些操作。
let hasLicense = true;
let hasInsurance = true;
let canDrive = hasLicense && hasInsurance; // true
let temperature = 25;
let isComfortable = temperature > 18 && temperature < 30; // true逻辑或（||）运算符用于判断多个条件中是否至少有一个为真。只要左侧或右侧的操作数有一个为真，整个表达式的结果就是true。
只有当所有操作数都为假时，结果才为false。例如：true || false 结果为 true，false || true 结果也为 true，只有 false || false 结果才为 false。在实际编程中，逻辑或常用于只要满足任意一个条件就执行某些操作的场景。
let isWeekend = false;
let isHoliday = true;
let canRest = isWeekend || isHoliday; // true
let userAge = 16;
let isChild = userAge < 12 || userAge > 65; // false逻辑非（!）运算符用于对一个值进行取反操作。它会先将操作数转换为布尔类型（即先用Boolean()函数隐式转换），然后再返回相反的布尔值。如果原本是“真值”（truthy），取反后就变成false；如果原本是“假值”（falsy），取反后就变成true。
常见的“假值”包括：false、0、-0、0n（BigInt零）、""（空字符串）、null、undefined 和 NaN。除此之外的值都被认为是真值。
举例说明：
let isLoggedIn = false;
let needsLogin = !isLoggedIn; // true
let isEmpty = "";
let hasContent = !isEmpty; // true这些逻辑运算符还有一个非常重要的特性，叫做“短路求值”（short-circuit evaluation）。这是什么意思呢？ 简单来说，当JavaScript在计算逻辑表达式时，会从左到右依次判断每个操作数，一旦能够确定整个表达式的最终结果，就会立即停止后续的计算，不再继续处理剩下的部分。具体来说：
- 对于逻辑与（
&&）运算符，如果左侧的值已经是“假值”（falsy），那么整个表达式一定为假，右侧的表达式就不会再被计算。 - 对于逻辑或（
||）运算符，如果左侧的值已经是“真值”（truthy），那么整个表达式一定为真，右侧的表达式同样不会再被计算。
这种机制不仅可以用来简化条件判断，还可以避免不必要的运算，甚至防止出现错误（比如访问不存在的属性）。下面我们会通过代码示例详细说明。
let user = null;
// 如果user为null，就不会尝试访问user.name，避免了错误
let userName = user && user.name;
let defaultName = "访客";
// 如果userInput为假值，就使用默认值
let displayName = userInput || defaultName;常用JavaScript逻辑运算符对比表：
null与undefined的细微差别
JavaScript有两个特殊的值来表示"没有值"的概念：null和undefined。虽然它们都表示缺失或空值，但在使用场景和语义上有着微妙的区别。
undefined通常表示系统级别的、意外的或错误的缺失。当你声明了一个变量但没有给它赋值时，它的值就是undefined：
let studentName;
console.log(studentName); // undefined
let scores = {};
console.log(scores.math); // undefined（属性不存在）
function greet(name) {
console.log(name); // 如果调用时不传参数，name就是undefined
}
greet(); // undefined相比之下，null通常用于表示程序级别的、正常的或预期的缺失。它是程序员有意设置的值，表示"这里应该有一个对象，但现在没有"：
let selectedItem = null; // 表示当前没有选中任何项目
let lastError = null; // 表示当前没有错误
// 在函数中，可以用null表示找不到结果
function findStudentById(id) {
// 查找逻辑...
if (/* 找不到 */) {
return null; // 明确表示没有找到
}
// 返回找到的学生对象
}检测null和undefined
在实际编程中，经常需要检查值是否为null或undefined。有几种不同的方法：
let value;
// 检查是否为undefined
if (value === undefined) {
console.log("值是undefined");
}
// 检查是否为null
if (value === null) {
console.log("值是null");
}
// 检查是否为null或undefined
if (value == null) { // 注意使用==而不是===
console.log("值是null或undefined"
理解null和undefined的区别有助于编写更清晰、更有意图的代码。一般的建议是：当你需要明确表示"没有值"时使用null，而让undefined保持其系统默认的语义。
变量的声明与使用
变量是程序中存储和引用数据的基本机制。在JavaScript中，变量的声明方式经历了几个发展阶段，从最初的var关键字，到后来引入的let和const关键字。
现代变量声明
现代JavaScript推荐使用let和const来声明变量。let用于声明可以重新赋值的变量，而const用于声明常量：
let studentAge = 18;
studentAge = 19; // 可以重新赋值
const schoolName = "第一中学";
// schoolName = "第二中学"; // 错误！常量不能重新赋值
let totalScore; // 可以先声明，后赋值
totalScore = 95;
const pi = 3.14159; // 常量必须在声明时赋值使用let和const声明变量的一个重要优点是，它们具有块级作用域（block scope）。也就是说，使用这两种方式声明的变量，只在它们被声明时所在的代码块（如{}包裹的if语句、循环、函数等）内部有效，出了这个代码块就无法访问。这相比于早期的var声明（其作用域为整个函数或全局）更加安全，能有效避免变量污染和意外覆盖。例如：
function calculateGrade() {
if (true) {
let blockVariable = "只在这个块内有效";
const blockConstant = 100;
console.log(blockVariable); // 正常工作
}
// console.log(blockVariable); // 错误！变量在块外不可访问
}变量命名规则
良好的变量命名是编写可读代码的关键。JavaScript变量名可以包含字母、数字、下划线和美元符号，但不能以数字开头：
// 好的变量命名
let userName = "张三";
let studentCount = 30;
let isCompleted = false;
let maxRetryTimes = 3;
// 避免的命名方式
let a = "张三"; // 太简短，无法表达含义
let student_name = ""; // 下划线风格在JavaScript中不常用
let 123name = ""; // 错误！不能以数字开头采用驼峰命名法（camelCase）是JavaScript社区的约定俗成：
let firstName = "三";
let lastName = "张";
let fullName = firstName + lastName;
let phoneNumber = "13800138000";
let birthDate = new Date();变量的作用域
作用域决定了变量在程序中的可见范围。JavaScript使用函数作用域和块作用域：
let globalVariable = "全局变量"; // 在任何地方都可以访问
function processStudentData() {
let functionVariable = "函数变量"; // 只在函数内可访问
for (let i = 0; i < 5; i++) {
let loopVariable = "循环变量"; // 只在循环内可访问
console.log(globalVariable); // 可以访问全局变量
console.
变量提升现象
JavaScript有一个特殊的行为叫做"提升"（hoisting）。用var声明的变量会被提升到函数的顶部，但只是声明被提升，赋值仍在原位置：
function demonstrateHoisting() {
console.log(myVariable); // undefined（而不是错误）
var myVariable = "hello";
console.log(myVariable); // "hello"
}
// 上面的代码实际上等同于：
function demonstrateHoisting() {
var myVariable; // 声明被提升到顶部
console.log(myVariable); // undefined
myVariable = "hello"; // 赋值仍在原位置
而使用let和const的变量不会有这种令人困惑的行为：
function modernDeclaration() {
// console.log(myLet); // 错误！不能在声明前使用
let myLet = "现代方式";
console.log(myLet); // "现代方式"
}对象类型与引用语义
对象类型与原始类型在行为上有着根本性的差异。原始类型的值是不可变的，而对象类型的值是可变的。这种差异在变量赋值和比较时表现得尤为明显。
对象的可变性
当我们创建一个对象并修改它时，改变的是对象本身，而不是创建一个新对象：
let student = {
name: "李华",
age: 18,
scores: [85, 90, 78]
};
// 修改对象属性
student.age = 19;
student.scores.push(92);
console.log(student); // 对象已被修改这与原始类型的行为形成鲜明对比：
let message = "hello";
message.toUpperCase(); // 这不会改变message本身
console.log(message); // 仍然是"hello"
let newMessage = message.toUpperCase(); // 需要将结果赋给新变量
console.log(newMessage); // "HELLO"引用赋值与比较
当我们将一个对象赋值给另一个变量时，实际上是在复制对象的引用，而不是对象本身：
let originalStudent = {
name: "王五",
grade: 90
};
let copiedStudent = originalStudent; // 复制的是引用，不是对象
// 修改任一变量都会影响同一个对象
copiedStudent.grade = 95;
console.log(originalStudent.grade); // 95（也被改变了）
// 它们指向同一个对象，所以相等
console.log(originalStudent === copiedStudent); // true如果我们需要创建对象的真正副本，必须明确地复制对象的属性：
let student1 = { name: "张三", age: 20 };
// 浅拷贝
let student2 = { ...student1 }; // 使用展开运算符
// 或者
let student3 = Object.assign({}, student1);
// 现在它们是不同的对象
student2.age = 21;
console.log(student1.age); // 20（没有被改变）
console.log(student1 === student2); // false（不同的对象）对于包含嵌套对象的复杂结构，需要深拷贝：
let classInfo = {
className: "高三一班",
students: [
{ name: "小明", age: 18 },
{ name: "小红", age: 17 }
]
};
// 深拷贝（简单方法，但有限制）
let newClassInfo = JSON.parse(JSON.stringify(classInfo));
// 修改新对象不会影响原对象
newClassInfo.students[0].age = 19
对象比较的注意事项
两个结构相同的对象并不相等，因为它们是不同的对象实例：
let book1 = { title: "JavaScript指南", pages: 300 };
let book2 = { title: "JavaScript指南", pages: 300 };
console.log(book1 === book2); // false（不同的对象）
// 如果需要比较对象的内容，需要自定义比较函数
function booksEqual(book1, book2) {
return book1.title === book2.title && book1.pages === book2.pages;
}
理解对象的引用语义对于避免程序中的意外行为至关重要。它解释了为什么修改对象属性会影响所有引用该对象的变量，以及为什么对象比较需要特别小心。
类型转换
JavaScript的类型转换是这门语言最具特色但也最容易引起困惑的特性之一。JavaScript会在需要时自动进行类型转换，这种灵活性既带来了便利，也可能导致意想不到的结果。
自动类型转换
JavaScript在许多场景下会自动进行类型转换，尤其是在涉及不同类型的值进行运算时。例如，当你将字符串和数字相加、或者用算术运算符（如*、-、/）操作字符串和数字时，JavaScript会根据上下文自动将值转换为合适的类型。这种自动类型转换（也称为“隐式类型转换”）是JavaScript的核心特性之一，既可以简化代码编写，但有时也会带来意想不到的结果。下面通过具体例子详细说明：
// 字符串连接时，其他类型会转换为字符串
let result1 = "今年是" + 2024 + "年"; // "今年是2024年"
let result2 = "温度：" + 25 + "度"; // "温度：25度"
// 算术运算时，字符串会尝试转换为数字
let calculation1 = "10" * "5"; // 50
let calculation2 = "100" - "30"; // 70
let calculation3
转换为布尔值
在JavaScript中，所有的值都可以被转换为布尔值（Boolean），这在条件判断、循环等场景中非常常见和重要。不同类型的值在转换为布尔值时有不同的表现：像false、0、NaN、null、undefined和空字符串""会被转换为false，而其他的值（包括非空字符串、非零数字、对象、数组等）都会被转换为true。这种机制让我们可以直接在if语句、while循环等条件表达式中使用各种类型的变量，无需手动比较。例如：
let userInput = "";
if (userInput) {
console.log("用户输入了内容");
} else {
console.log("用户没有输入内容"); // 会执行这里
}
let itemCount = 0;
let hasItems = Boolean(itemCount); // false
let noItems = !itemCount; // true
显式类型转换
虽然自动类型转换在很多场景下能够简化代码，但有时会导致代码行为不够直观，甚至引发难以察觉的bug。因此，在需要明确表达类型意图、保证代码可读性和可维护性时，推荐使用显式类型转换。通过显式地将值转换为所需的类型，可以让代码的逻辑更加清晰，减少出错的可能。例如，使用Number()、String()、Boolean()等内置函数，或者parseInt()、parseFloat()等方法，可以明确地将变量转换为期望的类型，从而避免自动转换带来的歧义。
// 转换为数字
let ageString = "25";
let age = Number(ageString); // 25
let ageInt = parseInt(ageString); // 25
let ageFloat = parseFloat("25.5"); // 25.5
// 转换为字符串
let score = 95;
let scoreString = String(score); // "95"
let
数字与字符串的相互转换
在实际开发中，尤其是在处理用户输入、数据展示或与后端接口交互时，常常需要在数字（Number）和字符串（String）之间进行相互转换。例如，用户在表单中输入的内容通常是字符串类型，但在进行数学运算时需要将其转换为数字；而在页面上展示数据时，又需要将数字格式化为字符串。下面详细介绍几种常见的数字与字符串转换场景：
// 用户输入通常是字符串
let userAge = "18";
let calculatedYear = 2024 - parseInt(userAge); // 2006
// 格式化数字输出
let price = 199.99;
let formattedPrice = "￥" + price.toFixed(2); // "￥199.99"
// 处理百分比
let percentage = 0.875;
let percentText
避免转换陷阱
在JavaScript中，类型转换有时会带来一些令人困惑或容易出错的情况。了解这些常见的“陷阱”非常重要，这样可以避免在实际开发中出现难以发现的bug。下面详细介绍几种常见的类型转换陷阱及其原因：
// 小数精度问题
let total = 0.1 + 0.2;
console.log(total === 0.3); // false！
console.log(total.toFixed(1) === "0.3"); // true
// 空字符串和零的转换
console.log("" == 0); // true
console.log("" === 0
JavaScript 类型实验室
练习
练习 1：基本数据类型的声明和使用
在浏览器控制台中，声明不同类型的变量（字符串、数字、布尔值、数组、对象），并使用typeof查看它们的类型。
// 在浏览器控制台中输入以下代码
// 声明不同类型的变量
let studentName = "李明";
let studentAge = 20;
let isGraduated = false;
let scores = [85, 90, 78, 92];
let studentInfo = { name: studentName, age: studentAge };
// 查看类型
console.log(typeof studentName);
练习 2：类型转换
编写代码，演示数字、字符串和布尔值之间的类型转换。
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<title>类型转换练习</title>
</head>
<body>
<script>
let num = 20;
let str =
练习 3：相等性比较
解释==和===的区别，并编写代码演示它们的差异。
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<title>相等性比较</title>
</head>
<body>
<script>
let num1 = 5;
let str1 =
练习 4：数组和对象的基本操作
创建一个学生信息对象，包含姓名、年龄和成绩数组，然后访问和修改这些数据。
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<title>数组和对象操作</title>
</head>
<body>
<script>
// 创建学生对象
let student = {
name: "张三"
练习 5：综合应用——简单的学生信息管理
创建一个简单的学生信息管理程序，可以添加学生、显示学生列表，并计算平均年龄。
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<title>学生信息管理</title>
</head>
<body>
<h1>学生信息管理系统</h1>
<script>
// 学生列表