TypeScript Map.has函数代码示例

			updateIds.forEach(function(id, updateIndex) {
				if (!newIndex.has(id) && state.idToIndex.has(id)) {
					trackedUpdates.push(update.updates[updateIndex]);
					const index = state.idToIndex.get(id);
					removedFromTracked.push({
						item: update.updates[updateIndex],
						previousIndex: index,
						id: id
					});
				}
				else if (newIndex.has(id) && state.idToIndex.has(id)) {
					trackedUpdates.push(update.updates[updateIndex]);
					const previouxIndex = state.idToIndex.get(id);
					const index = newIndex.get(id);
					movedInTracked.push({
						item: newData[index],
						id: id,
						previousIndex: previouxIndex,
						index: index
					});
				}
			});

			updateAndAddIds.forEach(function(id, itemIndex) {
				if (newIndex.has(id) && !state.idToIndex.has(id)) {
					if (itemIndex < update.updates.length) {
						trackedUpdates.push(update.updates[itemIndex]);
					}
					else {
						trackedAdds.push(update.adds[itemIndex - update.updates.length]);
					}
					trackedAdds.push();
					const index = newIndex.get(id);
					addedToTracked.push({
						item: newData[index],
						id: id,
						index: index
					});
				}
			});

							// Record negative and positive columns separately.
							{ originalPoints: [], columns: [], isNegative: true, relativeValue: 0, value: 0 },
							{ originalPoints: [], columns: [], isNegative: false, relativeValue: 0, value: 0 }
						];
					};

					for (const point of originalPoints) {
						const { datum } = point;
						const { input, relativeValue, value } = datum;

						// Note that the ordering of the stacks is determined by the original sort order, as is the
						// ordering of nodes within the stack.
						const stack = stackSelector(input);
						const signed = stacks.get(stack) || createSigned();
						const record = relativeValue < 0 ? signed[0] : signed[1];
						if (!stacks.has(stack)) {
							stacks.set(stack, signed);
						}

						record.originalPoints.push(point);
						record.columns.push(datum);
						record.relativeValue += relativeValue;
						record.value += value;

						if (record.relativeValue < mostNegativeRelValue) {
							mostNegativeRelValue = record.relativeValue;
						}
						else if (record.relativeValue > mostPositiveRelValue) {
							mostPositiveRelValue = record.relativeValue;
						}

						value: number;
						y1: number;
					}
					const groups = new Map<G, Record>();
					const createRecord = (): Record => {
						return { originalPoints: [], columns: [], totalValue: 0, value: 0, y1: columnHeight };
					};

					for (const point of originalPoints) {
						const { input, relativeValue, value } = point.datum;

						// Note that the ordering of the groups is determined by the original sort order, as is the
						// ordering of nodes within the group.
						const group = groupSelector(input);
						const record = groups.get(group) || createRecord();
						if (!groups.has(group)) {
							groups.set(group, record);
						}

						record.originalPoints.push(point);
						record.columns.push(point.datum);
						record.totalValue += value;
						if (relativeValue < 0) {
							record.value = Math.min(record.value, value);
						}
						else {
							// Note that the expected value for mixed groups is undefined.
							record.value = Math.max(record.value, value);
						}
						record.y1 = Math.min(record.y1, point.y1);
					}