集合数据简介

集合数据是指将多个元素组合在一起的数据结构。
它可以包含各种类型的元素，比如整数、浮点数、字符串、对象等。
集合数据常用于存储和操作一组相关的数据。

集合数据特点

在编程中，集合数据通常具有以下特点：

无序性：集合数据没有固定的顺序，元素之间的排列是不确定的。
唯一性：集合数据中的元素是唯一的，不会存在重复的元素。
动态性：集合数据可以根据需要进行动态添加、删除或修改元素。
可迭代性：可以对集合数据进行遍历操作，访问每个元素。

常见的集合数据类型

常见的集合数据类型包括：

1. 列表（List）

允许存储重复的元素，有序且可变。

列表（List）是一种集合数据类型，用于存储多个元素的有序集合。列表可以包含不同类型的元素，并允许元素重复。列表是可变的，即可以添加、删除和修改其中的元素。

在 JavaScript 中，列表可以使用数组（Array）来表示。下面是一个简单的 JavaScript 代码案例，展示了列表的基本用法：

// 创建一个空的列表
let my_list = [];

// 在列表末尾添加元素
my_list.push(1);
my_list.push(2);
my_list.push(3);

// 输出列表的长度
console.log(my_list.length);  // 输出：3

// 访问列表中的元素
console.log(my_list[0]);  // 输出：1
console.log(my_list[1]);  // 输出：2
console.log(my_list[2]);  // 输出：3

// 修改列表中的元素
my_list[1] = 5;
console.log(my_list);  // 输出：[1, 5, 3]

// 删除列表中的元素
my_list.splice(0, 1);
console.log(my_list);  // 输出：[5, 3]

// 使用数组提供的方法
my_list.push(4);
my_list.unshift(6);
my_list.pop();
console.log(my_list);  // 输出：[6, 5, 3]

// 列表的切片操作
let sub_list = my_list.slice(1, 3);
console.log(sub_list);  // 输出：[5, 3]

// 列表的拼接
let new_list = my_list.concat([7, 8]);
console.log(new_list);  // 输出：[6, 5, 3, 7, 8]

在上述代码中，我们首先创建了一个空的列表 my_list。然后使用 push() 方法依次添加了三个元素到列表中，并使用 length 属性获取列表的长度。

我们可以通过索引来访问列表中的元素，例如 my_list[0] 表示访问列表中的第一个元素。可以使用赋值语句 my_list[1] = 5 修改列表中的元素。

使用 splice() 方法可以删除指定位置的元素，例如 my_list.splice(0, 1) 表示从列表中的第一个位置删除一个元素。

列表还提供了一些方法，比如 push() 在列表末尾添加元素，unshift() 在列表开头添加元素，pop() 移除并返回列表的最后一个元素。

切片操作可以截取列表中的一部分元素，通过 slice() 方法指定起始和结束位置来获取子列表。

可以使用 concat() 方法将两个列表拼接在一起，生成一个新的列表。

通过这个简单的 JavaScript 代码案例，你可以看到列表作为集合数据类型的基本用法。列表是一种常用、灵活且强大的数据结构，它可以存储和操作多个元素，广泛应用于各种编程场景中。

2. 元组（Tuple）

允许存储重复的元素，有序但不可变。

元组（Tuple）是一种集合数据类型，用于存储多个元素的有序集合。与列表不同的是，元组中的元素可以是不同类型的，且元组的长度是固定的，不可变的。

在 JavaScript 中，由于没有内置的元组类型，我们可以使用数组（Array）来表示元组，并通过约定来限制元素的类型和长度。下面是一个简单的 JavaScript 代码案例，展示了元组的基本用法：

// 创建一个元组（使用数组表示）
let my_tuple = [1, 'two', true];

// 访问元组中的元素
console.log(my_tuple[0]);  // 输出：1
console.log(my_tuple[1]);  // 输出：'two'
console.log(my_tuple[2]);  // 输出：true

// 修改元组中的元素（不可变的元组不能修改）
my_tuple[1] = 'three';    // 不会生效，无法修改元组中的元素

// 元组的长度
console.log(my_tuple.length);  // 输出：3

// 扩展元组
my_tuple.push('four');    // 不会生效，无法扩展元组的长度

// 元组的解构赋值
let [num, str, bool] = my_tuple;
console.log(num);   // 输出：1
console.log(str);   // 输出：'two'
console.log(bool);  // 输出：true

