Scripting Guide - SAS

216 Programming Methods Chapter 8
Advanced Programming Concepts
dt=new table(); // to get an empty data table
if (nrow(CurrentDataTable())==0, throw("!Empty Data Table"));
Functions
JSL also has a function called Function to extend the macro concept with a local context arguments.
Suppose that you want to create a function that takes the square root but tolerates negative arguments,
returning zero rather than errors. You first specify the local arguments in a list with braces { } and then state
the expression directly. You do not need to enclose the expression in Expr because Function stores it as an
expression implicitly.
myRoot = function({x},if(x>0,sqrt(x),0));
a = myRoot(4); // result in a is 2
b = myRoot(-1); // result in b is 0
Functions are stored in globals, the same as values. This means that you cannot have both a root function
and a root value. It also means that you can redefine a function anytime except when you are inside the
function itself.
When a function is called, its arguments are evaluated and given to the local variables specified in the list
forming the first argument. Then the body of the function, the second argument, is evaluated.
The values of the arguments are for the temporary use of the function. When the function is exited, the
values are discarded. The only value returned is the return value. If you want to return several values, then
return a list instead of a single value.
In defined functions, the stored function is not accessible directly, even by the Name Expr command. If you
need to access the function expression in your script, you have to create the function within an expr()
clause. For example,
makeFunction = expr(myRoot=function({x}, if (x>0, sqrt(x), 0)));
d=substitute(
NameExpr(MakeFunction),
expr(x), expr(y)
);
show(d);
makeFunction;
Local Symbols
You can declare variables as local to a function so that they do not affect the global symbol space. This is
particularly useful for recursive functions, which need to keep separate the values of the local variables at
each level of function call evaluation.
As shown above, a function definition looks as follows.
functionName=Function({arg1, ...}, body);
You can also have the function definition default all the unscoped names to be local.
functionName=Function({arg1, ...}, {Default Local}, body);