操作
Deno KV API 提供了一系列可以在键空间上执行的操作。
有两种从存储中读取数据的操作，以及五种向存储写入数据的操作。
读取操作可以在强一致性模式或最终一致性模式下执行。强一致性模式保证读取操作将返回最新写入的值。最终一致性模式可能会返回过时值，但速度更快。
写入操作总是以强一致性模式执行。
get Jump to heading
get 操作返回与给定键关联的值和版本戳。如果值不存在，get 返回一个 null 值和版本戳。
有两种 API 可用于执行 get 操作。 Deno.Kv.prototype.get(key, options?) API 可用于读取单个键，而 Deno.Kv.prototype.getMany(keys, options?) API 可用于一次读取多个键。
get 操作在所有一致性模式下都作为“快照读取”执行。这意味着当一次检索多个键时，返回的值将彼此一致。
const res = await kv.get<string>(["config"]);
console.log(res); // { key: ["config"], value: "value", versionstamp: "000002fa526aaccb0000" }
const res = await kv.get<string>(["config"], { consistency: "eventual" });
console.log(res); // { key: ["config"], value: "value", versionstamp: "000002fa526aaccb0000" }
const [res1, res2, res3] = await kv.getMany<[string, string, string]>([
["users", "sam"],
["users", "taylor"],
["users", "alex"],
]);
console.log(res1); // { key: ["users", "sam"], value: "sam", versionstamp: "00e0a2a0f0178b270000" }
console.log(res2); // { key: ["users", "taylor"], value: "taylor", versionstamp: "0059e9035e5e7c5e0000" }
console.log(res3); // { key: ["users", "alex"], value: "alex", versionstamp: "00a44a3c3e53b9750000" }
list Jump to heading
list 操作返回与给定选择器匹配的键列表。这些键的关联值和版本戳也一并返回。有 2 种不同的选择器可用于过滤匹配的键。
prefix 选择器匹配所有以给定前缀键部分开头的键，但不包括键的精确匹配。prefix 选择器可以选择性地给定一个 start 或 end 键来限制返回键的范围。start 键是包含的，end 键是独占的。
range 选择器匹配所有在给定 start 和 end 键之间按字典序排列的键。start 键是包含的，end 键是独占的。
注意：在 `prefix` 选择器的情况下，
prefix键必须仅由完整的（而非部分的）键部分组成。例如，如果键["foo", "bar"]存在于存储中，那么prefix选择器["foo"]将匹配它，但prefix选择器["f"]不会。
list 操作可以选择性地给定一个 limit 来限制返回键的数量。
list 操作可以使用 Deno.Kv.prototype.list<string>(selector, options?) 方法执行。此方法返回一个 Deno.KvListIterator，可用于迭代返回的键。这是一个异步迭代器，可以与 for await 循环一起使用。
// Return all users
const iter = kv.list<string>({ prefix: ["users"] });
const users = [];
for await (const res of iter) users.push(res);
console.log(users[0]); // { key: ["users", "alex"], value: "alex", versionstamp: "00a44a3c3e53b9750000" }
console.log(users[1]); // { key: ["users", "sam"], value: "sam", versionstamp: "00e0a2a0f0178b270000" }
console.log(users[2]); // { key: ["users", "taylor"], value: "taylor", versionstamp: "0059e9035e5e7c5e0000" }
// Return the first 2 users
const iter = kv.list<string>({ prefix: ["users"] }, { limit: 2 });
const users = [];
for await (const res of iter) users.push(res);
console.log(users[0]); // { key: ["users", "alex"], value: "alex", versionstamp: "00a44a3c3e53b9750000" }
console.log(users[1]); // { key: ["users", "sam"], value: "sam", versionstamp: "00e0a2a0f0178b270000" }
// Return all users lexicographically after "taylor"
const iter = kv.list<string>({ prefix: ["users"], start: ["users", "taylor"] });
const users = [];
for await (const res of iter) users.push(res);
console.log(users[0]); // { key: ["users", "taylor"], value: "taylor", versionstamp: "0059e9035e5e7c5e0000" }
// Return all users lexicographically before "taylor"
const iter = kv.list<string>({ prefix: ["users"], end: ["users", "taylor"] });
const users = [];
for await (const res of iter) users.push(res);
console.log(users[0]); // { key: ["users", "alex"], value: "alex", versionstamp: "00a44a3c3e53b9750000" }
console.log(users[1]); // { key: ["users", "sam"], value: "sam", versionstamp: "00e0a2a0f0178b270000" }
// Return all users starting with characters between "a" and "n"
const iter = kv.list<string>({ start: ["users", "a"], end: ["users", "n"] });
const users = [];
for await (const res of iter) users.push(res);
console.log(users[0]); // { key: ["users", "alex"], value: "alex", versionstamp: "00a44a3c3e53b9750000" }
list 操作以批次形式从存储中读取数据。每个批次的大小可以通过 batchSize 选项控制。默认批次大小为 500 个键。批次内的数据以单次快照读取方式读取，因此值彼此一致。一致性模式适用于每个读取的数据批次。跨批次的数据不一致。批次之间的边界在 API 中不可见，因为迭代器返回的是单个键。
通过将 reverse 选项设置为 true，list 操作可以反向执行。这将按字典序降序返回键。start 键和 end 键仍然分别是包含和独占的，并且仍然被解释为按字典序升序排列。
// Return all users in reverse order, ending with "sam"
const iter = kv.list<string>({ prefix: ["users"], start: ["users", "sam"] }, {
reverse: true,
});
const users = [];
for await (const res of iter) users.push(res);
console.log(users[0]); // { key: ["users", "taylor"], value: "taylor", versionstamp: "0059e9035e5e7c5e0000" }
console.log(users[1]); // { key: ["users", "sam"], value: "sam", versionstamp: "00e0a2a0f0178b270000" }
注意：在上述示例中，我们将
start键设置为["users", "sam"]，尽管返回的第一个键是["users", "taylor"]。这是因为start和end键总是按字典序升序评估，即使list操作以反向执行（这会按字典序降序返回键）。
set Jump to heading
set 操作设置存储中键的值。如果键不存在，则创建它。如果键已存在，则其值将被覆盖。
set 操作可以使用 Deno.Kv.prototype.set(key, value) 方法执行。此方法返回一个解析为 Deno.KvCommitResult 对象的 Promise，其中包含提交的 versionstamp。
set 操作总是以强一致性模式执行。
const res = await kv.set(["users", "alex"], "alex");
console.log(res.versionstamp); // "00a44a3c3e53b9750000"
delete Jump to heading
delete 操作从存储中删除一个键。如果键不存在，该操作是空操作（no-op）。
delete 操作可以使用 Deno.Kv.prototype.delete(key) 方法执行。
delete 操作总是以强一致性模式执行。
await kv.delete(["users", "alex"]);
sum Jump to heading
sum 操作以原子方式向存储中的键添加值。如果键不存在，则以和的值创建它。如果键已存在，则其值将添加到和中。
sum 操作只能作为原子操作的一部分执行。 Deno.AtomicOperation.prototype.mutate({ type: "sum", value }) 方法可用于向原子操作添加求和突变。
sum 操作只能在 Deno.KvU64 类型的值上执行。操作数和存储中的值都必须是 Deno.KvU64 类型。
如果键的新值大于 2^64 - 1 或小于 0，sum 操作会回绕。例如，如果存储中的值为 2^64 - 1 且操作数为 1，则新值将为 0。
sum 操作总是以强一致性模式执行。
await kv.atomic()
.mutate({
type: "sum",
key: ["accounts", "alex"],
value: new Deno.KvU64(100n),
})
.commit();
min Jump to heading
min 操作以原子方式将键设置为其当前值和给定值中的最小值。如果键不存在，则以给定值创建它。如果键已存在，则其值设置为其当前值和给定值中的最小值。
min 操作只能作为原子操作的一部分执行。 Deno.AtomicOperation.prototype.mutate({ type: "min", value }) 方法可用于向原子操作添加最小突变。
min 操作只能在 Deno.KvU64 类型的值上执行。操作数和存储中的值都必须是 Deno.KvU64 类型。
min 操作总是以强一致性模式执行。
await kv.atomic()
.mutate({
type: "min",
key: ["accounts", "alex"],
value: new Deno.KvU64(100n),
})
.commit();
max Jump to heading
max 操作以原子方式将键设置为其当前值和给定值中的最大值。如果键不存在，则以给定值创建它。如果键已存在，则其值设置为其当前值和给定值中的最大值。
max 操作只能作为原子操作的一部分执行。 Deno.AtomicOperation.prototype.mutate({ type: "max", value }) 方法可用于向原子操作添加最大突变。
max 操作只能在 Deno.KvU64 类型的值上执行。操作数和存储中的值都必须是 Deno.KvU64 类型。
max 操作总是以强一致性模式执行。
await kv.atomic()
.mutate({
type: "max",
key: ["accounts", "alex"],
value: new Deno.KvU64(100n),
})
.commit();
watch Jump to heading
watch 操作接受一个键数组，并返回一个 ReadableStream，每当任何被监视的键的 versionstamp 发生变化时，它都会发出一个新值。发出的值是 Deno.KvEntryMaybe 对象的数组。
请注意，返回的流不会返回被监视键的每个中间状态，而是让您了解键的最新状态。这意味着如果一个键被快速修改多次，您可能不会收到每次更改的通知，而是键的最新状态。
const db = await Deno.openKv();
const stream = db.watch([["foo"], ["bar"]]);
for await (const entries of stream) {
entries[0].key; // ["foo"]
entries[0].value; // "bar"
entries[0].versionstamp; // "00000000000000010000"
entries[1].key; // ["bar"]
entries[1].value; // null
entries[1].versionstamp; // null
}