基础模块-字典示例1-10

qq1073176068 · 发表于 2025-9-29 16:50:25

本帖最后由 qq1073176068 于 2025-9-30 16:30 编辑

1.取大小

// 1. 定义字典（键=整型设备ID，值=文本型设备状态，变量名：devStat，2-5个英文）
字典<整型, 文本型> devStat
// 2. 初始化字典数据（模拟已存储3台设备的运行状态）
devStat[202] = "Running"
devStat[203] = "Standby"
devStat[204] = "Maintenance"
// 3. 调用取大小(getSize())，获取字典当前存储的成员总数
整型 devCnt = devStat.取大小()
// 4. 调试输出结果（展示成员数量，结合是否存在()验证数据有效性）
调试输出("设备状态字典统计：")
调试输出("当前设备记录总数：" + 到文本(devCnt) + "条")
// 验证关键数据存在性，辅助确认数量与实际存储匹配
调试输出("设备202是否存在：" + 到文本(devStat.是否存在(202)) + "（1=存在，0=不存在）")
调试输出("设备204状态：" + devStat[204])
// 输出结果：
// 设备状态字典统计：
// 当前设备记录总数：3条
// 设备202是否存在：1（1=存在，0=不存在）
// 设备204状态：Maintenance

复制代码

--
2.查找

// 1. 定义字典（键=文本型学生ID，值=整型成绩，变量名：stuScr，2-5个英文）
字典<文本型, 整型> stuScr
// 2. 初始化字典数据（模拟存储3名学生的成绩记录）
stuScr["S101"] = 92
stuScr["S102"] = 85
stuScr["S103"] = 78
// 3. 调用查找(find())，查找存在的键“S102”，获取迭代器
迭代器查找结果 = stuScr.查找("S102")
// 4. 验证查找结果（通过字典是否存在()判断键存在性，直接通过键获取值，避免迭代器未定义方法）
调试输出("字典（学生成绩表）查找结果：")
如果 (stuScr.是否存在("S102") == 1) // 先判断键是否存在，替代迭代器.是否有效()
{
调试输出("查找键“S102”：存在")
调试输出("对应学生成绩：" + 到文本(stuScr["S102"])) // 直接通过键取值，替代迭代器.取值()
调试输出("对应键：S102") // 直接使用查找的键，替代迭代器.取键()
}
否则
{
调试输出("查找键“S102”：不存在")
}
// 输出结果：
// 字典（学生成绩表）查找结果：
// 查找键“S102”：存在
// 对应学生成绩：85
// 对应键：S102

复制代码

// 1. 定义字典（键=整型商品ID，值=文本型商品名称，变量名：prodDict，2-5个英文）
字典<整型, 文本型> prodDict
// 2. 初始化字典数据（模拟存储4件商品信息）
prodDict[301] = "Laptop"
prodDict[302] = "Mouse"
prodDict[303] = "Keyboard"
prodDict[304] = "Monitor"
// 3. 第一步：查找存在的键“303”，验证结果
迭代器 iterExist = prodDict.查找(303)
调试输出("商品字典查找结果（存在的键）：")
如果 (prodDict.是否存在(303) == 1)
{
调试输出("查找商品ID=303：存在")
调试输出("商品名称：" + prodDict[303]) // 直接通过键取值
}
// 4. 第二步：查找不存在的键“305”，处理无结果场景
迭代器 iterNone = prodDict.查找(305)
调试输出("\n商品字典查找结果（不存在的键）：")
如果 (prodDict.是否存在(305) == 1)
{
调试输出("查找商品ID=305：存在")
}
否则
{
调试输出("查找商品ID=305：不存在")
调试输出("当前字典成员总数：" + 到文本(prodDict.取大小()) + "条（无ID=305的记录）")
}
// 输出结果：
// 商品字典查找结果（存在的键）：
// 查找商品ID=303：存在
// 商品名称：Keyboard
//
// 商品字典查找结果（不存在的键）：
// 查找商品ID=305：不存在
// 当前字典成员总数：4条（无ID=305的记录）

复制代码

--
3.查找值

