对象：由一组键值对组成的无序集合，可以通过键来获取对应的值。
每个键值对中的键是唯一的，值可以是任意类型的数据。
对象通常用来表示实体的属性和方法。
对象字面量：通过在大括号 {} 中定义对象的属性和方法来创建对象。
这是最简单和最常用的方式。
var obj = {}; //创建空对象
var person = { name: 'John', age: 30, city: 'New York'};
通过使用 new 关键字来创建一个新对象，并使用对象构造函数来设置属性和方法。
function Person(name, age, city) {
this.name = name;
this.age = age;
this.city = city;
}
var person = new Person('John', 30, 'New York');
通过调用 Object.create() 方法来创建一个新对象，并指定原型对象。
var person = Object.create(null);
person.name = 'John';
person.age = 30;
person.city = 'New York';
有原型对象，如下：
var personProto = {
city: 'New York'
};
var person = Object.create(personProto);
person.firstName = 'John';
person.lastName = 'Doe';
person.age = 30;
console.log(person)
//{firstName: 'John', lastName: 'Doe', age: 30}
console.log(person.city) //New York
直接赋值：可以通过对象的属性名直接赋值的方式来修改对象的内容。
var person = { name: 'Alice', age: 25 };
person.age = 26; // 修改年龄
person.city = 'New York'; // 添加新的属性
点号或方括号访问属性：可以使用对象的属性名来修改对象的内容。
var person = { name: 'Alice', age: 25 };
person.age = 26; // 使用点号访问属性
person['age'] = 26; // 使用方括号访问属性
Object.assign() ：可以将一个或多个源对象的属性复制到目标对象。
var person = { name: 'Alice', age: 25 };
// 修改年龄并添加新属性
Object.assign(person, { age: 26, city: 'New York' });
console.log(person) //{name: 'Alice', age: 26, city: 'New York'}
这样可以实现对象内容的修改和合并。
解构赋值：可以使用对象的解构赋值来修改对象的内容。
var person = { name: 'Alice', age: 25 };
// 修改年龄并添加新属性
person = { ...person, age: 26, city: 'New York' };
console.log(person) //{name: 'Alice', age: 26, city: 'New York'}
这是创建一个新的person对象，该对象包含了原来person对象的所有属性，以及新添加的age和city属性，并将新创建的对象赋值给person变量。
var person = { name: 'Alice', age: 25 };
// 删除 'age' 属性
delete person.age;
console.log(person); // { name: 'Alice' }
Object.keys()：返回一个对象的所有可枚举属性的属性名组成的数组。
通过获取属性名数组的长度，就可以得到对象有多少个属性。
var obj = {a: 1, b: 2, c: 3};
var objLength = Object.keys(obj).length;
console.log(objLength); // 输出 3
1、for…in 循环：使用 for…in 循环可以遍历对象的可枚举属性。(常用)
2、Object.keys() 方法：返回一个包含对象所有可枚举属性的字符串数组，可以使用它来遍历对象的属性。
3、Object.values() 方法：返回一个包含对象所有可枚举属性值的数组，可以使用它来遍历对象的属性值。
4、Object.entries() 方法：返回一个包含对象所有可枚举属性的键值对数组，可以使用它来遍历对象的键值对。
var person = { name: 'Alice', age: 25, city: 'New York' };
for (var key in person) {
console.log(key + ': ' + person[key]);
}
Object.keys(person).forEach(key => {
console.log(key + ': ' + person[key]);
});
Object.values(person).forEach(value => {
console.log(value);
});
Object.entries(person).forEach(([key, value]) => {
console.log(key + ': ' + value);
});
//可以使用for...of循环来替代 forEach 方法
for (var key of Object.keys(person)) {
console.log(key + ': ' + person[key]);
}
//使用for...of 循环相比forEach方法的优势在于
//可以在循环中使用break和continue语句
注意：for…of 循环是 JavaScript 中用于遍历可迭代对象（如数组、字符串、Map 等）的一种循环结构。它允许你迭代对象的每个元素，并对每个元素执行相应的操作。
数组：用于存储一组有序的数据集合，可以通过索引来访问和修改其中的元素。
数组可以包含任意类型的数据，包括对象、数组、字符串、数字等。
数组通常用来存储一组相关的数据。
使用 [ ] 直接定义数组的元素。
var arr = []; //创建空数组
var arr1 = [1, 2, 3, 4, 5];
使用 Array() 构造函数可以创建一个数组。
var arr = new Array(); //创建空数组
var arr1 = new Array(5);
console.log(arr1); //[empty × 5]
var arr2 = new Array(1, 2, 3, 4, 5);
console.log(arr2); //[1, 2, 3, 4, 5]
注意：只有一个数值传参，则表示创建一个初始长度为数值的空数组。
1、push() 方法：用于在数组的 末尾 添加一个或多个数据。
var arr = [1, 2, 3];
arr.push(4);
arr.push(5);
console.log(arr); // [1, 2, 3, 4, 5]
2、unshift() 方法：用于在数组的 开头 添加一个或多个数据。
var arr = [1, 2, 3];
arr.unshift(0);
arr.unshift('-1');
console.log(arr) // ['-1', 0, 1, 2, 3]
3、splice() 方法：可以在数组的 任意位置 添加/删除 一个或多个数据。
splice(index, delNum, add)
index: 开始修改的位置，
delNum: 要删除的元素数量，
add: 要添加的数据。
var arr = [1, 2, 3];
arr.splice(2, 0, 4);
console.log(arr) //[1, 2, 4, 3]
arr.splice(0, 2, 5);
console.log(arr) //[5, 4, 3]
arr.splice(2, 2, 6);
console.log(arr) //[5, 4, 6]
4、直接赋值：直接通过索引来给数组赋值，实际上是在指定位置 添加/修改数据。
var arr = [1, 2, 3];
arr[3] = 4;
console.log(arr) //[1, 2, 3, 4]
arr[2] = 5;
console.log(arr) //[1, 2, 5, 4]
5、使用扩展运算符 结合 解构赋值，可以在一个声明中添加多个数据。
var arr = [1, 2, 3];
arr = [0,...arr, 4, 5];
console.log(arr); //[0, 1, 2, 3, 4, 5]
1、splice() ：可以从数组中 添加/删除 项目，然后返回被删除的项目。
splice(index, delNum, add)
index: 开始修改的位置，
delNum: 要删除的元素数量，
add: 要添加的数据。
var arr = [1, 2, 3];
var del = arr.splice(1, 1);
console.log(arr); //[1, 3]
console.log(del); //[2]
arr.splice(1, 0, 4);
console.log(arr); //[1, 4, 3]
2、pop()：可以删除数组中的 最后一个元素，并返回删除的元素。
var arr = [1, 2, 3];
var del = arr.pop();
console.log(arr); //[1, 2]
console.log(del); //3
3、shift()：可以删除数组中的 第一个元素，并返回删除的元素。
var arr = [1, 2, 3];
var del = arr.shift();
console.log(arr); //[2, 3]
console.log(del); //1
4、filter()：可以根据条件筛选数组中的元素，并返回一个新的数组。
var arr = [1, 2, 3, 4, 5];
var newArr = arr.filter(item => item !== 3); // 筛选值不为3的元素
console.log(arr); // [1, 2, 3, 4, 5]
console.log(newArr); // [1, 2, 4, 5]
5、slice()：返回被选中的元素的一个副本（数组的一个片段）。
原始数组不会被改变。
var arr = [1, 2, 3, 4, 5];
var newArr = arr.slice(0,2); //筛选从索引0 开始到索引2的元素
console.log(arr); // [1, 2, 3, 4, 5]
console.log(newArr); // [1, 2]
6、indexOf() 和 splice() 结合使用
使用 indexOf() 找到要删除的索引，然后使用 splice() 来删除它。
var arr = [1, 2, 3, 4, 5];
var index = arr.indexOf(3); // 找到值为3的元素的索引
if (index !== -1) { // 如果找到了该元素
arr.splice(index, 1); // 使用splice()删除该元素
}
console.log(arr); // [1, 2, 4, 5]
var arr = [1, 2, 3, 4, 5];
var length = arr.length;
console.log(length); // 输出：5
1、 for 循环：遍历数组的每一个元素。（常用）
var arr = [1, 2, 3, 4, 5];
for (var i = 0; i < arr.length; i++) {
console.log(arr[i]);
}
2、for…of循环：是ES6引入的一种遍历数据的方法，可以用来遍历数组中的元素。
var arr = [1, 2, 3, 4, 5];
for (var element of arr) {
console.log(element);
}
3、forEach()：是数组对象的一个内置方法，可以对数组中的每个元素执行指定的操作。
var arr = [1, 2, 3, 4, 5];
arr.forEach(function(element) {
console.log(element);
});
4、map()：数组对象的一个内置方法，可以对数组中的每个元素执行指定的操作，并返回一个新的数组。
var arr = [1, 2, 3, 4, 5];
var newArr = arr.map(function(element) {
return element * 2; // 对每个元素乘以2
});
console.log(newArr); // [2, 4, 6, 8, 10]
Map：一种有序的键值对集合。
与对象不同的是，Map中的键可以是任意类型的数据，
而且 Map 会保持键值对的插入顺序。
Map通常用来存储和管理复杂的数据结构。
1、使用Map构造函数，set方法逐个添加键值对（常用）
var myMap = new Map();
myMap.set('key1', 'value1');
myMap.set('key2', 'value2');
console.log(myMap); //{'key1' => 'value1', 'key2' => 'value2'}
2、使用数组创建Map：
var myMap = new Map([
['key1', 'value1'],
['key2', 'value2']
]);
console.log(myMap); //{'key1' => 'value1', 'key2' => 'value2'}
1、set(key, value)：添加一个新的键值对到Map对象中，如果键已经存在，则更新对应的值。
2、get(key)：获取指定键的值，如果键不存在则返回undefined。
3、has(key)：检查Map对象中是否存在指定的键，如果存在则返回true，否则返回false。
4、delete(key)：删除指定键及其对应的值，如果删除成功则返回true，否则返回false。
var myMap = new Map();
myMap.set('key1', 'value1'); // 添加键值对
myMap.set('key2', 'value2'); // 添加另一个键值对
myMap.set('key1', 'updatedValue1'); // 修改已存在的键值对
console.log(myMap); //{'key1' => 'updatedValue1', 'key2' => 'value2'}
//获取键的值
var val1 = myMap.get('key1');
console.log(val1); // 输出: 'updatedValue1'
var val2 = myMap.get('key11');
console.log(val2); // undefined
//判断是否存在键
var hasKey1 = myMap.has('key1');
console.log(hasKey1); // 输出: true
//删除键
myMap.delete('key2');
var hasKey2 = myMap.has('key2');
console.log(hasKey2); // 输出: false
Map对象的长度表示其包含的键值对的数量。
var myMap = new Map();
myMap.set('key1', 'value1');
myMap.set('key2', 'value2');
console.log(myMap); //{'key1' => 'value1', 'key2' => 'value2'}
var length = myMap.size;
console.log(length); // 输出: 2
1、for…of循环
2、forEach()
3、使用 keys() 和 values() 方法
var myMap = new Map();
myMap.set('A', 1);
myMap.set('B', 2);
myMap.set('C', 3);
// for…of循环
for (var [key, value] of myMap) {
console.log(key + ' = ' + value);
}
// forEach()
myMap.forEach(function(value, key) {
console.log(key + ' = ' + value);
});
// 使用 keys() 方法遍历键
for (var key of myMap.keys()) {
console.log(key);
}
var keysArray = Array.from(myMap.keys());
keysArray.forEach(key => {
console.log(key);
});
// 使用 values() 方法遍历值
for (var value of myMap.values()) {
console.log(value);
}
注意：myMap.keys()、myMap.values() 返回的是一个迭代器对象，
而不是一个数组，因此不能直接使用forEach方法。
要遍历Map对象中的键，可以将迭代器对象转换为数组，然后再使用forEach方法。
总的来说，对象适合表示实体的属性和方法，数组适合存储一组相关的数据，而Map适合存储和管理复杂的数据结构。