Platform Dependent Code - Best Practice

As for this question:

Would this only compile the required code, therefore it wouldn't be a performance hit?

Correct the if check is done at compile time, not at run time. If you are building for android, it won't compile things inside #if UNITY_IOS. visual studio makes this clear by making is gray in the editor. Visual studio also doesn't compile it, so it won't even show compiler errors in that section until you switch build target.

As for best practice. Due to performance reasons it is in theory better to not use the bool/enum checks, as it just slows down your code and increases your build size (ever so slightly). The downside being that you don't get compiler errors on parts that are not compiled, so if you have a lot of those #if in a method or class, you might accidentally cause some compiler errors when you rename something, which you might not notice right away and only after switching build targets... Personally I think that is a minor issue, but could be rather annoying during development when you accidentally commit code that doesn't compile on a different platform.

In some cases in order to reduce the number of platform checking in your code (which might make your code more difficult to read due to huge methods even though half is not compiled), in some situations you can work with interfaces or abstract classes, where each platform has its own implementation of that interface. For Example:

 public interface IInputManager
 {
     bool WantsToJump();
 }
 
 public class TouchInputManager : IInputManager
 {
     public bool WantsToJump()
     {
        // ... check whether touches say jump
     }
 }
 
 public class StandAloneInputManager : IInputManager
 {
     public bool WantsToJump()
     {
         //... check whether w or up arrow is pressed
     }
 }

This way, you can choose to put the entire classes inside #if to reduce build size by a tiny (prolly not noticeable) bit. But if you don't, you only need to check this it on 1 place on startup, the place where you declare which InputManager, like this:

 public Example : MonoBehaviour
 {
     IInputManager inputManager;
 
     void Start()
     {
 #if UNITY_IOS
         inputManager = new TouchInputManager();
 #else
         inputManager = new StandAloneInputManager();
 #endif
     }
 
     void Update()
     {
         if (inputManager.WantsToJump())
         {
             // Do something
         }
     }
 }

But ofcourse you should use a pattern that you think makes most sense for your situation. It's mostly down to preference as the possible performance hit is not noticeable in most cases anyway. btw. wrote this in the browser, so there might be silly syntax errors in code.