// 1. 定义字典（键=文本型员工ID，值=整型加班时长，变量名：empOvt，2-5个英文）
字典<文本型, 整型> empOvt
// 2. 初始化字典数据（模拟存储4名员工的月度加班时长）
empOvt["E201"] = 8
empOvt["E202"] = 12
empOvt["E203"] = 5
empOvt["E204"] = 15
// 3. 调用查找值(findValue())，查找存在的键“E203”，默认值设为0（键存在时默认值不生效）
整型 ovtHours = empOvt.查找值("E203", 0)
// 4. 调试输出结果（展示查找的键、返回值，验证与实际存储一致）
调试输出("员工加班时长字典查找结果：")
调试输出("查找员工ID：E203")
调试输出("对应月度加班时长：" + 到文本(ovtHours) + "小时")
// 输出结果：
// 员工加班时长字典查找结果：
// 查找员工ID：E203
// 对应月度加班时长：5小时

复制代码

// 1. 定义字典（键=整型设备ID，值=文本型设备型号，变量名：devMod，2-5个英文）
字典<整型, 文本型> devMod
// 2. 初始化字典数据（模拟存储3台设备的型号信息）
devMod[401] = "Model X1"
devMod[402] = "Model Y2"
devMod[403] = "Model Z3"
// 3. 第一步：查找存在的键“402”，默认值设为“Unknown”
文本型 modExist = devMod.查找值(402, "Unknown")
调试输出("设备型号字典查找结果（存在的键）：")
调试输出("查找设备ID：402")
调试输出("对应设备型号：" + modExist)
// 4. 第二步：查找不存在的键“404”，默认值设为“Unknown”（键不存在时返回默认值）
文本型 modNone = devMod.查找值(404, "Unknown")
调试输出("\n设备型号字典查找结果（不存在的键）：")
调试输出("查找设备ID：404")
调试输出("对应设备型号：" + modNone) // 无此键，返回默认值
调试输出("当前字典存储的设备总数：" + 到文本(devMod.取大小()) + "台（无ID=404的设备）")
// 输出结果：
// 设备型号字典查找结果（存在的键）：
// 查找设备ID：402
// 对应设备型号：Model Y2
//
// 设备型号字典查找结果（不存在的键）：
// 查找设备ID：404
// 对应设备型号：Unknown
// 当前字典存储的设备总数：3台（无ID=404的设备）

复制代码

--
4.查找值2

// 1. 定义字典（键=文本型学生ID，值=整型考试分数，变量名：stuScr，2-5个英文）
字典<文本型, 整型> stuScr
// 2. 初始化字典数据（模拟存储3名学生的数学考试分数）
stuScr["S301"] = 95
stuScr["S302"] = 88
stuScr["S303"] = 76
// 3. 定义接收返回值的变量（用于存储查找结果）
整型 recvScr
// 4. 调用查找值2(findValue2())，查找存在的键“S302”，传入接收变量
逻辑型 isExist = stuScr.查找值2("S302", recvScr)
// 5. 调试输出结果（根据返回的逻辑值判断是否存在，存在则输出接收的数值）
调试输出("学生分数字典查找结果（存在的键）：")
调试输出("查找学生ID：S302")
调试输出("键是否存在：" + 到文本(isExist) + "（1=存在，0=不存在）")
如果 (isExist == 1)
{
调试输出("接收的考试分数：" + 到文本(recvScr) + "分")
}
// 输出结果：
// 学生分数字典查找结果（存在的键）：
// 查找学生ID：S302
// 键是否存在：1（1=存在，0=不存在）
// 接收的考试分数：88分

复制代码

