如何阻止push()重复生成键？图片上传数据库下载链接去重问题

Hey there! Let's break down your problem and fix it step by step. You've got two key issues to resolve here: redundant download link regeneration for existing images in your database, and the push() method creating unnecessary new keys every time you upload additional files. Let's tackle them one by one.

The root of this problem is that your current logic doesn't check if an image already exists in the database before generating a new link. To fix this, you need a unique identifier for each image to track its presence. Here are the most reliable options for this identifier:

• The unique file ID/key returned by your storage service (e.g., cloud storage's object key)
• A hash of the image file's content (like MD5 or SHA-256, perfect for detecting duplicate content even with different filenames)
• A combination of filename + file size (simpler, but less reliable if filenames repeat with different content)

Step-by-Step Implementation #

Let's use a storage service's file ID as the unique identifier (adjust code to match your tech stack):

async function uploadAndSaveImage(imageFile) {
  // 1. Upload the image to storage and get its unique file ID
  const storageRef = yourStorageService.ref(`uploads/${imageFile.name}`);
  const uploadResult = await storageRef.put(imageFile);
  const uniqueFileId = uploadResult.ref.fullPath; // Use the storage service's unique key

  // 2. Check if this image already has a database record
  const dbQuery = yourDatabase.collection('image_links').where('file_id', '==', uniqueFileId);
  const existingRecord = await dbQuery.get();

  if (existingRecord.empty) {
    // 3. Only generate and save the download link if no record exists
    const downloadUrl = await storageRef.getDownloadURL();
    await yourDatabase.collection('image_links').add({
      file_id: uniqueFileId,
      download_url: downloadUrl,
      uploaded_at: new Date()
    });
    console.log("New image link added to database!");
  } else {
    console.log("Image already exists in database — skipping link generation.");
  }
}

For relational databases (like MySQL), you can add a UNIQUE constraint to the file_id column to enforce uniqueness at the database level, and use INSERT IGNORE or ON DUPLICATE KEY UPDATE to avoid duplicates:

-- First, add unique constraint to your table
ALTER TABLE image_links ADD CONSTRAINT unique_file_id UNIQUE (file_id);

-- Insert only if the file_id doesn't exist
INSERT IGNORE INTO image_links (file_id, download_url, uploaded_at)
VALUES ('your-unique-file-id', 'https://your-storage-link.com', NOW());

The push() method is designed to generate a unique auto-ID every time it's called — that's why you're getting endless new keys. Instead, you need to replace push() with a write operation tied to your unique image identifier.

Fix Options #

Option 1: Use the unique file ID as the database key

Instead of letting push() generate random IDs, use your image's unique identifier as the node/record key. This ensures one key per image:

async function saveImageLink(uniqueFileId, downloadUrl) {
  const linkRef = yourDatabase.ref(`image_links/${uniqueFileId}`);
  const recordExists = await linkRef.get().then(snap => snap.exists());
  
  if (!recordExists) {
    await linkRef.set({
      download_url: downloadUrl,
      uploaded_at: new Date()
    });
  }
}

Option 2: Filter existing records before pushing

If you need to keep a list structure and can't use unique keys, query for existing records first, and only call push() if the image isn't already present:

async function safePushImageLink(uniqueFileId, downloadUrl) {
  const existingRecords = await yourDatabase.collection('image_links')
    .where('file_id', '==', uniqueFileId)
    .get();

  if (existingRecords.empty) {
    // Only push if no match is found
    await yourDatabase.collection('image_links').push({
      file_id: uniqueFileId,
      download_url: downloadUrl
    });
  }
}

• Use a unique image identifier (storage file ID or content hash) to track existing images
• Query the database before generating/saving links to avoid duplicates
• Replace push() with key-based writes or conditional pushes to stop unnecessary new keys from being created

内容的提问来源于stack exchange，提问作者Gastón Saillán