基于地理定位筛选并获取最近建筑的代码优化需求

Let's tackle this location filtering problem step by step—your current approach uses a broad fixed range which is why it's not accurate enough, and it doesn't prioritize the closest building. Here's how to fix it:

First, the Problems with Your Current Code #

• You're comparing string coordinates (the API returns lat/long as strings) as numbers, which can lead to unexpected comparison bugs.
• A 0.5 degree range is way too large (roughly 55km for latitude)—this will include far more buildings than you need.
• You're only filtering buildings in a general range, not finding the closest one, and there's no logic to keep the same building when the user moves within its bounds.

The Solution: Use Distance Calculation + Smart Filtering #

We'll use the Haversine formula to calculate the actual spherical distance between the user and each building (since Earth isn't flat, straight lat/long differences aren't accurate). Then we'll filter by a reasonable proximity threshold and pick the closest building.

Step 1: Implement the Haversine Distance Function

This function converts degrees to radians and calculates the distance in meters between two coordinates:

// Calculate distance between two coordinates in meters using Haversine formula
function calculateDistance(userLat, userLng, buildingLat, buildingLng) {
  const R = 6371000; // Earth radius in meters
  const dLat = (buildingLat - userLat) * Math.PI / 180;
  const dLng = (buildingLng - userLng) * Math.PI / 180;
  const a = 
    Math.sin(dLat/2) * Math.sin(dLat/2) +
    Math.cos(userLat * Math.PI / 180) * Math.cos(buildingLat * Math.PI / 180) * 
    Math.sin(dLng/2) * Math.sin(dLng/2); 
  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a)); 
  return R * c; // Distance in meters
}

Step 2: Updated Fetch Logic

Here's the revised code that:

• Converts API coordinates to numbers for accurate calculations
• Calculates distance for each building
• Filters out buildings beyond a reasonable threshold (e.g., 50 meters—adjust based on your building size)
• Sorts remaining buildings by distance
• Picks the closest one (or returns an empty array if none are nearby)

fetch('http://localhost:8888/api/buildings')
  .then(response => response.json())
  .then(data => {
    const userCoordinates = { 
      latitude: 35.7053509, 
      longitude: 16.9362301 
    };

    // Process each building: calculate distance and keep relevant data
    const buildingsWithDistance = data.data.map(building => {
      // Convert string coordinates to numbers
      const buildingLat = parseFloat(building.latitude);
      const buildingLng = parseFloat(building.longitude);
      const distance = calculateDistance(
        userCoordinates.latitude,
        userCoordinates.longitude,
        buildingLat,
        buildingLng
      );
      return { ...building, distance };
    });

    // Filter buildings within 50 meters (adjust this threshold to fit your needs)
    const nearbyBuildings = buildingsWithDistance.filter(b => b.distance <= 50);

    // Sort by distance (closest first)
    nearbyBuildings.sort((a, b) => a.distance - b.distance);

    // Get the closest building (or undefined if none are nearby)
    const closestBuilding = nearbyBuildings[0];

    console.log("Closest building:", closestBuilding);
  })
  .catch(err => console.error("Error fetching buildings:", err));

Key Improvements #

• Accurate Distance Calculation: The Haversine formula accounts for Earth's curvature, so distances are precise.
• Stable Matching: The 50-meter threshold ensures users don't get matched to buildings across the street. Adjust this based on your building size (e.g., 100 meters for a large campus building)—as long as the user stays within this range, the same building will be returned, avoiding false switches.
• Type Safety: Converting string coordinates to numbers prevents weird comparison bugs.

Bonus: Handle Edge Cases #

• If no buildings are within the threshold, closestBuilding will be undefined—you can add logic to show a "No nearby buildings found" message.
• If multiple buildings are within the threshold, sorting ensures you always get the closest one.

内容的提问来源于stack exchange，提问作者user9294038