能否调用GeoFire的附近地理哈希函数？及非存储式位置筛选方案

Great question! Let's break this down step by step since you’ve got a few related concerns here:

1. Avoiding Storing All Answers in GeoFire (For Occasional Filtering) #

Since your distance filter is used rarely and each question can have hundreds of answers, a hybrid approach makes perfect sense here:

• Store answers in a standard database node: Keep all answers under a path like /answers/{questionId}/{answerId}, and include the answerer’s geographic coordinates (latitude/longitude) as fields in each answer entry. No need to pre-add these to GeoFire.
• On-demand filtering when the user triggers it:
  1. First, calculate a rough geographic bounding box for your target radius (e.g., 1km around the user’s location). This narrows down the candidate answers to a manageable set.
  2. Query your standard answer node for entries where latitude falls within the bounding box’s lat range, and longitude falls within the lon range. This is a fast, indexed query if you’ve set up indexes on the latitude/longitude fields.
  3. Finally, run a precise distance calculation (like the Haversine formula) on the filtered candidates to keep only those truly within your target radius. For hundreds of entries, this client-side calculation is totally performant.

2. Using GeoFire’s Nearby Geohash Functions Directly #

Most GeoFire implementations don’t expose their internal geohash range calculation logic as public APIs, since it’s tied to the GeoQuery system. But you have options:

• Replicate the logic yourself: GeoFire’s core trick is calculating all geohash prefixes that cover the target radius. You can look up the source code of your GeoFire library (e.g., JavaScript, Android) and extract the logic for generating these prefixes. For example, the JavaScript version uses a _calculateGeoHashQueries method internally—you can adapt this into a standalone function.
• Skip geohashes entirely: As mentioned above, using latitude/longitude bounding box queries on your standard database node is a simpler alternative that avoids needing to interact with GeoFire’s geohash functions directly.

3. Filtering a List of Locations by Radius #

Absolutely—this is straightforward to implement with or without GeoFire:

• Use the Haversine formula: This calculates the spherical distance between two coordinates (critical for accurate real-world distance, since the Earth isn’t flat). Here’s a quick JavaScript example:

  function calculateDistance(coordsA, coordsB) {
    const earthRadiusKm = 6371;
    const dLat = (coordsB.latitude - coordsA.latitude) * Math.PI / 180;
    const dLon = (coordsB.longitude - coordsA.longitude) * Math.PI / 180;
    const a = 
      Math.sin(dLat/2) * Math.sin(dLat/2) +
      Math.cos(coordsA.latitude * Math.PI / 180) * Math.cos(coordsB.latitude * Math.PI / 180) * 
      Math.sin(dLon/2) * Math.sin(dLon/2);
    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
    return earthRadiusKm * c; // Returns distance in kilometers
  }
  

• Filter your list: Iterate over your location list, use the function above to compute distance from the target location, and keep only entries where the distance is ≤ your radius.
• Leverage GeoFire’s built-in tools: Some GeoFire versions include a pre-built distance function (e.g., GeoFire.distanceBetween() in JavaScript). If your library has this, use it instead of writing your own Haversine formula.

Quick Recap #

For your use case, the most efficient path is:

1. Store answers in a standard node with latitude/longitude fields.
2. When the user triggers distance filtering, run a bounding box query to narrow candidates.
3. Use precise distance calculation to filter the final results.

This avoids cluttering GeoFire with hundreds of rarely accessed answer entries, while still delivering fast, accurate filtering when needed.

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