PRIVATE
Declares variables that you can use in the routine where they're declared and in all lower-level subroutines.
Syntax
PRIVATE <memvar list> |
ALL
[LIKE <memvar skeleton 1>]
[EXCEPT <memvar skeleton 2>]
<memvar list>
The list of memory variables you want to declare private, separated by commas.
ALL
Makes private all memory variables declared in the subroutine.
LIKE <memvar skeleton 1>
Makes private the memory variables whose names are like the memory variable skeleton you specify for <memvar skeleton 1>. Use characters of the variable names and the wildcards * and ? to create <memvar skeleton 1>.
EXCEPT <memvar skeleton 2>
Makes private all memory variables except those whose names are like the memory variable skeleton you specify for <memvar skeleton 2>. Use characters of the variable names and the wildcards * and ? to create <memvar skeleton 2>. You can use LIKE and EXCEPT in the same statement, for example, PRIVATE ALL LIKE ?_* EXCEPT c_*.
Description
Use PRIVATE in a function to avoid accidentally overwriting a variable with the same name that was declared in a higher-level routine. Normally, variables are visible and changeable in lower-level routines. In effect, PRIVATE hides any existing variable with the same name that was not created in the current routine.It’s a good practice to always use LOCAL or PRIVATE. For example, if you write a function that someone else might use, you probably won’t know what variables they’re using. If you don’t use LOCAL or PRIVATE, you might accidentally change the value of one of their variables when they call your function.
Although they have some limitations, local variables are generally preferred over private variables because of their more limited visibilty. You cannot accidentally overwrite them in a lower-level routine, which would happen if you forget to hide a public variable; nor can you inadvertently use a variable created in a higher-level routine, thinking that it’s one declared in the current routine, which would happen if you misspell the variable name in the current routine. Also, private variables may be macro-substituted inadvertently with the & operator. For example, if you specify the text of a menu item as "&Close" to designate the letter C as the pick character and you happen to have a private variable named close, the variable with be macro-substituted when the menu is created. If the variable was declared local, this wouldn’t happen.
You must declare a variable PRIVATE before initializing it to a particular value. Declaring a variable PRIVATE doesn't create it, but it does hide any higher-level variable with the same name. After declaring a variable PRIVATE, you can create and initialize it to a value with STORE or =. (The := operator will not work at this point because the variable hasn’t been created yet.) Private variables are erased from memory when the routine that creates them finishes executing.
Unless declared otherwise, variables you initialize in programs are private. If you initialize a variable that has the same name as a variable created in the Command window or declared PUBLIC or PRIVATE in an earlier routine—in other words, a variable that is visible to the current routine—and don't declare the variable PRIVATE first, it is not created as a private variable. Instead, the routine uses and alters the value of the existing variable. Therefore, you should always declare your private variables, even though that is the default.
For more information, see PUBLIC for a table that compares the scope of public, private, local, and static variables.