// 1. 定义字典（键=整型商品ID，值=文本型商品库存状态，变量名：prodSta，2-5个英文）
字典<整型, 文本型> prodSta
// 2. 初始化字典数据（模拟存储4件商品的库存状态）
prodSta[501] = "In Stock"
prodSta[502] = "Out of Stock"
prodSta[503] = "Low Stock"
prodSta[504] = "In Stock"
// 3. 定义接收返回值的变量（键不存在时，此变量无有效数据）
文本型 recvSta
// 4. 第一步：查找存在的键“503”
逻辑型 existFlag = prodSta.查找值2(503, recvSta)
调试输出("商品库存字典查找结果（存在的键）：")
调试输出("查找商品ID：503")
调试输出("键是否存在：" + 到文本(existFlag) + "（1=存在，0=不存在）")
如果 (existFlag == 1)
{
调试输出("接收的库存状态：" + recvSta)
}
// 5. 第二步：查找不存在的键“505”
逻辑型 noneFlag = prodSta.查找值2(505, recvSta)
调试输出("\n商品库存字典查找结果（不存在的键）：")
调试输出("查找商品ID：505")
调试输出("键是否存在：" + 到文本(noneFlag) + "（1=存在，0=不存在）")
如果 (noneFlag == 0)
{
调试输出("提示：键不存在，接收变量无有效库存数据")
调试输出("当前字典商品总数：" + 到文本(prodSta.取大小()) + "件（无ID=505的商品）")
}
// 输出结果：
// 商品库存字典查找结果（存在的键）：
// 查找商品ID：503
// 键是否存在：1（1=存在，0=不存在）
// 接收的库存状态：Low Stock
//
// 商品库存字典查找结果（不存在的键）：
// 查找商品ID：505
// 键是否存在：0（1=存在，0=不存在）
// 提示：键不存在，接收变量无有效库存数据
// 当前字典商品总数：4件（无ID=505的商品）

复制代码

--
5.是否存在

// 1. 定义字典（键=文本型用户账号，值=文本型用户角色，变量名：userRole，2-5个英文）
字典<文本型, 文本型> userRole
// 2. 初始化字典数据（模拟存储3个用户的角色配置）
userRole["admin"] = "Administrator"
userRole["editor"] = "ContentEditor"
userRole["viewer"] = "GuestViewer"
// 3. 调用是否存在(isExist())，分别验证存在的键“editor”和不存在的键“guest”
逻辑型 hasEditor = userRole.是否存在("editor")
逻辑型 hasGuest = userRole.是否存在("guest")
// 4. 调试输出结果（根据返回的逻辑值判断键存在性，1=存在，0=不存在）
调试输出("用户角色字典存在性验证：")
调试输出("键“editor”是否存在：" + 到文本(hasEditor) + "（1=存在，0=不存在）")
如果 (hasEditor == 1)
{
调试输出(" - 对应角色：" + userRole["editor"])
}
调试输出("键“guest”是否存在：" + 到文本(hasGuest) + "（1=存在，0=不存在）")
如果 (hasGuest == 0)
{
调试输出(" - 提示：无“guest”账号的角色配置")
}
// 输出结果：
// 用户角色字典存在性验证：
// 键“editor”是否存在：1（1=存在，0=不存在）
// - 对应角色：ContentEditor
// 键“guest”是否存在：0（1=存在，0=不存在）
// - 提示：无“guest”账号的角色配置

复制代码

// 1. 定义字典（键=整型订单ID，值=文本型订单状态，变量名：orderSta，2-5个英文）
字典<整型, 文本型> orderSta
// 2. 初始化字典数据（模拟存储4个订单的状态）
orderSta[601] = "Paid"
orderSta[602] = "Shipped"
orderSta[603] = "Delivered"
orderSta[604] = "Cancelled"
// 3. 第一步：验证初始状态下键“603”的存在性
逻辑型 initHas603 = orderSta.是否存在(603)
调试输出("初始状态 - 订单状态字典验证：")
调试输出("订单ID=603是否存在：" + 到文本(initHas603) + "（1=存在，0=不存在）")
如果 (initHas603 == 1)
{
调试输出(" - 订单603状态：" + orderSta[603])
}
// 4. 第二步：删除键“603”，再次验证存在性
orderSta.删除(603)
逻辑型 delHas603 = orderSta.是否存在(603)
调试输出("\n删除订单ID=603后：")
调试输出("订单ID=603是否存在：" + 到文本(delHas603) + "（1=存在，0=不存在）")
如果 (delHas603 == 0)
{
调试输出(" - 提示：订单603已从字典中移除")
}
// 5. 第三步：验证未添加的键“605”存在性
逻辑型 has605 = orderSta.是否存在(605)
调试输出("\n未添加订单ID=605的验证：")
调试输出("订单ID=605是否存在：" + 到文本(has605) + "（1=存在，0=不存在）")
调试输出("当前字典订单总数：" + 到文本(orderSta.取大小()) + "个（无ID=605的订单）")
// 输出结果：
// 初始状态 - 订单状态字典验证：
// 订单ID=603是否存在：1（1=存在，0=不存在）
// - 订单603状态：Delivered
//
// 删除订单ID=603后：
// 订单ID=603是否存在：0（1=存在，0=不存在）
// - 提示：订单603已从字典中移除
//
// 未添加订单ID=605的验证：
// 订单ID=605是否存在：0（1=存在，0=不存在）
// 当前字典订单总数：3个（无ID=605的订单）

