A function defines a block of code which can be executed with a single statement (a function call), and provide a value back to the caller when finished (a return value). There are several reasons to use functions:
- Reduces redundancy in your program
- Enables reuse of code in many programs
- Improves readability of the program
- Improves maintainability of the program
- Makes it easy to extend your program
Access Rights : The
Public and
Private keywords specify public or private intra module-level access rights, respectively. If neither is given, the function defaults to public access (
Public).
Calling Convention : Calling convention, or the order in which arguments are pushed and popped from the stack during function calls, is specified with the
cdecl,
pascal and
stdcall keywords. If none is given, the function uses the standard convention by default (
stdcall).
Passing Arguments : Functions may receive one or more variables, or arguments, when called. These arguments are listed as
parameters in the
parameter_list. The
ByRef and
ByVal keywords specify whether the argument will be passed by reference or by value, respectively. The argument's type is given by "
As type" following the
parameter. If a parameter in the declaration is given a default value, the parameter is optional. Array parameters are specified by following an identifier with an empty parenthesis. Note that array parameters are always
ByRef and the
ByRef keyword is neither required nor allowed for array parameters. When calling a function with an array argument the parenthesis must be supplied there too; see the examples.
Overloaded Functions : An overloaded function may share the same name (
identifier) as another with a different signature. The
Overload keyword specifies that a function may be overloaded. A function must be defined - or declared - using the
Overload keyword prior to any functions that overload them.
Returning values :
return_type specifies the
data type returned by a function upon exit. If no data type is specified, then the function will return the default data type, which will be Integer unless set to another data type using
DefSng,
DefDbl,
DefStr, etc. Functions can return values using three methods: the
Return keyword followed by a value exits the function immediately, and returns that value to the caller. Functions can also return values by assigning the Function keyword or the function's
identifier to the desired return value (but Function keyword or function's
identifier does not allow to evaluate the current assigned value). The latter two methods do not cause the function to exit, however.
Return keyword mixed with Function= keyword or function's
identifier= or
Exit Function keyword in a same function is unsupported when returning objects with constructors. Since functions return values, function calls evaluate to expressions. Thus, function calls can be made wherever an expression is expected, like in
Assignments or
If statements. Functions can also return references by specifying
Byref As return_type.
Warning: Whatever the output branch used, the return value must be always defined, otherwise an unexpected behavior may occur.
Local Variable Preservation : The
Static keyword specifies that a function's locally declared variables are preserved between function calls. Upon entering a function defined with
Static, local variables have the same value as when the function was last called.
Global Variable Access: To access duplicated symbols defined as global outside the function body, add one or preferably two dot(s) as prefix:
.SomeSymbol or preferably
..SomeSymbol (or only
..SomeSymbol if inside a
With..End With block).
When calling a function, parentheses surrounding the argument list (if any) are required only for function calls in expressions. If there is no argument to pass, the parentheses become optional, but it is a common convention to place empty parentheses '()' after the function name, to signify a function call.
Warning for 64-bit compiler only: See the
Identifier Rules page for the choice of user procedure identifier names (and specially the 'Platform Differences' paragraph).