Difference between revisions of "LSL Variables"

From Second Life Wiki
Jump to navigation Jump to search
m (Replaced old <LSL> block with <source lang="lsl2">)
 
(27 intermediate revisions by 13 users not shown)
Line 1: Line 1:
A '''variable''' is a place to store information, like a number or strings.
{{LSL Header|ml=*}}


LSL is a strongly and dynamically typed language. This means that variables must be declared by type and that variables may only hold values of a corresponding type.
A '''variable''' is a place to store information, like a number or a string.


==Variable Conventions==
A variable has a name, a type, and a value.  The name starts with a letter or underscore ("_"), and the name convention is similar to C or Java.  Case matters.  ''X'' is not the same as ''x''.
=== Common Variable Uses===
* '''i''' is usually used as an index variable in a {{LSLG|for}} loop.  '''j''' is usually used for a nested for loop (when i is already being used), and then '''k'''.
* '''x''', '''y''', and '''z''' usually refer to the first three dimensions of some vector (when applicable).


===Magic Numbers===
LSL is a strongly and statically typed language. This means that variables must be declared by type and that variables may only hold values of a corresponding type. However, a list variable may hold zero or more values of any other type.
The phrase "magic number" refers to a number written literally as a constant in code, but the meaning is not intuitive from the context of the code.  It may also be such a number used repeatedly throughout the code.


For example:
Some examples:
<source lang="lsl2">integer  count  = 2;            //A whole number
float    measure = 1.2;          //A number with decimal places
string  chars  = "Lee";        //Any text within " "
list    words  = ["This", "Is", "A", "List"];
list    entries = ["A list may contain many types of values such as", 2, 1.2, <0.4, 0.8, 1.6>];
vector  vec_2  = <1,6,2>;      //Generally used for position as xyz, but can be used to store 3 numbers to be parsed out later
rotation _rot    = <1,2,3,4>;    //Can also be used to store 4 numbers to be parsed out later</source>


if ( vctSpd.z < 10 ) {
== Scope of variables ==
}
A variable can be limited to only certain parts of the script, depending upon where it is placed.  This placement, and the areas where it is enabled is called the "scope."  Variables that apply to the entire script are called global variables: they are defined at the top of the script above the state declarations.  Variables that are within functions or within nested areas are considered local variables.


The 10 is a "magic number". In a scenario where this test is repeated 20 times in the script, any change to the number would require 20 updates by hand, which increases the chance for errors.
The variable name is in scope from the point it first appears to the end of the scope it is in, or the end of the script for global variables. A name may not be defined twice in the same scope, but a name may be redefined in an inner scope, and it hides the same name at outer scope. Again, the semantics are very similar to C and Java. That is to say, the following code will compile and run.
<source lang="lsl2">integer i = 50;


To avoid magic numbers, declare a variable of the appropriate type, set the value of the variable in the declaration and use the variable in your code.
default
{
    state_entry()
    {
        string i = "Hello there!"; //This WILL compile just fine, unlike in Java.
        llOwnerSay(i); //Will say "Hello there!". There is no way to get the global variable i.
    }
}</source>


integer intSlowSpeed = 10;
I found this confusing at first, this may make it a little clearer:
The same rules apply to any variable type, a local variable name will overide any global variable previously defined
<source lang="lsl2">string  j = "Global Hi";
integer i = 50;


if ( vctSpd.z < intSlowSpeed) {
default
}
{
    state_entry()
    {
        string i = "Hello there!"; //This WILL compile just fine, unlike in Java.
        llOwnerSay(i); //Will say "Hello there!". this is the local variable, accessed only in this part of the script
        llOwnerSay(j); //Will say "Global Hi", this is the global variable that can be accessed anywhere in the script
    }
}</source>


Updating the value of intSlowSpeed here requires only one change and reduces the opportunity for error. The name of the variable also expresses its meaning.
 
Converting between variable types is know as casting. for example in the script above, the global variable i has a value of 50. This can be cast to a string to send the value as text to the chat window. This can also be done with local variables.
This is commonly used for debugging a script.
 
 
<source lang="lsl2">integer i = 50;
 