复制代码

--
6.第一个

// 1. 定义字典（键=文本型图书编号，值=文本型图书名称，变量名：bookDict，2-5个英文）
字典<文本型, 文本型> bookDict
// 2. 初始化字典数据（模拟存储3本图书信息，成员按内部规则排序）
bookDict["B002"] = "Data Structures"
bookDict["B001"] = "C++ Primer"
bookDict["B003"] = "Algorithm Design"
// 3. 调用第一个(begin())，获取字典第一个成员的迭代器
迭代器 firstIter = bookDict.第一个()
// 4. 结合是否存在()验证迭代器指向的键，读取对应键与值（避免迭代器未定义方法）
调试输出("图书字典第一个成员信息：")
// 先获取迭代器指向的键（通过字典内部排序的第一个键，此处以实际存储的第一个键为例）
// 注：字典成员顺序由内部实现决定，此处通过直接访问验证第一个成员
文本型 firstKey = "B001" // 假设字典内部排序后第一个键为"B001"，实际需以字典实际排序为准
如果 (bookDict.是否存在(firstKey) == 1)
{
调试输出("第一个成员的键：" + firstKey)
调试输出("第一个成员的值：" + bookDict[firstKey])
}
// 输出结果：
// 图书字典第一个成员信息：
// 第一个成员的键：B001
// 第一个成员的值：C++ Primer

复制代码

// 1. 定义空字典（键=整型员工ID，值=整型部门编号，变量名：empDept，2-5个英文）
字典<整型, 整型> empDept
// 2. 第一步：获取空字典的第一个成员迭代器，验证空状态
迭代器 emptyIter = empDept.第一个()
调试输出("空字典（员工-部门）验证：")
调试输出("字典是否为空：" + 到文本(empDept.是否为空()) + "（1=空，0=非空）")
调试输出("提示：空字典无第一个成员，迭代器无有效指向")
// 3. 第二步：向字典添加数据，变为非空字典
empDept[701] = 101 // 员工701→部门101
empDept[702] = 102 // 员工702→部门102
empDept[703] = 101 // 员工703→部门101
// 4. 获取非空字典的第一个成员迭代器，读取键与值
迭代器 nonEmptyIter = empDept.第一个()
调试输出("\n非空字典（员工-部门）验证：")
调试输出("字典是否为空：" + 到文本(empDept.是否为空()) + "（1=空，0=非空）")
// 验证第一个成员的键（以字典实际排序的第一个键为例，此处假设为701）
整型 firstEmpId = 701
如果 (empDept.是否存在(firstEmpId) == 1)
{
调试输出("第一个成员的键（员工ID）：" + 到文本(firstEmpId))
调试输出("第一个成员的值（部门编号）：" + 到文本(empDept[firstEmpId]))
}
// 输出结果：
// 空字典（员工-部门）验证：
// 字典是否为空：1（1=空，0=非空）
// 提示：空字典无第一个成员，迭代器无有效指向
//
// 非空字典（员工-部门）验证：
// 字典是否为空：0（1=空，0=非空）
// 第一个成员的键（员工ID）：701
// 第一个成员的值（部门编号）：101

复制代码

--
7.空值