在上述代码中，我们使用数组 my_tuple 来表示一个元组。该元组包含了一个数字、一个字符串和一个布尔值。

可以通过索引来访问元组中的元素，例如 my_tuple[0] 表示访问元组中的第一个元素。

由于元组是不可变的，无法修改元组中的元素。尝试修改元素的赋值语句 my_tuple[1] = 'three' 不会生效。

元组的长度可以通过数组的 length 属性获取。

需要注意的是，由于 JavaScript 中的数组是动态的，我们需要自己约定元组的长度，并在使用时遵守这个约定。

可以使用解构赋值的方式将元组中的元素分别赋值给变量。例如 [num, str, bool] = my_tuple 将元组中的元素依次赋值给 num、str、bool 这三个变量。

尽管 JavaScript 没有内置的元组类型，但你可以使用数组或自定义对象等方式来模拟元组的行为和特性。通过约定和编码规范，你可以在 JavaScript 中实现类似元组的数据结构。

3. 集合（Set）

不允许存储重复的元素，无序且可变。

集合（Set）是一种集合数据类型，用于存储多个唯一的元素，且没有顺序的要求。集合中的元素不能重复，即每个元素在集合中只能出现一次。

在 JavaScript 中，可以使用 Set 对象来表示集合。下面是一个简单的 JavaScript 代码案例，展示了集合的基本用法：

// 创建一个集合
let my_set = new Set();

// 向集合中添加元素
my_set.add(1);
my_set.add(2);
my_set.add(3);
my_set.add(2);  // 重复的元素不会被添加

// 访问集合中的元素
console.log(my_set.has(1));  // 输出：true
console.log(my_set.has(4));  // 输出：false

// 集合的大小
console.log(my_set.size);  // 输出：3

// 删除集合中的元素
my_set.delete(2);

// 遍历集合中的元素
for (let item of my_set) {
  console.log(item);
}

// 清空集合
my_set.clear();

在上述代码中，我们首先使用 new Set() 创建一个空的集合 my_set。

然后使用 add() 方法向集合中添加元素，例如 my_set.add(1) 表示向集合中添加元素 1。由于集合中的元素不能重复，所以重复的元素不会被添加。

可以使用 has() 方法判断集合中是否包含某个元素。例如 my_set.has(1) 返回 true 表示集合中存在元素 1，而 my_set.has(4) 返回 false 表示集合中不存在元素 4。

集合的大小可以通过 size 属性获取。

使用 delete() 方法可以从集合中删除指定的元素，例如 my_set.delete(2) 表示从集合中删除元素 2。

可以使用 for…of 循环来遍历集合中的元素，如上述代码所示。

通过 clear() 方法可以清空集合，即删除集合中的所有元素。

集合是一种常用的数据结构，适用于需要存储唯一元素且不关心顺序的场景。在 JavaScript 中，Set 对象是一种内置的集合类型，提供了一系列方便的方法来操作集合中的元素。

4. 字典（Dictionary）

存储键-值对，键唯一且无序，值可重复且可变。

字典（Dictionary）是一种集合数据类型，用于存储键值对（Key-Value Pair）。每个键（Key）在字典中是唯一的，而值（Value）则对应于该键。

在 JavaScript 中，可以使用对象（Object）来表示字典，因为对象实际上就是一组键值对的集合。下面是一个简单的 JavaScript 代码案例，展示了字典的基本用法：

// 创建一个字典
let my_dict = {};

// 向字典中添加键值对
my_dict['name'] = 'Alice';
my_dict['age'] = 25;
my_dict['city'] = 'Beijing';

// 访问字典中的值
console.log(my_dict['name']);  // 输出：'Alice'
console.log(my_dict.age);      // 输出：25

// 修改字典中的值
my_dict.age = 26;

// 删除字典中的键值对
delete my_dict.city;

// 遍历字典中的键值对
for (let key in my_dict) {
  console.log(key + ': ' + my_dict[key]);
}

// 获取字典的键数组
let keys = Object.keys(my_dict);
console.log(keys);  // 输出：['name', 'age']

// 获取字典的值数组
let values = Object.values(my_dict);
console.log(values);  // 输出：['Alice', 26]

// 判断字典是否包含某个键
console.log('name' in my_dict);  // 输出：true
console.log('height' in my_dict);  // 输出：false