---
name: "privateAll"
type: command
status: ok
groups: ["Variables"]
arma3_since: "2.18"
locality: {"argument": null, "effect": null, "server_exec": false}
source: https://community.bistudio.com/wiki/privateAll
revid: 369773
updated: 2024-10-08T15:08:58Z
---

# privateAll

*Command · Variables · Arma 3 v2.18*

## Description

Disables the implicit inheritance of local variables, as defined in the parent scope.

By default, any local variables defined in a parent scope are available to the lower scope code.

After using [privateAll](../commands/privateAll.md), parent scope variables can no longer be accessed implicitly. However, it is still possible to explicitly access parent scope variables using the [import](../commands/import.md) command.

## Syntax

```sqf
privateAll
```

**Returns:** [Nothing](../topics/Nothing.md)

## Examples

### Example 1

```sqf
_a = 1;
_b = 2;
_c = 3;
4 call {
    // _a, _b and _c from the parent scope are accessible at this point
    systemChat str [_a, _b, _c];             // prints [1, 2, 3]
    privateAll;                             // _a, _b and _c from the parent scope can no longer be accessed
    systemChat str [_a, _b, _c];             // prints [Any, Any, Any]
    import ["_a", "_b"];                     // _a and _b are now defined as private variables in the current scope; _c is still not defined
    systemChat str [_a, _b, _c, _this];     // prints [1, 2, Any, 4]
    _a = _a + 1;                             // changes the private _a variable in the current scope, but doesn't change the parent scope _a
};
systemChat str _a; // _a is still 1
```

### Example 2

```sqf
private _a = /* ... */;
private _b = /* ... */;
private _c = /* ... */;

{
    _x call {
        privateAll;
        import ["_a", "_b"];
        call _this;
    };
} forEach CustomEventHandlers;
```

1. Because of the [import](../commands/import.md)-statement, code from `CustomEventHandlers` can use `_a` and `_b` without using [params](../commands/params.md) (even if `_a` and `_b` were provided via `_this`, which is not the case here).
1. Code from `CustomEventHandlers` can only see `_a` and `_b`, but no other variables such as `_c`, `_x` or `_forEachIndex`.
1. Code from `CustomEventHandlers` can modify `_a` and `_b` (e.g. `_a = _b / 2`), but only within its own scope (i.e. `CustomEventHandlers # (n + 1)` will not see any changes that `CustomEventHandlers # n` may have made to `_a` and `_b`).
1. The values of `_a`, `_b` and `_c` after the [forEach](../commands/forEach.md)-loop are guaranteed to be the same as before the [forEach](../commands/forEach.md)-loop.

> [!IMPORTANT]
> There is one important exception to points 3 and 4: Modifications by reference (e.g. `_a pushBack 123` where `_a` is an [Array](../topics/Array.md)) are applied in all scopes. This can be avoided by copying `_a` before calling the `CustomEventHandlers` code:
>
> ```sqf
> private _a = [/* ... */]; // Note that _a is an array.
> private _b = /* ... */;
> private _c = /* ... */;
>
> {
>     _x call {
>         privateAll;
>         import ["_a", "_b"];
>         _a = +_a; // Copy the array so that the code from CustomEventHandlers can no longer modify the original array.
>         call _this;
>     };
> } forEach CustomEventHandlers;
> ```

## See also

[import](../commands/import.md) · [private](../commands/private.md) · [Variables](../topics/Variables.md)

<sub>Source: [BI Community Wiki — privateAll](https://community.bistudio.com/wiki/privateAll) (revision 369773).</sub>