Most efficient way to check distance between player and scene objects

Interesting question. In my opinion do what @iwaldrop told you, logic-wise. Really nice logic he made there (+1) it depends on who's doing what.

However performance-wise, It's not like you're gonna get a boost if you're gonna calculate the distance from your objects (or vise versa), simply because for example if you have 100 objects, the distance instruction will get executed 100 times no matter what (let it be Vector3.Distance)

To prove it, I went in for some benchmarking. Here's my test environment:

I have a CubeSpawner.cs script attached to my main camera, that spawns a number of cubes:

 public class CubeSpawner : MonoBehaviour
 {
    public int nCubes;
    public GameObject cube;
    public List<GameObject> allCubes = new List<GameObject>();
    private Transform _transform;

    void Awake()
    {
       _transform = transform;
    }
 
    IEnumerator Start()
    {
       for (int i = 0; i < nCubes; i++)
       {
         var randVect = new Vector3(Random.Range(-50, 50),
                                    Random.Range(-50, 50),
                                    Random.Range(-50, 50));
         allCubes.Add((GameObject)Instantiate(cube, _transform.position + randVect, Quaternion.identity));
         yield return null;
       }

       var watch = new Stopwatch();
       watch.Start();
       for (int i = 0, len = allCubes.Count; i < len; i++)
       {
           var dist = Vector3.Distance(_transform.position, allCubes[i].transform.position);
           yield return null;
       }
       watch.Stop();

       Debug.Log("SPAWNER to CUBE: " + watch.ElapsedMilliseconds);
       Debug.Log("CUBES to SPAWNER: " + CubeScript.totalTime);
    }
 }

Here's my CubeScript.cs:

 public class CubeScript : MonoBehaviour
 {
     public Transform target;
     public static double totalTime = 0;
     private Transform _transform;
 
     void Awake()
     {
         _transform = transform;
         target = Camera.mainCamera.transform;
     }
 
     IEnumerator Start()
     {
         var watch = new Stopwatch();
         watch.Start();
 //        var init = Time.realtimeSinceStartup;
         var dist = Vector3.Distance(_transform.position, target.position);
         yield return null;
 //        totalTime += (Time.realtimeSinceStartup - init);
         watch.Stop();
         totalTime += watch.ElapsedMilliseconds;
     }
 }

(The comments shows another way to get the time took to get the dist) totalTime is static so its shared between all cubes.

Now, you might notice a strange thing, why am I doing a yield return null? Because no matter how I tried getting the total time without it, I just kept getting a zero, because it takes very little time to do a single Vector3.Distance - You can try it out for yourself.

Now that there's a yield return null after each distance calc in both the spawner and the cube scripts, we should reach balance now.

I ran a few tests, here are the results of instantiating 1000 cubes (you can think of the spawner as your player, and the cubes as the objects):

            Test#: 1     2     3     4
 SPAWNER to CUBES: 3683, 3208, 3108, 3514 (ms)
 CUBES to SPAWNER: 3776, 3240, 3461, 3453 (ms)

So, as you can see they're very close, with more wins to SPAWNER to CUBES over CUBES to SPAWNER

So performance-wise, it doesn't make that much of a difference.

And if there was a very huge number of objects that you must calculate the dist to (like 100000), I would use a yield return null to divide the pressure over separate frames every 1000 call or so.

Note that I used Vector3.Distance just to illustrate, it's more efficient to use (pos1 - pos2).sqrMagnitude if you just wanna compare between two distances like:

 (pos1 - pos2).sqrMagnitude < dist * dist