---
url: >-
  /statelake/scripting-reference/functions-and-procedures/parameters-or-arguments.md
---

# Parameters Or Arguments?

The **Parameter** is the temporary variable name within a **Function** or **Procedure** sub-routine, while the **Argument** is the value contained within or passed in by this temporary variable.

So **Parameters** (or **Arguments**) are the input values that are passed within parentheses into either a function or into a procedure.

While a **Parameter** is a placeholder for an **Argument**, the two terms are sometimes used interchangeably to refer to the same thing.

A **Function** or **Procedure** can contain one or more **Parameters** - where there is more than one, it is a **Parameter List**, which is simply a series of **Parameter** declarations inside a set of parentheses that are separated by a semi-colon (;). This list specifies the number, type, and order of **Parameters** that must be passed to the routine when it is called.

Not all sub-routines will require a **Parameter** to be passed in. Both **Functions** and **Procedures** can be defined to operate without any data values being passed in such as a **Function** that simply returns a randomly generated number. In these cases, simply omit the parentheses and all other details as shown below.

```pascal
procedure DoIt;
begin
  LogInfo('Doing it!!!');
end;
```

There are several different types of **Parameter**. Every **Parameter** has a classification - by default this is *value*, but they can also be *variable*, *constant*, or *out*. *Variable*, *constant*, and *out* are indicated by use of the reserved keywords **var**, **const** and **out**. The default *value* **Parameters** are always given a type, whereas *Variable*, *constant*, and *out* can be either typed or untyped.

* **Value** - these **Parameters** have a value passed in to the routine. The routine copies the **Argument** value and performs whatever it needs to on the copy value - the routine is free to read and write to the copied **Parameter**. At completion of the routine the copy is discarded, so there is no effect on the original value. A simple example follows where **XNum** is the parameter in the **Function** called **DoubleIt**. **XNum** will contain the same value at the end of the routine as it had at the start.

  ```pascal
  function DoubleIt(XNum : integer): integer;
  ```

* Variable (var) - these get their **Argument** by reference. Rather than working with a copy of the value passed in, any changes made to the **Argument** persist and are carried out of the routine on completion. Similar to the example above, the introduction of **var** before the **Parameter** means that the resulting value contained in **XNum** could be different from the starting value once the function has been called and run.

  ```pascal
   function DoubleIt(var XNum : integer): integer;
  ```

* Constant (const) - similar to the *value* **Parameter**, a *constant* **Parameter** however cannot be assigned a value within the **Function** or **Procedure** that calls it. It is essentially a read-only **Argument** and should be used for types such as strings as it gives better performance. Two examples follow.

  ```pascal
  procedure DoStuff(const a : string);
  begin
    LogInfo('Stuff=' + a);
  end;
  ```

  ```pascal
  function uc(const s1 : string):string;
  begin
    result := Uppercase(s1);
  end;
  ```

* **Out** - as suggested by the name, this **Parameter** is for output purposes only by instructing the routine where to store output. It is similar to a *variable* Parameter where the **Argument** is passed by reference, but the routine does not expect the **Parameter** to have an initial value. This *out* **Parameter** type serves the same purpose of the special variable called **Result**.

  ```pascal
  function GameTotal(out FinalNum : integer) : integer;
  begin
    FinalNum := 25;
    RESULT := FinalNum;
  end;

  procedure ScriptEvent (var Value : variant);
  var
    outTest : integer;
  begin
    LogInfo(IntToStr(GameTotal(outTest)));
  end;
  ```