default
{
    state_entry()
    {
        llOwnerSay((string) i); //Will say "50". the global integer has been changed ( cast ) to a string.
        integer j = 60;
        llOwnerSay((string) j); //Will say "60". the local integer has been changed ( cast ) to a string.
    }
}</source>
 
 
A global variable can be defined with or without a value and the value can be changed later in the script.
Note that in setting the value of j, only the name was used, the type ( integer) is already set globally,
wheras the variable k, is set locally and has its type and value set there.
<source lang="lsl2">integer i = 50;
integer j;
 
default
{
    state_entry()
    {
        llOwnerSay((string) i); //Will say "50". the integer was given a value at declaration.
        j = 60;  //Value added to a global variable
        llOwnerSay((string) j); //Will say "60". the value was added later.
        integer k = 70; //Name, type and value set within a local scope
    }
}</source>
== See Also ==
* [[string]]
* [[key]]
* [[integer]]
* [[float]]
* [[list]]
* [[vector]]
* [[rotation]]

Latest revision as of 01:47, 22 January 2015

A variable is a place to store information, like a number or a string.

A variable has a name, a type, and a value. The name starts with a letter or underscore ("_"), and the name convention is similar to C or Java. Case matters. X is not the same as x.

LSL is a strongly and statically typed language. This means that variables must be declared by type and that variables may only hold values of a corresponding type. However, a list variable may hold zero or more values of any other type.

Some examples: 

integer  count   = 2;            //A whole number
float    measure = 1.2;          //A number with decimal places
string   chars   = "Lee";        //Any text within " "
list     words   = ["This", "Is", "A", "List"];
list     entries = ["A list may contain many types of values such as", 2, 1.2, <0.4, 0.8, 1.6>];
vector   vec_2   = <1,6,2>;      //Generally used for position as xyz, but can be used to store 3 numbers to be parsed out later
rotation _rot    = <1,2,3,4>;    //Can also be used to store 4 numbers to be parsed out later

Scope of variables

A variable can be limited to only certain parts of the script, depending upon where it is placed. This placement, and the areas where it is enabled is called the "scope." Variables that apply to the entire script are called global variables: they are defined at the top of the script above the state declarations. Variables that are within functions or within nested areas are considered local variables.

The variable name is in scope from the point it first appears to the end of the scope it is in, or the end of the script for global variables. A name may not be defined twice in the same scope, but a name may be redefined in an inner scope, and it hides the same name at outer scope. Again, the semantics are very similar to C and Java. That is to say, the following code will compile and run. 

integer i = 50;

default 
{
    state_entry() 
    {
        string i = "Hello there!"; //This WILL compile just fine, unlike in Java.
        llOwnerSay(i); //Will say "Hello there!". There is no way to get the global variable i.
    }
}

I found this confusing at first, this may make it a little clearer: The same rules apply to any variable type, a local variable name will overide any global variable previously defined 

string  j = "Global Hi";
integer i = 50;

default 
{
    state_entry() 
    {
        string i = "Hello there!"; //This WILL compile just fine, unlike in Java.
        llOwnerSay(i); //Will say "Hello there!". this is the local variable, accessed only in this part of the script
        llOwnerSay(j); //Will say "Global Hi", this is the global variable that can be accessed anywhere in the script
    }
}


Converting between variable types is know as casting. for example in the script above, the global variable i has a value of 50. This can be cast to a string to send the value as text to the chat window. This can also be done with local variables. This is commonly used for debugging a script. 


integer i = 50;

default 
{
    state_entry() 
    {
        llOwnerSay((string) i); //Will say "50". the global integer has been changed ( cast ) to a string.
        integer j = 60;
        llOwnerSay((string) j); //Will say "60". the local integer has been changed ( cast ) to a string.
    }
}


A global variable can be defined with or without a value and the value can be changed later in the script. Note that in setting the value of j, only the name was used, the type ( integer) is already set globally, wheras the variable k, is set locally and has its type and value set there. 

integer i = 50;
integer j;

default 
{
    state_entry() 
    {
        llOwnerSay((string) i); //Will say "50". the integer was given a value at declaration.
        j = 60;  //Value added to a global variable
        llOwnerSay((string) j); //Will say "60". the value was added later.
        integer k = 70; //Name, type and value set within a local scope
    }
}

See Also

Retrieved from "https://wiki.secondlife.com/w/index.php?title=LSL_Variables&oldid=1194246"