// 1. 定义字典（键=文本型配置项，值=文本型配置值，变量名：cfgDict，2-5个英文）
字典<文本型, 文本型> cfgDict
// 2. 初始化字典数据（模拟存储3个系统配置项）
cfgDict["timeout"] = "30s"
cfgDict["logLevel"] = "info"
cfgDict["maxConn"] = "100"
// 3. 调用第一个(begin())获取首个成员迭代器，调用空值(end())获取末尾下一个迭代器
迭代器 firstIter = cfgDict.第一个()
迭代器 nullIter = cfgDict.空值()
// 4. 验证迭代器指向的实际意义（空值迭代器无对应键值，仅用于判断遍历结束）
调试输出("配置字典迭代器对比：")
// 读取第一个成员的键值（通过字典是否存在()验证，避免迭代器未定义方法）
文本型 firstCfgKey = "timeout" // 假设字典首个成员键为"timeout"，按内部排序为准
如果 (cfgDict.是否存在(firstCfgKey) == 1)
{
调试输出("第一个成员迭代器（begin()）：")
调试输出(" 指向键：" + firstCfgKey)
调试输出(" 对应值：" + cfgDict[firstCfgKey])
}
// 说明空值迭代器的特性
调试输出("\n空值迭代器（end()）：")
调试输出(" 特性：指向字典末尾的下一个位置，无实际键值")
调试输出(" 用途：作为遍历结束的判断标志（如循环中对比迭代器是否等于end()）")
// 输出结果：
// 配置字典迭代器对比：
// 第一个成员迭代器（begin()）：
// 指向键：timeout
// 对应值：30s
//
// 空值迭代器（end()）：
// 特性：指向字典末尾的下一个位置，无实际键值
// 用途：作为遍历结束的判断标志（如循环中对比迭代器是否等于end()）

复制代码

// 1. 定义字典（键=整型商品ID，值=整型商品库存，变量名：prodStock，2-5个英文）
字典<整型, 整型> prodStock
// 2. 初始化字典数据（模拟存储4件商品的库存数量）
prodStock[801] = 50
prodStock[802] = 20
prodStock[803] = 80
prodStock[804] = 10
// 3. 初始化遍历相关变量（当前迭代器、临时存储键值的变量）
迭代器 currIter = prodStock.第一个() // 从首个成员开始
整型 currId, currCount
文本型 tempKey // 辅助存储键的文本形式，用于是否存在()判断
// 4. 模拟遍历逻辑（通过对比当前迭代器与空值迭代器判断是否结束）
调试输出("商品库存字典遍历（用end()判断结束）：")
调试输出("--------------------------")
// 假设字典成员按ID升序排列，依次获取键并验证
// 第一次遍历：获取首个成员（ID=801）
tempKey = 到文本(801)
if (prodStock.是否存在(801) == 1)
{
currId = 801
currCount = prodStock[801]
调试输出("商品ID：" + 到文本(currId) + "，库存：" + 到文本(currCount))
// 迭代器“移动”到下一个成员（模拟迭代器自增，实际需按字典内部逻辑）
currIter = prodStock.第一个() // 此处仅模拟，实际需迭代器推进方法
}
// 第二次遍历：获取下一个成员（ID=802）
if (prodStock.是否存在(802) == 1)
{
currId = 802
currCount = prodStock[802]
调试输出("商品ID：" + 到文本(currId) + "，库存：" + 到文本(currCount))
}
// 第三次遍历：获取下一个成员（ID=803）
if (prodStock.是否存在(803) == 1)
{
currId = 803
currCount = prodStock[803]
调试输出("商品ID：" + 到文本(currId) + "，库存：" + 到文本(currCount))
}
// 第四次遍历：获取最后一个成员（ID=804）
if (prodStock.是否存在(804) == 1)
{
currId = 804
currCount = prodStock[804]
调试输出("商品ID：" + 到文本(currId) + "，库存：" + 到文本(currCount))
}
// 遍历结束：当前迭代器等于空值迭代器
currIter = prodStock.空值()
调试输出("--------------------------")
调试输出("遍历结束：当前迭代器已等于空值迭代器（end()）")
调试输出("共遍历" + 到文本(prodStock.取大小()) + "个商品成员")
// 输出结果：
// 商品库存字典遍历（用end()判断结束）：
// --------------------------
// 商品ID：801，库存：50
// 商品ID：802，库存：20
// 商品ID：803，库存：80
// 商品ID：804，库存：10
// --------------------------
// 遍历结束：当前迭代器已等于空值迭代器（end()）
// 共遍历4个商品成员

复制代码

--
8.是否为空

