Would it be slower to place function definitions inside another function definition?

Question

Will it be slower to place functions' defintions inside a main function?
I usually do that if the subfunctions are short.
However, with a long subfunction I usually place it outside as I think that would make it easier to read and run faster.
Now I want to do it as the first method below as I want to make it self-contained and easier to manage when I do copy-paste and re-use.
If I place them outside, I usually miscopy some functions and make it not running properly. But I'm worrying if it's slower and harder to read.

I understand about the local/global effect but I want to focus on the speed and readability here.

Method 1: Place function1 and function2 inside the main function.

   myFunction[parameters_] := Module[{},
  
  function1[parameters1_] := Module[{},
    (* a long function*)
    do something here
    ];
  function2[parameters2_] := Module[{},
    (* a short function*)
    do something here
    ];
  
  (*use function1 and function2 to do something more*)
  
  ]

Method 2:

  function1[parameters1_] := Module[{},
    (* a long function*)
    do something here
    ];

  function2[parameters2_] := Module[{},
    (* a short function*)
    do something here
    ];

myFunction[parameters_] := Module[{},
  
  (*use function1 and function2 to do something more*)
  
  ]

Answer 1

Given that you told on the comments that you want the internal functions not to be visible probably the best method is the following:

Define all functions, internal and main, inside a Module. Put those functions which you don't want to be publicly visible on the Module symbols list; the rest will become publicly visible. There shouldn't be performance issues; all definitions are evaluated only once.

Module[
 {function1, function2},

 function1[parameters1_] := 
  (Echo["function1 was here"]; parameters1);

 function2[parameters2_] := 
  (Echo["function2 was here"]; parameters2);

 myFunction[parameters_] :=
  (function1[parameters]; 
   function2[parameters]);
 ]

Now the main function is visible and can call internal functions:

myFunction[42]

(* function1 was here *)

(* function2 was here *)

(* 42 *)

At the same time, internal functions are not publicly visible:

function1[42]

(* function1[42] *)

function2[42]

(* function2[42] *)

Answer 2

There is not a big difference, but for housekeeping the first method is to be preferred:

myFunction[] := Module[{},
   function1[] := Module[{},
     Sqrt /@ Range[10^4]];
   function2[] := Module[{},
     Sqrt /@ Range[10^4];];
   function1[];
   function2[]];
myFunction[] // RepeatedTiming

(* {0.135302, Null} *)


function1[] := Module[{}, Sqrt /@ Range[10^4];];
function2[] := Module[{}, Sqrt /@ Range[10^4];];
myFunction[] := Module[{}, function1[]; function2[]]
myFunction[] // RepeatedTiming

(* {0.114168, Null} *)