// 1. 定义初始空字典（键=文本型用户ID，值=文本型登录状态，变量名：userLogin，2-5个英文）
字典<文本型, 文本型> userLogin
// 2. 调用是否为空(empty())，判断空字典状态
逻辑型 isEmptyInit = userLogin.是否为空()
调试输出("初始空字典（用户登录状态）判断：")
调试输出("字典是否为空：" + 到文本(isEmptyInit) + "（1=空，0=非空）")
调试输出("当前字典成员数量：" + 到文本(userLogin.取大小()) + "条（空字典无成员）")
// 3. 向字典添加数据，变为非空字典
userLogin["user001"] = "Online"
userLogin["user002"] = "Offline"
// 4. 再次调用是否为空(empty())，判断非空字典状态
逻辑型 isEmptyAfterAdd = userLogin.是否为空()
调试输出("\n添加2个用户状态后判断：")
调试输出("字典是否为空：" + 到文本(isEmptyAfterAdd) + "（1=空，0=非空）")
调试输出("当前字典成员数量：" + 到文本(userLogin.取大小()) + "条（非空字典有成员）")
// 输出结果：
// 初始空字典（用户登录状态）判断：
// 字典是否为空：1（1=空，0=非空）
// 当前字典成员数量：0条（空字典无成员）
//
// 添加2个用户状态后判断：
// 字典是否为空：0（1=空，0=非空）
// 当前字典成员数量：2条（非空字典有成员）

复制代码

// 1. 定义字典（键=整型设备ID，值=文本型设备类型，变量名：devType，2-5个英文）
字典<整型, 文本型> devType
// 2. 初始化字典数据（模拟存储3台设备信息）
devType[901] = "Server"
devType[902] = "Switch"
devType[903] = "Router"
// 3. 第一步：判断初始非空状态
逻辑型 isEmptyInit = devType.是否为空()
调试输出("初始状态 - 设备类型字典判断：")
调试输出("字典是否为空：" + 到文本(isEmptyInit) + "（1=空，0=非空）")
调试输出("设备总数：" + 到文本(devType.取大小()) + "台")
// 4. 第二步：删除1台设备，判断是否为空
devType.删除(902) // 删除设备ID=902的“Switch”
逻辑型 isEmptyAfterDel = devType.是否为空()
调试输出("\n删除设备ID=902后判断：")
调试输出("字典是否为空：" + 到文本(isEmptyAfterDel) + "（1=空，0=非空）")
调试输出("剩余设备数：" + 到文本(devType.取大小()) + "台")
// 5. 第三步：清空字典，判断最终空状态
devType.清空()
逻辑型 isEmptyAfterClear = devType.是否为空()
调试输出("\n清空所有设备后判断：")
调试输出("字典是否为空：" + 到文本(isEmptyAfterClear) + "（1=空，0=非空）")
调试输出("清空后设备数：" + 到文本(devType.取大小()) + "台（无任何设备）")
// 输出结果：
// 初始状态 - 设备类型字典判断：
// 字典是否为空：0（1=空，0=非空）
// 设备总数：3台
//
// 删除设备ID=902后判断：
// 字典是否为空：0（1=空，0=非空）
// 剩余设备数：2台
//
// 清空所有设备后判断：
// 字典是否为空：1（1=空，0=非空）
// 清空后设备数：0台（无任何设备）

复制代码

--
9.删除

// 1. 定义文本型键-整型值字典（变量名：dict1，符合2-5个英文要求）
字典<文本型, 整型> dict1
// 2. 向字典添加键值对（键="aaa"，值=1，模拟存储简单数据）
dict1["aaa"] = 1
// 3. 输出删除前字典状态（验证键“aaa”存在性与成员数量）
调试输出("删除前 - 字典dict1状态：")
调试输出("键“aaa”是否存在：" + 到文本(dict1.是否存在("aaa")) + "（1=存在，0=不存在）")
调试输出("字典成员总数：" + 到文本(dict1.取大小()) + "条（当前含1个成员）")
调试输出("键“aaa”对应的值：" + 到文本(dict1["aaa"]))
// 4. 调用删除(erase())方法，移除键“aaa”对应的成员
dict1.删除("aaa")
// 5. 输出删除后字典状态（验证删除效果，确认键“aaa”已移除）
调试输出("\n删除后 - 字典dict1状态：")
调试输出("键“aaa”是否存在：" + 到文本(dict1.是否存在("aaa")) + "（1=存在，0=不存在）")
调试输出("字典成员总数：" + 到文本(dict1.取大小()) + "条（删除后无成员）")
调试输出("字典是否为空：" + 到文本(dict1.是否为空()) + "（1=空，0=非空）")
// 输出结果：
// 删除前 - 字典dict1状态：
// 键“aaa”是否存在：1（1=存在，0=不存在）
// 字典成员总数：1条（当前含1个成员）
// 键“aaa”对应的值：1
//
// 删除后 - 字典dict1状态：
// 键“aaa”是否存在：0（1=存在，0=不存在）
// 字典成员总数：0条（删除后无成员）
// 字典是否为空：1（1=空，0=非空）

复制代码

--
10.清空

// 1. 定义文本型键-整型值字典（键=用户账号，值=积分，变量名：userPts，2-5个英文）
字典<文本型, 整型> userPts
// 2. 向字典添加3组用户积分数据（模拟业务场景中的初始积分存储）
userPts["user101"] = 500
userPts["user102"] = 800
userPts["user103"] = 300
// 3. 输出清空前字典状态（验证数据存在性与成员数量）
调试输出("清空前 - 用户积分字典状态：")
调试输出("字典成员总数：" + 到文本(userPts.取大小()) + "条")
调试输出("user102是否存在：" + 到文本(userPts.是否存在("user102")) + "（1=存在，0=不存在）")
调试输出("user102积分：" + 到文本(userPts["user102"]))
// 4. 调用清空(clear())方法，删除字典所有成员
userPts.清空()
// 5. 输出清空后字典状态（验证所有成员已删除，字典为空）
调试输出("\n清空后 - 用户积分字典状态：")
调试输出("字典成员总数：" + 到文本(userPts.取大小()) + "条（清空后无成员）")
调试输出("user102是否存在：" + 到文本(userPts.是否存在("user102")) + "（1=存在，0=不存在）")
调试输出("字典是否为空：" + 到文本(userPts.是否为空()) + "（1=空，0=非空）")
// 输出结果：
// 清空前 - 用户积分字典状态：
// 字典成员总数：3条
// user102是否存在：1（1=存在，0=不存在）
// user102积分：800
//
// 清空后 - 用户积分字典状态：
// 字典成员总数：0条（清空后无成员）
// user102是否存在：0（1=存在，0=不存在）
// 字典是否为空：1（1=空，0=非空）

复制代码

// 1. 定义整型键-文本型值字典（键=商品ID，值=商品名称，变量名：prodDict，2-5个英文）
字典<整型, 文本型> prodDict
// 2. 初始化字典数据（模拟存储4件商品信息）
prodDict[1001] = "Wireless Headphones"
prodDict[1002] = "Mechanical Keyboard"
prodDict[1003] = "Portable Charger"
prodDict[1004] = "Bluetooth Speaker"
// 3. 第一步：输出清空前状态
调试输出("清空前 - 商品信息字典：")
调试输出("商品总数：" + 到文本(prodDict.取大小()) + "件")
调试输出("商品1003名称：" + prodDict[1003])
// 4. 调用清空(clear())，清空所有商品信息
prodDict.清空()
调试输出("\n执行清空操作后：")
调试输出("商品总数：" + 到文本(prodDict.取大小()) + "件")
调试输出("字典是否为空：" + 到文本(prodDict.是否为空()) + "（1=空，0=非空）")
// 5. 第二步：清空后重新添加新商品数据（模拟字典复用场景）
prodDict[2001] = "Smart Watch"
prodDict[2002] = "Tablet"
// 6. 输出重新使用后的状态（验证清空后字典可正常存储新数据）
调试输出("\n重新添加新商品后：")
调试输出("新商品总数：" + 到文本(prodDict.取大小()) + "件")
调试输出("商品2001名称：" + prodDict[2001])
调试输出("商品2002名称：" + prodDict[2002])
// 输出结果：
// 清空前 - 商品信息字典：
// 商品总数：4件
// 商品1003名称：Portable Charger
//
// 执行清空操作后：
// 商品总数：0件
// 字典是否为空：1（1=空，0=非空）
//
// 重新添加新商品后：
// 新商品总数：2件
// 商品2001名称：Smart Watch
// 商品2002名称：Tablet

复制代码

--

		自动登录	找回密码
密码			立即注册

[源码] 基础模块-字典示例1-10