=

// global scope function one(){ alert(a); }

// local scope function two(a){ alert(a); }

// local scope again function three(){ var a = 3; alert(a); }

// Intermediate: no such thing as block scope in javascript function four(){ if(true){ var a=4; }

alert(a); // alerts '4', not the global value of '1'

}

// Intermediate: object properties function Five(){ this.a = 5; }

// Advanced: closure var six = function(){ var foo = 6;

return function(){
    // javascript "closure" means I have access to foo in here,
    // because it is defined in the function in which I was defined.
    alert(foo);
}

}()

// Advanced: prototype-based scope resolution function Seven(){ this.a = 7; }

// [object].prototype.property loses to [object].property in the scope chain Seven.prototype.a = -1; // won't get reached, because 'a' is set in the constructor above. Seven.prototype.b = 8; // Will get reached, even though 'b' is NOT set in the constructor.

// These will print 1-8 one(); two(2); three(); four(); alert(new Five().a); six(); alert(new Seven().a); alert(new Seven().b);

</div>

## Joy

JOY does not have variables. Variables essentially name locations in memory, where values are stored. JOY also uses memory to store values, but has no facility to name these locations. The memory that JOY uses is commonly referred to as "the stack".

'''Initializing'''

The JOY stack can be initialized:

```joy
[] unstack

'''Assignment'''

Values can be pushed on the stack:

pushes the value 42 of type integer on top of the stack.

'''Stack'''

Calling the stack by name pushes a copy of the stack on the stack. To continue the previous example:

```joy>stack</lang

pushes the list [42] on top of the stack. The stack now contains: [42] 42.

## jq

jq variables are strictly speaking not variable: they are just names given to JSON values.  For example, the expression "1 as $x | 2 as $x | $x " can be understood as assigning the value 1 to $x and then assigning another value to $x, with the final result being 2, but it must be understood that the second occurrence of $x shadows the first, so that the third occurrence is just a reference to the second.  To see this more clearly, consider the following superficially similar expression:

```jq
jq -n '1 as $x | (2 as $x | $x) | $x'

In this case, the expression as a whole yields 1 (rather than 2 as previously), as the subexpression in parentheses does not cause shadowing of the first $x.

'''Naming and Assignment'''

In a jq program, variable names are strings beginning with "$" followed by one or more characters chosen from the set of alphanumeric characters augmented with the "_" (underscore) character. Assignment within a jq program is based on the syntax:

EXPRESSION as $NAME

This establishes $NAME as a reference to the value of EXPRESSION. There is no special syntax to constrain the type of a variable.

'''Global Variables'''

Global variables can be given values on the jq command line. For example, suppose the following two lines are in a file named test.jq:

def test: $x;
test

The following invocation:

jq --arg x 123 -n -f test.jq

will result in the string "123" being output.

Liberty BASIC

'In Liberty BASIC variables are either string or numeric.
'A variable name can start with any letter and it can contain both letters and numerals, as well as dots (for example: user.firstname).
'There is no practical limit to the length of a variable name... up to ~2M characters.
'The variable names are case sensitive.

'assignments:   -numeric variables. LB assumes integers unless assigned or calculated otherwise.
'Because of its Smalltalk heritage, LB integers are of arbitrarily long precision.
'They lose this if a calculation yields a non-integer, switching to floating point.
    i = 1
    r = 3.14

'assignments    -string variables. Any string-length, from zero to ~2M.
    t$    ="21:12:45"
    flag$ ="TRUE"

'assignments    -1D or 2D arrays
'A default array size of 10 is available. Larger arrays need pre-'DIM'ming.
    height( 3)          =1.87
    dim height( 50)
    height( 23)         =123.5
    potential( 3, 5)    =4.5
    name$( 4)           ="John"

'There are no Boolean /bit variables as such.

'Arrays in a main program are global.
'However variables used in the main program code are not visible inside functions and subroutines.
'They can be declared 'global' if such visibility is desired.
'Functions can receive variables by name or by reference.

Julia

Certain constructs in the language introduce scope blocks, which are regions of code that are eligible to be the scope of some set of variables. The scope of a variable cannot be an arbitrary set of source lines, but will always line up with one of these blocks. The constructs introducing such blocks are:

function bodies (either syntax) while loops for loops try blocks catch blocks let blocks type blocks.

#declaration/assignment, declaration is optional
x::Int32 = 1
#datatypes are inferred dynamically, but can also be set thru convert functions and datatype literals
x = 1 #x is inferred as Int, which is Int32 for 32-bit machines, Int64 for 64-bit machines
#variable reference
julia>x
1

x = int8(1) #x is of type Int8
x = 1.0 #x is Float64
x = y = 1 #assign both x and y to 1
global x = 1 #assigns 1 to global variable x (used inside scope blocks)
local x = 1 #assigns 1 to local variable x (used inside scope blocks)
x = 'a' #x is a 'Char' type, designated by single quotes
x = "a" #x is a 1-element string, designated by double quotes

A common use of variables is giving names to specific, unchanging values. Such variables are only assigned once. This intent can be conveyed to the compiler using the const keyword:

const e  = 2.71828182845904523536
const pi = 3.14159265358979323846

Kotlin

Local variables in Kotlin (i.e. variables created within a function, constructor or a property getter/setter) must be individually declared and initialized before they are used. They then remain in scope until the end of the block in which they are declared though their lifetime may be extended if they are 'captured' by a closure of some kind.

A variable's type can either be inferred from the type of the initialization expression or can be declared explicitly. There are essentially two types of variables: read-only (declared with 'val') and mutable (declared with 'var').

Variables declared at top-level or class/object scope are technically properties rather than variables and only have hidden backing fields where necessary. However, like local variables, they are either read-only or mutable and (in the case of top level or object properties) can be declared to be compile-time constants using the 'const val' modifier.

Here are some examples of local variables:

// version 1.0.6

fun main(args: Array<String>) {
    /* read-only variables */
    val i = 3          // type inferred to be Int
    val d = 2.4        // type inferred to be double
    val sh: Short = 2  // type specified as Short
    val ch = 'A'       // type inferred to be Char
    val bt: Byte = 1   // type specified as Byte

    /* mutable variables */
    var s = "Hey"      // type inferred to be String
    var l =  4L        // type inferred to be Long
    var b: Boolean     // type specified as Boolean, not initialized immediately
    var f =  4.4f      // type inferred to be Float

    b = true           // now initialized
    println("$i, $d, $sh, $ch, $bt, $s, $l, $b, $f")

    s = "Bye"          // OK as mutable
    l = 5L             // OK as mutable
    b = false          // OK as mutable
    f = 5.6f           // OK as mutable

    println("$i, $d, $sh, $ch, $bt, $s, $l, $b, $f")
}

{{out}}

3, 2.4, 2, A, 1, Hey, 4, true, 4.4
3, 2.4, 2, A, 1, Bye, 5, false, 5.6

Lasso

// declare thread variable, default type null
var(x)
$x->type // null

// declare local variable, default type null
local(x)
#x->type // null

// declare thread variable, initialize with a type, in this case integer
var(x = integer)

// declare local variable, initialize with a type, in this case integer
local(x = integer)

// assign a value to the thread var x
$x = 12

// assign a value to the local var x
$x = 177

// a var always has a data type, even if not declared - then it's null
// a var can either be assigned a type using the name of the type, or a value that is by itself the type
local(y = string)
local(y = 'hello')

'\r'
// demonstrating asCopyDeep and relationship between variables:
local(original) = array('radish', 'carrot', 'cucumber', 'olive')
local(originalaswell) = #original
local(copy)     = #original->asCopyDeep
iterate(#original) => {
    loop_value->uppercase
}
#original		// modified
//array(RADISH, CARROT, CUCUMBER, OLIVE)
'\r'
#originalaswell // modified as well as it was not a deep copy
//array(RADISH, CARROT, CUCUMBER, OLIVE)
'\r'
#copy			// unmodified as it used ascopydeep
//array(RADISH, CARROT, CUCUMBER, OLIVE)

Lingo

In Lingo (local) variables are declared by assigning a value:

x = 23
y = "Hello world!"
z = TRUE -- same effect as z = 1

Trying to use a non declared variable causes a (pre)compile-time error. The following script doesn't compile, but throws "Script error: Variable used before assigned a value":

on foo
  put x
end

Lingo's value function can be used to "silently" - i.e. without throwing errors - check if a variable is defined or not in the current scope:

put value("x")
-- <Void> -- means: undefined

But variable declarations/assignments can also explicitely assign the constant VOID. The following script compiles successfully, but value("x") would still return :

on foo
  x = VOID
  put x
end

Global variables are declared by adding "global " either to the top of a script or anywhere - but before first usage - inside a function body. Both of the following scripts are valid and compile:

global x
on foo
  put x
end

on foo
  global x
  put x
end

Global variables can also be declared/created at runtime, by adding them as property to the special _global object:

_global.x = 23

Any other function/script can then access this dynamically created global variable, either by a having a "global " statement in its code (see above), or by using this special _global object:

put _global.x

Logo

Historically, Logo only had global variables, because they were easier to access when stepping through an algorithm. Modern variants have added dynamic scoped local variables. {{works with|UCB Logo}}

make "g1 0
name 2 "g2    ; same as make with parameters reversed
global "g3     ; no initial value
to func :x
  make "g4 4   ; still global
  localmake "L1 6
  local ["L2 "L3]    ; local variables, collection syntax
  func2 :g4
  print :L2      ; 9,  modified by func2
  print :L3      ; L3 has no value, was not modified by func2
end
to func2 :y
  make "g3 :y
  make "L2 :L1 + 3     ; dynamic scope: can see variables of callers
  localmake "L3 5       ; locally override L3 from caller
  (print :y :L1 :L2 :L3)      ; 4 6 9 5
end
print :g4   ; 4
print :L1   ; L1 has no value
print name? "L1    ; false, L1 is not bound in the current scope

LotusScript

Sub Click()
'a few declarations as example
Dim s as New NotesSession ' declaring a New NotesSession actually returns the current, active NotesSession
Dim i as Integer ' i = 0
Dim s as String ' s= ""
Dim v as Variant ' v is nothing
Dim l as Long ' l = 0
Dim doc as NotesDocument 'doc is EMTPY

'...

End Sub

Lua

In lua, variables are dynamically typecast, and do not need declaration prior to use.

a = 1    -- Here we declare a numeric variable
fruit = "banana"    -- Here we declare a string datatype
needspeeling = True    -- This is a boolean
local b = 2    -- This variable declaration is prefixed with a scope modifier

The lua programming language supports multiple assignments from within a single statement:

A, B, C, D, E = 2, 4, 6, 8, "It's never too late"

M2000 Interpreter

Each module has own local variables and can create global variables. A local variable shadow any global with same name. A new global with same name shadow a global variable (but its wrong to create a local first with same name, we see local always). We can change global variables, but to assign to a global variable we need to use <=. Arrays defined with DIM and global arrays not use <= for assign values to items.

Variables can exist in Groups as public or private. Also variables can be closures in lambda functions.

We can use '''Local''' to make local variables, '''Let''' to make variables, '''Def''' to make once variables (second time using Def for same variable we get error). We can use '''Input''' and '''Read''' to make new variables too. We can assign a value to new name, to make a variable.

\\ M2000 use inference to state the type of a new variable, at run time
\\ We can use literals of a numeric type
\\ @ for Decimal
\\ # for Currency
\\ ~ for Single
\\ & for Long (32bit)
\\ % for Integer (16bit)
\\ Double and Boolean have no symboles
Module TopA {
      Module Alfa {
                  Print A=10000, Type$(A)="Double"
                  \\ A is local, we use =
                  A=10@
                  Print A=10, Type$(A)
                  \\ Or we can state the type before
                  Def Currency K, Z=500, M
                  K=1000
                  \\ Currency Currency Currency
                  Print Type$(K), Type$(Z), Type$(M)
                  Def Double K1, K2 as Integer=10, K3=1
                  \\ double integer double
                  Print Type$(K1), Type$(K2), Type$(K3)
                  Mb=1=1
                  \\ We get a boolean
                  Print Type$(Mb)
                  Def boolean Mb1=True
                  Print Type$(Mb1)
                  \\ True and False are Double -1 and 0 not Boolean
                  Mb3=True
                  Print Type$(Mb3)="Double"
                  \\ For strings we have to use $ (like in old Basic)
                  A$="This is a String"
                  Global G1 as boolean = True
                  \\ To change a global variable we have to use <=
                  G1<=1=0
                  \\ If we do this: G1=1=0 we make a local variable, and shadow global
                  \\ In a For Object {} we can make temporary variables
                  For This {
                        Local G1=122.1212
                        Print G1, Type$(G1)="Double"
                  }
                  Print G1, Type$(G1)="Boolean"
      }
      \\ shadow A for this module only
      A=100
      \\ Now we call Alfa
      Alfa
      Print (A=100)=True
}
Global A=10000
TopA
Print A=10000
Module CheckStatic {
      \\ clear static variables and variables (for this module)
      Clear
      Module K {
            \\ if no A exist created with value 100@
            \\ Static variables can't be referenced
            Static A=100@
            Print A, Type$(A)="Decimal"
            A++
      }
      For i=1 to 10 : K : Next i
      Print A=10000
}
CheckStatic
Print A=10000

\\ reference and use of stack of values
C=100&
Module ChangeC {
      \\ we leave arguments in stack of values
      Module HereChangeC (&f) {
            \\ interpreter execute a Read &f
            f++
      }
      \\ now we call HereChangeC passing current stack of values
      HereChangeC
}
\\ Calling a module done without checking for what parameters a module take
ChangeC &C
Print C, Type$(C)="Long"
K=10010001001@
ChangeC &K
Print K, Type$(K)="Decimal"
Module TypeRef (&x as Double) {
     Print x
     x++
}
D=100
TypeRef  &D
Try ok {
      TypeRef &K
}
If Error or Not Ok then Print Error$ ' we get wrong data type

Maple

Variables are dynamic in Maple, so they do not need to be defined before they are used.

The assignment operator in Maple is := . It is also possible to assign to a variable name using the assign() command. It can also be noted that variables at the top level are global for a given session.

a := 1:
print ("a is "||a);
                            "a is 1"

Variables in a procedure should be declared with the "local" or "global" keyword.

A local variable has a smaller scope and can only be used within the procedure it's declared in. In the following example, b is local to f() and will be 3 within the procedure only. The local variable b does not have a value outside the procedure.

b;
f := proc()
    local b := 3;
    print("b is "||b);
end proc:
f();
print("b is "||b);
                               b
                            "b is 3"
                            "b is b"

A global variable has a large scope and can be used anywhere inside a program. A global variable declared outside a procedure can be used within the procedure, and a global variable declared within a procedure can be used outside of it. In the following example, a is a global variable that is from outside the procedure. The global variable c has a value even when used outside the procedure it was declared in.

f := proc()
    global c;
    c := 3;
    print("a is "||a);
    print("c is "||c);
end proc:
f();
print("c is "||c);
                            "a is 1"
                            "c is 3"
                            "c is 3"

Variables can be reassigned.

print ("a is "||a);
a := 4:
print ("a is "||a);
                            "a is 1"
                            "a is 4"

Variables can be reassigned as different datatypes.

print ("a is "||a);
type(a, integer);
a := "Hello World":
print ("a is "||a);
type(a, integer);
type(a, string);
                            "a is 4"
                              true
                       "a is Hello World"
                             false
                              true

Variable names may contain spaces and other characters when you enclose them in ``.

`This is a variable` := 1:
print(`This is a variable`);
                               1

To unassign a variable.

print ("a is "||a);
type(a, string);
print("c is "||c);
a := 'a':
print ("a is "||a);
type(a, symbol);
unassign('c');
print("c is "||c);
                       "a is Hello World"
                              true
                            "c is 3"
                            "a is a"
                              true
                            "c is c"

Here, symbol is essentially another term for variable name.

Mathematica

x=value	assign a value to the variable x
x=y=value	assign a value to both x and y
x=. or Clear[x]	remove any value assigned to x

lhs=rhs (immediate assignment)	rhs is evaluated when the assignment is made
lhs:=rhs (delayed assignment)	rhs is evaluated each time the value of lhs is requested

'''Atomic Objects'''

All expressions in Mathematica are ultimately made up from a small number of basic or atomic types of objects.

Symbol / String / Integer / Real / Rational / Complex

These objects have heads which are symbols that can be thought of as "tagging" their types.
The objects contain "raw data", which can usually be accessed only by functions specific to the particular type of object.
You can extract the head of the object using Head, but you cannot directly extract any of its other parts.

'''Symbols are the basic named objects in Mathematica'''

aaaaa	user-defined symbol
Aaaaa	system-defined symbol
$Aaaa	global or internal system-defined symbol
aaaa$	symbol renamed in a scoping construct
aa$nn	unique local symbol generated in a module

'''Contexts'''

aaaa`x is a symbol with short name x, and context aaaa.
Contexts in Mathematica work somewhat like file directories in many operating systems.
You can always specify a particular file by giving its complete name, including its directory.
But at any given point, there is usually a current working directory, analogous to the current Mathematica context.
Files that are in this directory can then be specified just by giving their short names.

'''Scoping Constructs'''

With[] evaluate with specified variables replaced by values
Module[] localize names of variables (lexical scoping)
Block[] localize values of variables (dynamic scoping)
DynamicModule[] localize names of variables in dynamic interface constructs

Other Forms of Scoping
Begin, End  localize symbol namespace
Throw, Catch  localize exceptions
Quiet, Check localize messages
BlockRandom localize pseudorandom variables

=={{header|MATLAB}} / {{header|Octave}}==

	a = 4; % declare variable and initialize double value,
        s = 'abc'; % string
        i8 = int8(5);	% signed byte
        u8 = uint8(5);	% unsigned byte
        i16 = int16(5);	% signed 2 byte
        u16 = uint16(5); % unsigned 2 byte integer
        i32 = int32(5);	% signed 4 byte integer
        u32 = uint32(5);% unsigned 4 byte integers
        i64 = int64(5);	% signed 8 byte integer
        u64 = uint64(5);% unsigned 8 byte integer
	f32 = float32(5); % single precision floating point number
	f64 = float64(5); % double precision floating point number , float 64 is the default data type.

	c = 4+5i; %	complex number
        colvec = [1;2;4];   % column vector
        crowvec = [1,2,4];   % row vector
        m = [1,2,3;4,5,6];  % matrix with size 2x3

Variables within functions have local scope, except when they are declared as global

## Mercury


Variables are normally implicitly instantiated into their natural scope, if not referred to in the head of the rule (as in <code>Name</code> below) and can only be bound once. This feels very similar to Erlang, where variables are function-scoped and single-assignment, without declaration. However, Mercury will reorder code to satisfy data dependencies, so assignments can appear to be out of order:


```Mercury
:- func name = string.
name = Name :-
    Name = Title ++ " " ++ Given,
    Title = "Dr.",
    Given = "Bob".

Mercury also has state variables, actually pairs of variables, usually instantiated in the head of a rule.

:- pred greet(string::in, io::di, io::uo) is det.
greet(Who, !IO) :-
    io.write_string("Hello", !IO),
    io.format(", %s!\n", [s(Who)], !IO).

In this example !IO is the state variable, and this code translates to

:- pred greet(string::in, io::di, io::uo) is det.
greet(Who, !.IO, !:IO) :-
    io.write_string("Hello", !.IO, !:IO),
    io.format(", %s!\n", [s(Who)], !.IO, !:IO).

which translates roughly to:

:- pred greet(string::in, io::di, io::uo) is det.
greet(Who, IO0, IO) :-
    io.write_string("Hello", IO0, IO1),
    io.format(", %s!\n", [s(Who)], IO1, IO).

!.IO is the bound 'current value' of IO, !:IO is the free 'next value' of IO, and the lexical appearance of these variables matters to their final translation to the normal variables in the third example, where data dependency enforces the intended order of operation (so that "Hello" is always written before the name.)

When state variables are instantiated within a rule, they need explicit instantiation, which you could think of as like a declaration without initialization. The state variable in the following example is existentially quantified, and is used for a temporary string builder:

:- func dr(string) = string.
dr(Name) = Titled :-
    some [!SB] (
        !:SB = string.builder.init,
        put_char(handle, 'D', !SB),
        put_char(handle, 'r', !SB),
        format(handle, " %s", [s(Name)], !SB),
        Titled = to_string(!.SB)
    ).

Existential vs. universal quantification comes up again to let you make local use of nondeterministic code, as in the following use of a nondeterministic list.member/2.

    % all_under(N, L)
    % True if every member of L is less than N
    %
:- pred all_under(int::in, list(int)::in) is semidet.
all_under(Limit, L) :-
    all [N] (member(N, L) => N < Limit).

In pure Mercury code that only uses functional data types, and only normal functions in higher-order code, variables can be said to be either 'free' or 'ground' where they're found in code, before the goal they're in changes their instantiation (for example to bind a free variable to a value, making it ground). The only exception are the 'state of the world' values used for I/O, which have 'unique' and 'dead' instantiations.

But as soon as you have higher-order predicates or non-functional data types (and this happens very easily even in rookie code, for example if you use the getopt module to handle command line arguments), then instantiations get more complex. For non-functional data types like arrays this might just mean using some special modes in your rules, but here's an extreme example:

:- type accumulator == (pred(int, int, io, io)).
:- inst accumulator == (pred(in, out, di, uo) is det).

:- func accumulator >> accumulator = accumulator.
:- mode in(accumulator) >> in(accumulator) = out(accumulator).
A >> B = C :-
    C = (pred(!.N::in, !:N::out, !.IO::di, !:IO::uo) is det :-
        A(!N, !IO),
        B(!N, !IO)).

:- pred add(int::in, int::in, int::out, io::di, io::uo) is det.
add(N, !Acc, !IO) :-
    io.format("adding %d to accumulator (current value: %d)\n",
        [i(N), i(!.Acc)], !IO),
    !:Acc = !.Acc + N.

:- pred example2(io::di, io::uo) is det.
example2(!IO) :-
    F = add(5)
        >> add(5)
        >> add(-10),
    F(0, X, !IO),
    io.print_line(X, !IO).

{{out}}

adding 5 to accumulator (current value: 0)
adding 5 to accumulator (current value: 5)
adding -10 to accumulator (current value: 10)
0

In that last example all of the insts and modes are just there to make the higher-order code work, so this system might seem like only a chore. It helps though in permitting efficient code with uniqueness, and it lets Mercury not always pay the costs of its logical facilities (there's underlying machinery required for a nondet call, which might be backtracked through, which isn't required in a det call). The variable instantiation system can also be used to provide static guarantees similar to those offered by dependently typed languages; an example of this is the non_empty_list instantiation used by the solutions module. This is getting really advanced, but here's a simple example of instantiation (ab)use:

:- module evenodd.
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.
:- implementation.
:- import_module list, string.

:- type coin
    --->    heads
    ;       tails.

:- inst heads for coin/0
    --->    heads.
:- inst tails for coin/0
    --->    tails.

main(!IO) :-
    (if heads(heads, N) then
        print_heads(N, !IO)
    else true).

:- pred print_heads(coin::in(heads), io::di, io::uo) is det.
print_heads(_, !IO) :-
    io.write_string("heads\n", !IO).

:- pred print_tails(coin::in(tails), io::di, io::uo) is det.
print_tails(_, !IO) :-
    io.write_string("tails\n", !IO).

:- pragma foreign_export_enum("C", coin/0, [prefix("COIN_"), uppercase]).

:- pred heads(coin::in, coin::out(heads)) is semidet.
:- pragma foreign_proc("C",
    heads(N::in, M::out(heads)),
    [promise_pure, will_not_call_mercury],
"
    M = N;
    SUCCESS_INDICATOR = N == COIN_HEADS;
").

Here, print_heads and print_tails take, by type, a coin, which could be either heads or tails, but this code has used the variable instantiation system to insist that they can each only accept one particular value. If you take this code and change the main/2 so that it instead tries to call print_tails(N, !IO), you'll get a compile-time error. A practical use of this is to avoid having to handle impossible (but well-typed) cases.

=={{header|Modula-3}}==

MODULE Foo EXPORTS Main;

IMPORT IO, Fmt;

VAR foo: INTEGER := 5; (* foo is global (to the module). *)

PROCEDURE Foo() =
  VAR bar: INTEGER := 10; (* bar is local to the procedure Foo. *)
  BEGIN
    IO.Put("foo + bar = " & Fmt.Int(foo + bar) & "\n");
  END Foo;

BEGIN
  Foo();
END Foo.

For procedures, the formal parameters create local variables unless the actual parameter is prefixed by VAR:

PROCEDURE Foo(n: INTEGER) =

Here, n will be local to the procedure Foo, but if we instead wrote:

PROCEDURE Foo(VAR n: INTEGER) =

Then n is the global variable n (if it exists).

Nim

var x: int = 3

var y = 3 # type inferred to int

var z: int # initialized to 0

let a = 13 # immutable variable

var
  b, c: int = 10
  s = "foobar"

Objeck

Different ways to declare and initialize an integer.

a : Int;
b : Int := 13;
c := 7;

OCaml

The default handlers for values in OCaml are not variables ''strictly speaking'', because as OCaml is a functional language these values can't vary (so are not variable). ''Strictly speaking'' these are bindings. An identifier is bound to a value in an immutable way.

The standard way to bind an identifier to a value is the '''let''' construct:

This stated, ocaml programmers most often use the word ''variable'' when they refer to bindings, because in the programming world we usually use this word for the default values handlers.

Now to add confusion, real variables also exist in OCaml because it is an ''impure'' functional language. They are called references and are defined this way:

```ocaml>let y = ref 28</lang

References can then be accessed and modified this way:

```ocaml
  !y       (* access *)
  y := 34  (* modification *)

An identifier can not be declared uninitialised, it is always defined with an initial value, and this initial value is used by the OCaml type inference to infer the type of the binding.

Inside an expression, bindings are defined with the '''let .. in''' construct, and we can also define multiple bindings with the '''let .. and .. in''' construct (here the expression can be the definition of a new identifier or the definition of a function):

let sum =     (* sum is bound to 181 *)
  let a = 31
  and b = 150 in
  (a + b)

let sum () =  (* sum is a function which returns 181 *)
  let a = 31
  and b = 150 in
  (a + b)

Oforth

Oforth does not have :

• Global variables.

• Class attributes.

Apart from the data stack that is global to a task, a function or method cannot modify something global.

Variables are local to functions or methods that declare them. They are a list of names between two pipes, declared at the beginning of a body. They are always initialized with null value.

Using a variable just push its value on the data stack. Using -> removes the top of the stack and assign this value to the variable

import: date

: testVariable
| a b c |
   Date now ->a
   a println ;

ooRexx

While REXX (and ooRexx) normally pass arguments ''by value''. ooRexx has a mechanism to pass compound variables ''by reference''. a.=4711 Say 'before sub a.3='a.3 Call sub a. Say ' after sub a.3='a.3 Exit sub: Procedure use Arg a. a.3=3 Return

{{out}}

```txt
before sub a.3=4711
 after sub a.3=3

Openscad

mynumber=5+4; // This gives a value of nine

Oz

Variable names in Oz always start with an uppercase letter.

Oz variables are dataflow variables. A dataflow variable can basically be free (unbound) or determined (has a value). Once a value has been assigned, it can not be changed. If we assign the same value again, nothing happens. If we assign a different value to an already determined variable, an exception is raised:

declare
Var         %% new variable Var, initially free
{Show Var}
Var = 42    %% now Var has the value 42
{Show Var}
Var = 42    %% the same value is assigned again: ok
Var = 43    %% a different value is assigned: exception

In the Emacs-based interactive environment, declare creates a new open scope in which variables can be declared. The variables are visible for the entire rest of the session.

Most operations on free variables block until the variables have been bound (but not Show as used above).

Assignment to dataflow variables is also called unification. It is actually a symmetric operation, e.g. the following binds B to 3:

declare
  A = 3
  B
in
  A = B
 {Show B}

However, variables can only be introduced at the left side of the = operator. So this is a syntax error:

declare
  A = 3
  A = B  %% Error: variable B not introduced
in
 {Show B}

It is possible to introduce multiple variables in a single statement:

declare
   [A B C D] = [1 2 3 4]  %% unification of two lists

In a module definition, toplevel variables can be introduced between the keywords define and end without the need for declare. The range between these two keywords is also their scope. Toplevel variables can optionally be exported.

functor
export Function
define
   ToplevelVariable = 42

   fun {Function}
     42
   end
end

Function and class definitions introduce a new variable with the name of the function/class and assign the new function/class to this variable.

Most Oz statement introduce a new scope and it is possible to introduce local variables at the top of this scope with the in keyword.

fun {Function Arg}
   LocalVar1
in
   LocalVar1 = if Arg == 42 then
		  LocalVar2
	       in
		  LocalVar2 = yes
		  LocalVar2
	       else
		  LocalVar3 = no  %% variables can be initialized when declared
	       in
		  LocalVar3
	       end
   LocalVar1
end

Here, LocalVar1 is visible in the whole body of Function while LocalVar2 is only visible in the then branch and LocalVar3 is only visible in the else branch.

Additionally, new local variables can be introduced everywhere using the keyword local.

if {IsEven 42} then
   {System.showInfo "Here, LocalVar is not visible."}
   local
      LocalVar = "Here, LocalVar IS visible"
   in
      {System.showInfo LocalVar}
   end
end

New variables are also introduced in pattern matching.

case "Rosetta code" of First|_ then {Show First} end %% prints "R"

_ creates a new nameless variable that is initially unbound. It is usually pronounced "don't care".

It is possible to create a read-only view of a variable with the !! operator. This is called a "future". We can wait for such a variable to become bound by another thread and we can read its value, but we can never set it.

declare
  A
  B = !!A %% B is a read-only view of A
in
  thread
     B = 43 %% this blocks until A is known; then it fails because 43 \= 42
  end
  A = 42

Additional operations on variables:

declare
  V = 42
in
  {Wait V}  %% explicitly wait for V to become determined

  if {IsDet V} then  %% check whether V is determined; not recommended
     {Show determined}
  elseif {IsFree V} then  %% check whether V is free; not recommended
     {Show free}
  end

IsFree and IsDet are low-level functions. If you use them, you code is no longer declarative and prone to race conditions when used in a multi-threaded context.

To have mutable references like in imperative languages, use cells:

declare
  A = {NewCell 42}
  OldVal
in
  {Show @A}         %% read a cell with @
  A := 43           %% change its value
  OldVal = A := 44  %% read and write at the same time (atomically)

A is an immutable dataflow variable that is bound to a mutable reference.

PARI/GP

There are two types of local variables, local (mostly deprecated) and my. Variables can be used without declaration or initialization; if not previously used such a variable is a pure variable: technically, a monomial in a variable with name equal to the variable name. This behavior can be forced with the apostrophe operator: regardless of the value (if any) currently stored in x,

'x

displays as (and is treated internally as) x. This is useful when you want to use it as a variable instead of a number (or other type of object). For example,

'x^3+7

is a cubic polynomial, not the number 8, even if x is currently 1.

Pascal

See [[Variables#Delphi | Delphi]]

Perl

In perl, variables are global by default and can be manipulated from anywhere in the program. Variables can be used without first being declared, providing that the strict pragmatic directive is not in effect:

sub dofruit {
  $fruit='apple';
}

dofruit;
print "The fruit is $fruit";

Variables can be declared prior to use and may be prefixed with [[scope modifiers]] our, my, or local see [[scope modifiers]] for the differences. Variables which haven't been assigned to have the undefined value by default. The undefined value acts just like 0 (if used as a number) or the empty string (if used as a string), except it can be distinguished from either of these with the defined function. If warnings are enabled, perl will print a message like "Use of uninitialized value $foo in addition (+)" whenever you use the undefined value as a number or string.

Initialization and assignment are the same thing in Perl: just use the = operator. Note that the rvalue's context (scalar or list) is determined based on the lvalue.

my $x = @a;                   # Scalar assignment; $x is set to the
                              # number of elements in @a.
my ($x) = @a;                 # List assignment; $x is set to the first
                              # element of @a.
my @b = @a;                   # List assignment; @b becomes the same length
                              # as @a and each element becomes the same.
my ($x, $y, @b) = @a;         # List assignment; $x and $y get the first
                              # two elements of @a, and @b the rest.
my ($x, $y, @b, @c, $z) = @a; # Same thing, and also @c becomes empty
                              # and $z undefined.

The kind of value a variable can hold depends on its sigil, "sigil" being a slang term for "funny character in front of a variable name". $dollarsigns can hold scalars: the undefined value, numbers, strings, or [http://perldoc.perl.org/perlref.html references]. @atsigns can hold arrays of scalars, and %percentsigns can hold hashes of scalars (associative arrays mapping strings to scalars); nested data structures are constructed by making arrays or hashes of references to arrays or hashes.

There are two other sigils, but they behave quite unlike the others. A token of the form &foo refers to a subroutine named foo. In older versions of Perl, ampersands were necessary for calling user-defined subroutines, but since they no longer are, they have only a handful of obscure uses, like making references to named subroutines. Note that you can't assign to an ampersand-marked name. But you can assign to a typeglob, a kind of object represented with the notation *var. A typeglob *foo represents the symbol-table entry for all of the otherwise independent variables $foo, @foo, %foo, and &foo. Assigning a string "bar" to *foo makes these variables aliases for $bar, @bar, %bar, and &bar respectively. Alternatively, you can assign a reference to a typeglob, which creates an alias only for the variable of the appropriate type. In particular, you can say *twiddle = sub {...} to change the definition of the subroutine &twiddle without affecting $twiddle and friends.

The strict pragmatic directive

If the strict pragmatic directive is in effect, then variables need explicit scope declaration, so should be prefixed with a my or our keyword depending on the required level of scope:

use strict;
our $fruit;             # declare a variable as global
our $veg = "carrot";    # declare a global variable and define its value

Local and global variables

The following example shows the use of local and global variables:

$fruit="apple";    # this will be global by default

sub dofruit {
  print "My global fruit was $fruit,";    # use the global variable
  my $fruit="banana";                      # declare a new local variable
  print "and the local fruit is $fruit.\n";
}

dofruit;
print "The global fruit is still $fruit";

Perl 6

Much of what is true for Perl 5 is also true for Perl 6. Some exceptions:

There are no typeglobs in Perl 6.

Assigning an array to a scalar variable now makes that scalar variable a reference to the array:

my @y = <A B C D>; # Array of strings 'A', 'B', 'C', and 'D'
say @y[2]; # the @-sigil requires the container to implement the role Positional
@y[1,2] = 'x','y'; # that's where subscripts and many other things come from
say @y; # OUTPUT«[A x y D]␤» # we start to count at 0 btw.

my $x = @y; # $x is now a reference for the array @y

say $x[1]; # prints 'x' followed by a newline character

my Int $with-type-check; # type checks are enforced by the compiler

my Int:D $defined-i = 10; # definedness can also be asked for and default values are required in that case

my Int:D $after-midnight where * > 24 = 25; # SQL is fun and so is Perl 6

my \bad = 'good'; # if you don't like sigils
say bad; # you don't have to use them
say "this is quite bad"; # but then string interpolation
say "this is quite {bad}" # becomes more wordy

Laziness is a big topic in Perl 6. Sometimes Perl programmers are so lazy, they can't even be bothered with giving [http://design.perl6.org/S02.html#Names_and_Variables variables names].

say ++$; # this is an anonymous state variable
say ++$; # this is a different anonymous state variable, prefix:<++> forces it into numerical context and defaults it to 0
say $+=2 for 1..10; # here we do something useful with another anonymous variable

sub foo { $^a * $^b } # for positional arguments we often can't be bothered to declare them or to give them fancy names
say foo 3, 4;

{{output}}

1
1
2
4
6
12

(Includes code modified from http://design.perl6.org/S02.html#Built-In_Data_Types. See this reference for more details.)

Phix

Phix has just five builtin data types:

        <-------- object --------->
        |                |
        +-atom           +-sequence
          |                |
          +-integer        +-string

• An object can hold any Phix data, specifically either an atom or a sequence.
• An atom can hold a single floating point numeric value, or an integer.
• An integer can hold a single whole number (at least +/- 1,000,000,000).
• A sequence can hold a collection of values, nested to any depth, or a string
• A string can hold a series of characters, or raw binary data.

Unlike traditional statically typed languages, you do not have to remember dozens of possibly complex data types, and unlike a dynamically typed language you get proper compile-time error messages for simple typos. Phix also allows user defined types, for extra validation and debugging purposes, rather than being fundamentally different to the above. Strings are mutable and the lengths of sequences and strings are only limited by available memory. The sequence is the real powerhouse of Phix, and can be used for lists, tables, trees, etc.

Identifiers may be of any length and are case sensitive. They must start with a letter and then be followed by letters, digits or underscores.

Variables must be declared before use, may be assigned on declaration, and can utilise multiple assignment/sequence decomposition, eg:

integer x = 25, y = 25, z
object {a, b, c} = {{}, 5, "string"}

In the latter statement, c is set to "string", b is set to 5, and a is set to {}. (In multiple assignment, values are assigned right-to-left to avoid having to reorder any subscripts.) You could also use the @= ("all equal") operator to assign a, b and c to the same (entire) thing. Attempts to reference a variable before it has been assigned a value trigger a run-time error, except for object(id) which yields false in that case. Constants are really just variables which must be assigned on declaration and for which subsequent assignment is prohibited.

Variables are by default local and restricted to the current file, routine, or block level. Static file-level variables may also be declared as global to make them visible to other source files. There are no static routine scoped variables, only file-level. Scope resolution is intended to be simple and intuitive, see the link below (Core Language/Declarations/Scope) for more details.

User defined types are declared with a single-parameter function that returns true or false, eg:

type hour(integer x)
    return x >= 0 and x <= 23
end type
hour h1, h2
h1 = 10      -- ok
h2 = 25      -- error! program aborts with a message

Phix has no notion of unsigned numeric types, except via user defined types such as the above which explicitly prevent their use.

You could theoretically write an entire application declaring all variables and parameters as type object, except that it would probably not catch errors the way you might expect it to.

An online copy of the manual can be found at http://phix.x10.mx/docs/html/phix.htm

PHP

<?php
/**
 * @author Elad Yosifon
 */


/*
 * PHP is a weak typed language,
 * no separation between variable declaration, initialization and assignment.
 *
 * variable type is defined by the value that is assigned to it.
 * a variable name must start with a "$" sign (called "sigil", not a dollar sign).
 * variable naming rules:
 *     + case-sensitive.
 *     + first character after $ must not be a number.
 *     + after the first character all alphanumeric chars and  _(underscore) sign is allowed, e.g. $i_am_a_new_var_with_the_number_0
 *
 */

# NULL typed variable
$null = NULL;				var_dump($null);	// output: null

# defining a boolean
$boolean = true;			var_dump($boolean);	// output: boolean true
$boolean = false;			var_dump($boolean);	// output: boolean false

/*
 * casting is made using (TYPE) as a prefix
 */
# bool and boolean is the same
$boolean = (bool)1;			var_dump($boolean);	// output: boolean true
$boolean = (boolean)1;			var_dump($boolean);	// output: boolean true

$boolean = (bool)0;			var_dump($boolean);	// output: boolean false
$boolean = (boolean)0;			var_dump($boolean);	// output: boolean false

# defining an integer
$int = 0;				var_dump($int);		// output: int 0

# defining a float,
$float = 0.01;				var_dump($float);	// output: float 0.01

# which is also identical to "real" and "double"
var_dump((double)$float);					// output: float 0.01
var_dump((real)$float);						// output: float 0.01

# casting back to int (auto flooring the value)
var_dump((int)$float);						// output: int 0
var_dump((int)($float+1));					// output: int 1
var_dump((int)($float+1.9));					// output: int 1

# defining a string
$string = 'string';
var_dump($string);						// output: string 'string' (length=6)

# referencing a variable (there are no pointers in PHP).
$another_string = &$string;
var_dump($another_string);
								// output: string 'string' (length=6)

$string = "I'm the same string!";
var_dump($another_string);
								// output: string 'I'm the same string!' (length=20)
# "deleting" a variable from memory
unset($another_string);

$string = 'string';
/*
 * a string can also be defined with double-quotes, HEREDOC and NOWDOC operators.
 * content inside double-quotes is being parsed before assignment.
 * concatenation operator is .=
 */
$parsed_string = "This is a $string";
var_dump($parsed_string);
								// output: string 'This is a string' (length=16)
$parsed_string .= " with another {$string}";
var_dump($parsed_string);
								// output: string 'This is a string with another string' (length=36)

# with string parsing
$heredoc = <<<HEREDOC
This is the content of \$string: {$string}
HEREDOC;
var_dump($heredoc);
								// output: string 'This is the content of $string: string' (length=38)

# without string parsing (notice the single quotes surrounding NOWDOC)
$nowdoc = <<<'NOWDOC'
This is the content of \$string: {$string}
NOWDOC;
var_dump($nowdoc);
								// output: string 'This is the content of \$string: {$string}' (length=42)

# as of PHP5, defining an object typed stdClass => standard class
$stdObject = new stdClass();	var_dump($stdObject);
								// output: object(stdClass)[1]
# defining an object typed Foo
class Foo {}
$foo = new Foo();		var_dump($foo);
								// output: object(Foo)[2]
# defining an empty array
$array = array();		var_dump($array);
								// output: array {empty}

/*
 * an array with non-integer key is also considered as an associative array(i.e. hash table)
 * can contain mixed variable types, can contain integer based keys and non-integer keys
 */
$assoc = array(
	0 => $int,
	'integer' => $int,
	1 => $float,
	'float' => $float,
	2 => $string,
	'string' => $string,
	3 => NULL, // <=== key 3 is NULL
	3, // <=== this is a value, not a key (key is 4)
	5 => $stdObject,
	'Foo' => $foo,
);
var_dump($assoc);

// output:
//
### =

//	array
//	    0 => int 0
//	    'integer' => int 0
//	    1 => float 0.01
//	    'float' => float 0.01
//	    2 => string 'string' (length=6)
//	    'string' => string 'string' (length=6)
//	    3 => null
//	    4 => int 3
//	    5 =>
//	    	object(stdClass)[1]
//	    'Foo' =>
//		    object(Foo)[2]



/*
 * all variables are "global" but not reachable inside functions(unless specifically "globalized" inside)
 */

function a_function()
{
	# not reachable
	var_dump(isset($foo));				// output: boolean false

	global $foo;
	# "global" (reachable) inside a_function()'s scope
	var_dump(isset($foo));				// output: boolean true
}

a_function();

/**
 * there is another special type of variable called (Resource).
 * for more info regarding Resources:
 * @url http://php.net/manual/en/language.types.resource.php
 * @url http://php.net/manual/en/resource.php
 */

PicoLisp

You can control the local bindings of symbols with functions like '[http://software-lab.de/doc/refU.html#use use]' or '[http://software-lab.de/doc/refL.html#let let]':

(use (A B C)
   (setq A 1  B 2  C 3)
   ... )

This is equivalent to

(let (A 1  B 2  C 3)
   ... )

The parentheses can be omitted if there is only a single variable

(use A
   (setq A ..)
   ... )

(let A 1
   ...)

Other functions that handle local bindings are '[http://software-lab.de/doc/refL.html#let? let?]', '[http://software-lab.de/doc/refB.html#bind bind]', '[http://software-lab.de/doc/refJ.html#job job]', '[http://software-lab.de/doc/refW.html#with with]' or '[http://software-lab.de/doc/refF.html#for for]'.

PL/I

/* The PROCEDURE block and BEGIN block are used to delimit scopes. */

declare i float; /* external, global variable, excluded from the */
                 /* local area (BEGIN block) below.              */
begin;
   declare (i, j) fixed binary; /* local variable */
   get list (i, j);
   put list (i,j);
end;

/* Examples of initialization. */

declare p fixed initial (25);
declare q(7) fixed initial (9, 3, 5, 1, 2, 8, 15);
   /* sets all elements of array Q at run time, on block entry. */
declare r(7) fixed initial (9, 3, 5, 1, 2, 8, 15);
   /* sets all elements of array R at compile time. */

p = 44; /* run-time assignment. */
q = 0; /* run-time initialization of all elements of Q to zero. */
q = r; /* run-time assignment of all elements of array R to     */
       /* corresponding elemets of S.                           */

Pony

var counter: I32 = 10 // mutable variable 'counter' with value 10
let temp: F64 = 36.6  // immutable variable 'temp'
let str: String       // immutable variable 'str' with no initial value
str = "i am a string" // variables must be initialized before use
let another_str = "i am another string" // type of variable 'another_str' infered from assigned value

let b  = true
let b' = false // variable names can contain ' to make a distinct variable with almost the same name

Destructive read

var x: I32 = 10
var y: I32 = x = 20
try
  Fact(x == 20) // x gets the new value of 20
  Fact(y == 10) // y gets the old value of x which is 10
end

Prolog

Variables in imperative languages are, in essence, named memory locations where items of data can be stored. Prolog, as a declarative language, has no variables in this sense, and therefore has no way of declaring them or assigning to them. Prolog variables are more like variables in formal logic or in mathematics. Here is a very simple Prolog program:

mortal(X) :- man(X).
man(socrates).

The symbol :- may be read as 'when' or 'if', so that the first line is equivalent to the statement in predicate logic ∀x: px → qx where px is interpreted as 'x is a man' and qx is interpreted as 'x is mortal'. Prolog notation, however, requires variable names to start with (or consist of) a capital letter: this is how the interpreter knows that socrates is not a variable.

We can of course use more than one variable:

student(X,Y) :- taught(Y,X).
taught(socrates,plato).

When we put queries to the Prolog system, it will seek to find a consistent set of interpretations that allows our query to be true in the light of the facts and rules we have provided:

?- mortal(socrates).
yes
?- student(X,socrates).
X=plato
?- student(socrates,X).
no

And so forth. We can reuse the same variable names in different statements as much as we like, but within each statement the same variable must be capable of referring to the same term.

?- mortal(zeus).
no

Prolog does not answer like that because it is a connoisseur of the mythology; and in any case several ancient writers report that Zeus's tomb could be seen on Crete. But the rule states that X is mortal if X—the same x—is a man, so it could only unify successfully if zeus and socrates were the same (which even his most devoted admirers did not claim). If our original rule had said

mortal(X) :- man(Y).

then the two variables would be able to refer to two different terms, and the Prolog interpreter would agree that mortal(zeus).

PureBasic

; Variables are initialized when they appear in sourcecode with default value of 0 and type int
Debug a
; or value "" for a string, they are not case sensitive
Debug b$
; This initializes a double precision float, if type is following the dot
Debug c.d
; They can be initialized with define (double precision float, string, integer)
Define d.d = 3.5, e$ = "Test", f.i = a + 2
; Define can have a default type (all bytes except j which is long):
Define.b g, h, j.l
; Define without following variables sets default type. In this case to single precision float
Define.f
; So this will be an single precision float and no integer
Debug k
; EnableExplicit forces declaration of used variables with define
EnableExplicit
; Will throw an error because L isn't initialized
Debug L
DisableExplicit
; Global Variables are available in Procedures and Threads too
Global M = 3, N = 2
Procedure Dummy(parameter1, parameter2 = 20)
  ; Parameter contain values which where used when calling the function,
  ; their types have to be specified in the above Procedure header.
  ; The last ones can have default values which get applied if this parameter is not given.

  ; Variables in Procedures are separate from those outside,
  ; so d can be initialized again with another type
  ; which would otherwise lead to an error
  d.i
  ; Protected makes a variable local even if another one with same name is declared as global (see above)
  Protected M = 2
  ; Shares a variable with main program like it was declared by global
  Shared a
  ; prevents a variable to be initialized with default value again when procedure is called a second time,
  ; could be used for example as a counter, which contains the number of times a function was called
  Static a
  ; N here also would have a value of 2, while for example
  ; f would, when named, initialize a new variable, and so have a value of 0
EndProcedure
; finally there are constants which are prefixed by an #:
#Test = 1
; Their value cannot be changed while program is running
#String_Constant = "blubb"
; In constrast  to variables, a constant has no types except an (optional) $ sign to mark  it as string constant
#Float_Constant = 2.3
; Maps, LinkedLists , Arrays and Structures are not handled here, because they are no elemental variables

PowerShell

Variables in PowerShell start with a $ character, they are created on assignment and thus don't need to be declared:

$s = "abc"
$i = 123

Uninitialized variables expand to nothing. This may be interpreted for example as an empty string or 0, depending on context:

4 + $foo              # yields 4
"abc" + $foo + "def"  # yields "abcdef"

Variables all show up in the '''Variable''': drive and can be queried from there with the usual facilities:

Get-ChildItem Variable:

Since Variables are provided via a flat filesystem, they can be manipulated using the common cmdlets for doing so. For example to delete a variable one can use

Remove-Item Variable:foo

as if it were a file or a registry key. There are, however, several cmdlets dealing specifically with variables:

Get-Variable      # retrieves the value of a variable
New-Variable      # creates a new variable
Set-Variable      # sets the value of a variable
Clear-Variable    # deletes the value of a variable, but not the variable itself
Remove-Variable   # deletes a variable completely

Python

[http://python.net/~goodger/projects/pycon/2007/idiomatic/handout.html#python-has-names Names] in Python are not typed, although all the objects referred to by them, are. Names are lexically scoped by function/method/class definitions, and must be defined before use.

Names in global statements are looked up in the outermost context of the program or module. Names in a nonlocal statement are looked up in the order of closest enclosing scope outwards.

# these examples, respectively, refer to integer, float, boolean, and string objects
example1 = 3
example2 = 3.0
example3 = True
example4 = "hello"

# example1 now refers to a string object.
example1 = "goodbye"

R

Variables are dynamically typed, so they do not need to be declared and instantiated separately. <- and = are both used as the assignment operator, though <- is preferred, for compatibility with S-Plus code.

foo <- 3.4
bar = "abc"

It is possible to assign multiple variables with the same value, and to assign values from left to right.

baz <- quux <- 1:10
TRUE -> quuux

There are also global assignment operators, <<- and ->>. From their help page: The operators '<<-' and '->>' cause a search to made through the environment for an existing definition of the variable being assigned. If such a variable is found (and its binding is not locked) then its value is redefined, otherwise assignment takes place in the global environment. In practice, this usually means that variables are assigned in the user workspace (global environment) rather than a function.

a <- 3

assignmentdemo <- function()
{
   message("assign 'a' locally, i.e. within the scope of the function")
   a <- 5
   message(paste("inside assignmentdemo, a = ", a))
   message(paste("in the global environment, a = ", get("a", envir=globalenv())))

   message("assign 'a' globally")
   a <<- 7
   message(paste("inside assignmentdemo, a = ", a))
   message(paste("in the global environment, a = ", get("a", envir=globalenv())))
}
assignmentdemo()

assign 'a' locally, i.e. within the scope of the function inside assignmentdemo, a = 5 in the global environment, a = 3 assign 'a' globally inside assignmentdemo, a = 5 in the global environment, a = 7 Finally, there is also the assign function, where you choose the environment to assign the variable.

assign("b", TRUE)                         #equivalent to b <- TRUE
assign("c", runif(10), envir=globalenv()) #equivalent to c <<- runif(10)

Racket

#lang racket

;; define a variable and initialize it
(define foo 0)
;; increment it
(set! foo (add1 foo))

;; Racket is lexically scoped, which makes local variables work:
(define (bar)
  (define foo 100)
  (set! foo (add1 foo))
  foo)
(bar) ; -> 101

;; and it also makes it possible to have variables with a global value
;; that are accessible only in a specific local lexical scope:
(define baz
  (let () ; used to create a new scope
    (define foo 0)
    (define (bar)
      (set! foo (add1 foo))
      foo)
    bar)) ; this is the value that gets bound to `baz'
(list (baz) (baz) (baz)) ; -> '(1 2 3)

;; define a new type, and initialize a variable with an instance
(struct pos (x y))
(define p (pos 1 2))
(list (pos-x p) (pos-y p)) ; -> '(1 2)

;; for a mutable reference, a struct (or some specific fields in a
;; struct) can be declared mutable
(struct mpos (x y) #:mutable)
(define mp (mpos 1 2))
(set-mpos-x! mp 11)
(set-mpos-y! mp 22)
(list (mpos-x mp) (mpos-y mp)) ; -> '(11 22)

;; but for just a mutable value, we have boxes as a builtin type
(define b (box 10))
(set-box! b (add1 (unbox b)))
(unbox b) ; -> 11

;; (Racket has many more related features: static typing in typed
;; racket, structs that are extensions of other structs,
;; pattern-matching on structs, classes, and much more)

Rascal

The effect of a variable declaration is to introduce a new variable Name and to assign the value of expression Exp to Name. A variable declaration has the form

A mention of Name later on in the same scope will be replaced by this value, provided that Name’s value has not been changed by an intermediate assignment. When a variable is declared, it has as scope the nearest enclosing block, or the module when declared at the module level.

There are two rules you have to take into account. Double declarations in the same scope are not allowed. Additionally, the type of Exp should be compatible with Type, i.e., it should be a subtype of Type.

As a convenience, also declarations without an initialization expression are permitted inside functions (but not at the module level) and have the form

```rascal>Type Name;</lang

and only introduce the variable Name.

Rascal provides local type inference, which allows the implicit declaration of variables that are used locally in functions. There are four rules that apply when doing so.
(1) An implicitly declared variable is declared at the level of the current scope, this may the whole function body or a block nested in it.
(2) An implicitly declared variable gets as type the type of the first value that is assignment to it.
(3) If a variable is implicitly declared in different execution path of a function, all these implicit declarations should result in the same type.
(4) All uses of an implicitly declared variable must be compatible with its implicit type.

'''Examples'''

Two explicit variable declarations:

```rascal>rascal
int max = 100;
int: 100
rascal>min = 0;
int: 0

An implicit variable declaration

day = {<"mon", 1>, <"tue", 2>, <"wed",3>,
>>>>>>>       <"thu", 4>, <"fri", 5>, <"sat",6>, <"sun",7>};
rel[str, int]: {
  <"thu",4>,
  <"mon",1>,
  <"sat",6>,
  <"wed",3>,
  <"tue",2>,
  <"fri",5>,
  <"sun",7>
}

Variable declaration and assignment leading to type error

int month = 12;
int: 12
rascal>month ="December";
|stdin:///|(7,10,<1,7>,<1,17>): Expected int, but got str

Pitfalls Local type inference for variables always uses the smallest possibe scope for a variable; this implies that a variable introduced in an inner scope is not available outside that scope. Here is how things can go wrong:

if( 4 > 3){ x = "abc"; } else { x = "def";}
str: "abc"
rascal>x;
|stdin:///|(0,1,<1,0>,<1,1>): Undeclared variable, function or constructor: x

REXX

assignments via =

REXX has only one type of variable: a (character) string.

There is no need to declare anything (variables, entry points, subroutines, functions, etc) (indeed, there isn't any way to declare anything at all).

All unassigned REXX variables have a default value of the variable name (in uppercase).

There isn't any way to initialize a variable except to assign it a value (by one of the methods below), however,

there is a way to "initialize" a (stemmed) array in REXX with a default value) ── see the 6^th section below,

'''default value for an array'''.

To assign some data (value) to a variable, one method is to use the assignment operator, an equal sign ('''='''):

aa = 10                                /*assigns chars    10  ───►  AA  */
bb = ''                                /*assigns a null value ───►  BB  */
cc = 2*10                              /*assigns chars    20  ───►  CC  */
dd = 'Adam'                            /*assigns chars Adam   ───►  DD  */
ee = "Adam"                            /*same as above        ───►  EE  */
ff = 10.                               /*assigns chars   10.  ───►  FF  */
gg = '10.'                             /*same as above        ───►  GG  */
hh = "+10"                             /*assigns chars  +10   ───►  hh  */
ii = 1e1                               /*assigns chars  1e1   ───►  ii  */
jj = +.1e+2                            /*assigns chars  .1e+2 ───►  jj  */

Variables '''aa, ff, gg, hh, ii,''' and '''jj''' will all be considered ''numerically equal'' in REXX (but not exactly equal ''except'' for '''ff''' and '''gg''').

assignments via PARSE

kk = '123'x                            /*assigns hex  00000123 ───► KK  */
kk = 'dead beaf'X                      /*assigns hex  deadbeaf ───► KK  */
ll = '0000 0010'b                      /*assigns blank ───► LL  (ASCII) */
mm = '0000 0100'B                      /*assigns blank ───► MM  (EBCDIC)*/

xxx = '11 2. 333 -5'
parse var xxx   nn oo pp qq rr
                                       /*assigns     11    ───►  NN     */
                                       /*assigns     2.    ───►  OO     */
                                       /*assigns    333    ───►  PP     */
                                       /*assigns     ─5    ───►  QQ     */
                                       /*assigns   "null"  ───►  RR     */

                           /*a  "null"  is a string of length zero (0), */
                           /*and is not to be confused with a null char.*/

cat = 'A cat is a lion in a jungle of small bushes.'
                                       /*assigns a literal ───►  CAT    */

assignments via VALUE

Assignments can be made via the '''value''' BIF ['''B'''uilt-'''I'''n '''F'''unction] (which also has other capabilities), the

capability used here is to create a variable name programmatically (normally using concatenation or abuttal).

call value 'CAT', "When the cat's away, the mice will play."
                                       /*assigns a literal ───►  CAT    */
yyy='CA'
call value yyy'T', "Honest as the Cat when the meat's out of reach."
                                       /*assigns a literal ───►  CAT    */
yyy = 'CA'
call value yyy || 'T', "Honest as the Cat when the meat's out of reach."
                                       /*assigns a literal ───►  CAT    */

unassigned variables

There are methods to catch unassigned variables in REXX.

/*REXX pgm to do a "bad" assignment  (with an unassigned REXX variable).*/

signal on noValue                      /*usually, placed at pgm start.  */

xxx=aaaaa                              /*tries to assign aaaaa ───► xxx */

say xxx 'or somesuch'
exit

noValue:                               /*this can be dressed up better. */
badLine  =sigl                         /*REXX line number that failed.  */
badSource=sourceline(badLine)          /*REXX source line ···           */
badVar   =condition('D')               /*REXX var name that's ¬ defined.*/
say
say '*** error! ***'
say 'undefined variable' badvar "at REXX line number" badLine
say
say badSource
say
exit 13

Note: the value (result) of the '''condition''' BIF can vary in different implementations of a REXX interpreter.

'''output''' using Regina (various versions), PC/REXX, Personal REXX, and ooRexx.

*** error! ***
undefined variable AAAAA at REXX line number 5

xxx=aaaaa                              /*tries to assign aaaaa ───► xxx */

'''output''' using R4 REXX:

Error 46 : Invalid variable reference (NOVALUE)
Information: Variable aaaaa does not have an assigned value
Error occurred in statement# 5
Statement source: xxx= aaaaa
Statement context: D:\variabl4.rex, procedure: variabl4

scope of variables

REXX subroutines/functions/routines/procedures can have their own "local" variables if the '''procedure''' statement is used.

Variables can be shared with the main program if the variables are named on the '''procedure''' statement with the '''expose''' keyword.

/*REXX pgm shows different scopes of a variable: "global"  and  "local".*/
q = 55          ;    say ' 1st q='  q  /*assign a value ───►  "main"  Q.*/
call sub        ;    say ' 2nd q='  q  /*call a procedure subroutine.   */
call gyro       ;    say ' 3rd q='  q  /*call a procedure with EXPOSE.  */
call sand       ;    say ' 4th q='  q  /*call a subroutine or function. */
exit                                   /*stick a fork in it, we're done.*/
/*──────────────────────────────────SUB subroutine──────────────────────*/
sub:  procedure                        /*use PROCEDURE to use local vars*/
q = -777        ;    say ' sub q='  q  /*assign a value ───► "local" Q. */
return
/*──────────────────────────────────GYRO subroutine─────────────────────*/
gyro: procedure expose q               /*use EXPOSE to use global var Q.*/
q = "yuppers"   ;    say 'gyro q='  q  /*assign a value ───► "exposed" Q*/
return
/*──────────────────────────────────SAND subroutine─────────────────────*/
sand:                                  /*all REXX variables are exposed.*/
q = "Monty"     ;    say 'sand q='  q  /*assign a value ───► "global"  Q*/
return

'''output'''

 1st q= 55
 sub q= -777
 2nd q= 55
gyro q= yuppers
 3rd q= yuppers
sand q= Monty
 4th q= Monty

Programming note: there is also a method in REXX to '''expose''' a ''list'' of variables.

default value for an array

There is a way in REXX to assign a default value (or an initial value, if you will) to a (stemmed) array.

aaa. = '───────nope.'                  /*assign this string as a default*/
aaa.1=1                                /*assign   1   to first  element.*/
aaa.4=4.                               /*   "     4    " fourth    "    */
aaa.7='lucky'                          /*   "     7    " seventh   "    */
              do j=0  to 8             /*go through a bunch of elements.*/
              say 'aaa.'||j '=' aaa.j  /*display element # and its value*/
              end                      /*we could've started J at  -100.*/

dropping a variable

In REXX, dropping a variable (this can be thought of as deallocating it or setting the value back to its "default").

Note that the storage used by the variable's (old) value is not truly deallocated, but its storage is returned to the

pool of storage available for allocation of other REXX variables (and their values). This action isn't mandatory

for the REXX language (or for that matter, not even specified), but it's apparently what all (Classic) REXX

interpreters do at the the time of this writing.

radius=6.28                            /*assign a value to a variable.  */
                say 'radius =' radius
drop radius                            /*now, "undefine" the variable.  */
                say 'radius =' radius

Note: The value of an undefined (or deallocated) REXX variable is the uppercased name of the REXX variable name.

'''output'''

radius = 6.28
radius = RADIUS

compound variables

In additions to the (simple) variables described above, REXX defines compound variables that consist of a stem (symbol.) followed by a list of period-separated simple variables and constants The compound variable's tail is computed by concatenating the variables' values (which can be any string) with the constants and the intervening periods.

var.='something' /* sets all possible compound variables of stem var. */
x='3 '
var.x.x.4='something else'
Do i=1 To 5
  a=left(i,2)
  Say i var.a.a.4 "(tail is '"a||'.'||a||'.'||'4'"')"
  End

Output:

1 something (tail is '1 .1 .4')
2 something (tail is '2 .2 .4')
3 something else (tail is '3 .3 .4')
4 something (tail is '4 .4 .4')
5 something (tail is '5 .5 .4')

Ring

To create a new variable, you just need to determine the variable name & value. The value will determine the variable type and you can change the value to switch between the types using the same variable name.

Syntax:

<Variable Name> = <Value>

The operator ‘=’ is used here as an Assignment operator and the same operator can be used in conditions, but for testing equality of expressions.

The Variable will contains the real value (not a reference). This means that once you change the variable value, the old value will be removed from memory (even if the variable contains a list or object).

Ring is a dynamic programming language that uses Dynamic Typing.

x = "Hello"             # x is a string
see x + nl
x = 5                   # x is a number (int)
see x + nl
x = 1.2                 # x is a number (double)
see x + nl
x = [1,2,3,4]           # x is a list
see x                   # print list items
x = date()              # x is a string contains date
see x + nl
x = time()              # x is a string contains time
see x + nl
x = true                # x is a number (logical value = 1)
see x + nl
x = false               # x is a number (logical value = 0)
see x + nl

We can use the assignment operator ‘=’ to copy variables. We can do that to copy values like strings & numbers. Also, we can copy complete lists & objects. The assignment operator will do a complete duplication for us. This operation called Deep Copy

list = [1,2,3,"four","five"]
list2 = list
list = []
See list        # print the first list - no items to print
See "********" + nl
See list2       # print the second list - contains 5 items

Ring is a weakly typed language, this means that the language can automatically convert between data types (like string & numbers) when that conversion make sense.

Rules:

<NUMBER> + <STRING> --> <NUMBER>
<STRING> + <NUMBER> --> <STRING>

The same operator ‘+’ can be used as an arithmetic operator or for string concatenation.

x = 10                  # x is a number
y = "20"                # y is a string
sum = x + y             # sum is a number (y will be converted to a number)
Msg = "Sum = " + sum    # Msg is a string (sum will be converted to a string)
see Msg + nl

Ruby

Information taken from [http://www.rubyist.net/~slagell/ruby/variables.html Variables] page at the [http://www.rubyist.net/~slagell/ruby/ Ruby User's Guide]

Ruby has three kinds of variables, one kind of constant and exactly two pseudo-variables. The variables and the constants have no type. While untyped variables have some drawbacks, they have many more advantages and fit well with ruby's quick and easy philosophy.

Variables must be declared in most languages in order to specify their type, modifiability (i.e., whether they are constants), and scope; since type is not an issue, and the rest is evident from the variable name as you are about to see, we do not need variable declarations in ruby.

The first character of an identifier categorizes it at a glance:

$	[http://www.rubyist.net/~slagell/ruby/globalvars.html global variable]
@	[http://www.rubyist.net/~slagell/ruby/instancevars.html instance variable]
[a-z] or _	[http://www.rubyist.net/~slagell/ruby/localvars.html local variable]
[A-Z]	[http://www.rubyist.net/~slagell/ruby/constants.html constant]

The only exceptions to the above are ruby's pseudo-variables: self, which always refers to the currently executing object, and nil, which is the meaningless value assigned to uninitialized variables. Both are named as if they are local variables, but self is a global variable maintained by the interpreter, and nil is really a constant. As these are the only two exceptions, they don't confuse things too much.

Referencing an undefined global or instance variable returns nil. Referencing an undefined local variable throws a NameError exception.

$a_global_var = 5
class Demo
  @@a_class_var = 6
  A_CONSTANT = 8
  def initialize
    @an_instance_var = 7
  end
  def incr(a_local_var)
    @an_instance_var += a_local_var
  end
end

Scala

Variables in Scala can have three different scopes depending on the place where they are being used. They can exist as fields, as method parameters and as local variables. Below are the details about each type of scope:

• '''Fields''' are variables that belong to an object. The fields are accessible from inside every method in the object. Fields can also be accessible outside the object depending on what access modifiers the field is declared with. Object fields can be both mutable or immutable types and can be defined using respectively var or val.

• '''Method parameters''' are variables, which are used to pass the value inside a method when the method is called. Method parameters are only accessible from inside the method but the objects passed in may be accessible from the outside, if you have a reference to the object from outside the method. Method parameters are always immutable and defined by val keyword. In ''algebraic datatypes'' (Scala's case classes), -think records- the parameters looks like method parameters. In this case they are fields.

• '''Local variables''' are variables declared inside a method. Local variables are only accessible from inside the method, but the objects you create may escape the method if you return them from the method. Local variables can be both mutable or immutable types and can be defined using respectively var or val.

Seed7

Seed7 variables must be defined with type and initialization value, before they are used. There are global variables and variables declared local to a function.

$ include "seed7_05.s7i";

var integer: foo is 5;   # foo is global

const proc: aFunc is func
  local
    var integer: bar is 10;   # bar is local to aFunc
  begin
    writeln("foo + bar = " <& foo + bar);
  end func;

const proc: main is func
  begin
    aFunc;
  end func;

Set lang

There is no declared intialization of variables, or datatypes. '''Set''' already initializes 52 variables, named a-z with a value of 0 (ASCII for Null) each, and A-Z with ASCII values corresponding to their characters (65-90). There is also a question mark variable, which represents the number of the current line of code being executed. set a 0 > Useless intialization - All lowercase variables have an initial value of 0 set b 66 > Simple variable assignment - ''b'' is now the ASCII value of 66, or the character 'B' [c=0] set c 5 > Conditional variable assignment - If ''c'' is 0, then set ''c'' to 5 set ? 6 > A "goto" command; Setting the ''?'' variable defines the line of code to be executed next set z 1 > This line of code will never be executed, because the previous skipped it set c 10 > Line #5 skipped to here set d A > Assigning a variable to another variable - ''d'' is now ASCII 65, or the character 'A' set b ! > The ''!'' deals with I/O. Setting a variable to it receives an input character and assigns it to the variable set ! a > Setting the exclamation point to a variable outputs that variable set e (d+1) > Combiners are defined inside round brackets - () - and have an addition and a subtraction function set f (e-1) > Variable ''e'' was assigned to ''d'' + 1 (65 + 1 = 66, character B), and ''f'' was assigned to ''e'' - 1 (66 - 1 = 65, character A)

## smart BASIC



###  Data Types

There are two variable data types in smart BASIC; numeric and string.

Numeric variables can contain real and complex numbers.

```qbasic
x = 14
y = 0.4E3
z = 3-2i

String variables use the dollar symbol ($) at the end.

t$ = "Name"

String values may include the quotation symbol " by specifying double quotes "".

n$ = """This is a quoted text"""

Initialization

Variable names are NOT case sensitive.

Variable names may not begin with a number.

Variables are initialized when assigned as either numeric or strings. However, smart BASIC in unique in that it will automatically interpret a numeric value from a string if utilized in that manner.

n = 4
a$ = "6 feet"
PRINT n * a$

{{out}}

24

Declaration

Variables do not require declaration in smart BASIC.

Only variable arrays need to be declared by size if the array is over 10 elements.

Arrays are DIM-ensioned by default with a size of 10. Larger arrays must be pre-DIM-entioned.

DIM name$(100)

Assignment

The command LET used in standard BASIC may be omitted.

'''LET x = 1''' may be shortened to just '''x = 1'''.

Precision

Numeric variable precision is limited to 64-bit representation with 1 bit for sign, 11 bits for power, and 52 bits for mantissa. Any integer greater than 2^52 (4,503,599,627,370,496) will be approximated.

Scope

All variables are local in smart BASIC. Variables within the main program are localized from variables within defined functions as well as other defined functions. However, variables may be accessed outside of their localized areas by preceding the variable with the function name and a period. By extension, the main program scope is null, therefore non-function variables may be accessed within functions with a period before the variable and a null scope (for example: .x).

DEF MyFunction(x)
MyF2 = x^2
MyF3 = x^3
MyFunction = MyF2 + MyF3
END DEF

To access the variables within the function:

x = MyFunction(3)
PRINT x; MyFunction.MyF2; MyFunction.MyF3

Variables may also be made global using the DEF command:

## SNOBOL4


Local variables in Snobol are declared in a function definition prototype string:


```SNOBOL4
        define('foo(x,y)a,b,c') :(foo_end)
foo     a = 1; b = 2; c = 3
        foo = a * ( x * x ) + b * y + c :(return)
foo_end

This defines a function foo( ) taking two arguments x,y and three localized variables a,b,c. Both the argument parameters and vars are dynamically scoped to the function body, and visible to any called functions within that scope. The function name also behaves as a local variable, and may be assigned to as the return value of the function. Any variable initialization or assignment is done explicitly within the function body. Unassigned variables have a null string value, which behaves as zero in numeric context.

Snobol does not support static or lexical scoping, or module level namespaces. Any variables not defined in a prototype are global to the program.

SPL

'''Variable declaration.''' In SPL variables do not need and do not have declaration.

'''Initialization.''' In SPL variables are autodeclared according to their usage. For example, this one-line program is valid because it is evident what is expected:

In contrast, this one-line program raises an error because it is not evident what object "a" is:


```spl>a = a+1</lang


'''Assignment.'''

```spl
a = 1
b,c,d = 0

'''Datatypes.''' In SPL an object can be: number, text, stack, array, group, function.

'''Scope.''' There is a main program body scope and individual function scopes. Variable from any scope can be accessed from any other scope by specifying the desired scope and variable name like "scope.variable". Variable from main program body scope can be accessed from any other scope like ".variable", because main program body scope is an empty space.

'''Referencing.''' An object can become a reference to another object using "~" symbol, for example:

r = ~a
a = 3
#.output(r)
r = 5
#.output(a)

{{out}}

3
5

SSEM

A variable is simply a storage address that the programmer chooses to treat as a variable. It requires no special allocation, declaration, etc., and an initial value can be loaded into it just as with any other storage address. Naturally, there is no concept of scope: any variable can be accessed and modified from any part of the program. To assign a fresh value to a variable, first form the desired number in the accumulator and then use a 110 c to

// variable declaration
var table, chair;

// assignment
var table = 10, chair = -10;

// multiple assignment to the same value
table = chair = 0;

// multiple assignment to an array
(
var table, chair;
#table, chair = [10, -10];
#table ... chair = [10, -10, 2, 3]; // with ellipsis: now chair is [-10, 2, 3]
)

// the letters a-z are predeclared in the interpreter for interactive programming
a = 10; x = a - 8;

// variables are type-neutral and mutable: reassign to different objects
a = 10; a = [1, 2, 3]; a = nil;

// immutable variables (only in class definitions)
const z = 42;

// lexical scope
// the closures g and h refer to different values of their c
(
f = {
	var c = 0;
	{ c = c + 1 }
};
g = f.value;
h = f.value;
c = 100; // this doesn't change it.
)

// dynamic scope: environments
f = { ~table = ~table + 1 };
Environment.use { ~table = 100; f.value }; // 101.
Environment.use { ~table = -1; f.value }; // 0.

// there is a default environment
~table = 7;
f.value;

// lexical scope in environments:
(
Environment.use {
	~table = 100;
	f = { ~table = ~table + 1 }.inEnvir;
};
)
f.value; // 101.

// because objects keep reference to other objects, references are not needed:
// objects can take the role of variables. But there is a Ref object, that just holds a value

a = Ref([1, 2, 3]); // a reference to an array, can also be written as a quote `[1, 2, 3];
f = { |x| x.value = x.value.squared }; // a function that operates on a ref
f.(a); // `[ 1, 4, 9 ]

// proxy objects serve as delegators in environments. This can be called line by line:
ProxySpace.push;
~z // returns a NodeProxy
~z.play; // play a silent sound
~z = ~x + ~y; // make it the sum of two silent sounds
~x = { PinkNoise.ar(0.1) }; // … which now are noise,
~y = { SinOsc.ar(440, 0, 0.1) }; // and a sine tone

import Foundation

// All variables declared outside of a struct/class/etc are global

// Swift is a typed language
// Swift can infer the type of variables
var str = "Hello, playground" // String
let letStr:String = "This is a constant"

// However, all variables must be initialized
// Intialize variable of type String to nil
var str1:String! // str1 is nil

// Assign value to str1
str1 = "foo bar" // str1 is foo bar

// Swift also has optional types
// Declare optional with type of String
var optionalString = Optional<String>("foo bar") // (Some "foo bar")

println(optionalString) // Optional("foo bar")

// Optionals can also be declared with the shorthand ?
var optionalString1:String? = "foo bar"

// ! can be used to force unwrap but will throw a runtime error if trying to unwrap a nil value
println(optionalString1!)

optionalString1 = nil // Is now nil
// println(optionalString1!) would now throw a runtime error

// Optional chaining can be used to gracefully fail if there is a nil value
if let value = optionalString1?.lowercaseString {
    // Is never executed
} else {
    println("optionalString1 is nil")
}

// Swift also has type aliasing
typealias MyNewType = String // MyNewType is an alias of String
var myNewTypeString = MyNewType("foo bar")

// Swift also has special types Any and AnyObject
// Any can hold any type
// AnyObject can hold any object type
let myAnyObjectString:AnyObject = "foo bar"

// Downcast myAnyObjectString to String
if let myString = myAnyObjectString as? String {
    println(myString) // foo bar
} else {
    println("myString is not a string")
}

// Swift treats functions as first-class
// Declare a variable with a type of a function that takes no args
// and returns Void
var myFunc:(() -> Void)
func showScopes() {
    // Variable is scoped to function
    let myFunctionVariable = "foo bar function"

    // Nested functions inherit variables declared in enclosing scope
    func nestFunc() {
        println(myFunctionVariable)
    }
    nestFunc()
}

myFunc = showScopes // myFunc is now showScopes
myFunc() // foo bar function

namespace eval foo {
    # Define a procedure with two formal arguments; they are local variables
    proc bar {callerVarName argumentVar} {
        ### Associate some non-local variables with the procedure
        global globalVar;      # Variable in global namespace
        variable namespaceVar; # Variable in local (::foo) namespace
        # Access to variable in caller's context; may be local or global
        upvar 1 callerVarName callerVar

        ### Reading a variable uses the same syntax in all cases
        puts "caller's var has $callerVar"
        # But global and namespace vars can be accessed by using qualified names
        puts "global var has $globalVar which is $::globalVar"

        ### Writing a variable has no special syntax
        ### but [set] is by far the most common command for writing
        set namespaceVar $globalVar
        incr globalVar

        ### Destroying a variable is done like this
        unset argumentVar
    }
}

:1→A

Local mynum, myfunc

Define mynum = 1                  © Two ways to assign a number
1 → mynum

Define myfunc(x) = (sin(x))^2     © Two ways to assign a function
(sin(x))^2 → myfunc(x)

Define myfunc(x) = Func           © Multi-statement function
  If x < 0 Then
    Return –x
  Else
    Return x
  EndIf
EndFunc

$$ MODE TUSCRIPT,{}
var1=1, var2="b"
PRINT "var1=",var1
PRINT "var2=",var2

basket=*
DATA apples
DATA bananas
DATA cherry

LOOP n,letter="a'b'c",fruit=basket
var=CONCAT (letter,n)
SET @var=VALUE(fruit)
PRINT var,"=",@var
ENDLOOP

var1=1
var2=b
a1=apples
b2=bananas
c3=cherry

@(cases)
hey @a
how are you
@(or)
hey @b
long time no see
@(end)

@(maybe)
@a bar
@(or)
foo @b
@(end)

## UNIX Shell


{{works with|Bourne Shell}}


```sh

#!/bin/sh
# The unix shell uses typeless variables
apples=6
# pears=5+4           # Some shells cannot perform addition this way
pears = `expr 5+4`    # We use the external expr to perform the calculation
myfavourite="raspberries"

# variable declaration
#
# declare [type] [name]
# 	-or-
# decl [type] [name]
decl int test

# initialization / assignment
#
# the set statement can be used to init variables and
# assign values to them
set test 10

# datatypes
#
# ursa currently has 10 built-in types, but
# more may be added in the future.
#     boolean
#     double
#     file
#     function
#     int
#     iodevice
#     port
#     serverport
#     string
#     task
#
# also, java classes may be used as data types
# cygnus/x ursa

# scope
#
# there is a global variable space, and functions
# have their own scope. control statements (for,
# if, try, while) don't have their own scope yet,
# but this will be implemented in the near future

# referencing
#
# variables are referenced by their name
decl port p
out p endl console

The parameters are scoped to the inside of the function in which they're declared. There are also lambdas, which also have parameters:


```WDTE>let example t =
 3 -> (@ s n => * t n);

  file.open name : f
  -> str.format '{}' data
  -> io.writeln f
  -- io.close f
  ;

 3;
io.writeln io.stdout a;

There are only three variable types: 32-bit signed integers (in the
32-bit version), IEEE-754 64-bit reals, and characters which are actually
32-bit addresses of (or pointers to) strings. When a 'char' variable is
subscripted, it accesses a single byte. All variable names must be
declared before they are used, for example:

int  I, J, K;
real X, Y, Array(10);
char String(80);

Variables (as well as all declared names, such as for procedures) must
start with a capital letter or underline. Names may contain digits or
underlines and be any length, but only the first 16 characters are
significant. Names are case-insensitive by default, unless the /c switch
is used when compiling.

Variables are usually assigned values like this: X:= 3.14, but the first
declared variables in a procedure can have argument values passed into
them. Variables other than arguments are only initialized by explicit
assignments in the body of the code.

Local variables are encapsulated in the procedures that declare them and
are not visible (are out of scope) outside those procedures. Procedures
can be (statically) nested several levels deep. The deepest procedure can
"see" all variables declared in the procedures in which it is nested. If
two variables are declared with identical names, the most local one is
used.

<xsl:variable name="foo" select="XPath expression" />
<xsl:if test="$foo = 4">... </xsl:if>     <!-- prepend '$' to reference a variable or parameter-->

Dim variable As datatype
Dim var1,var2,... As datatype

Dim n1,n2 as Integer
Dim x as Double
Dim isRaining as Boolean
Dim greeting as String

Dim variable As datatype = value
Dim var1,var2,... As datatype

Dim wholeNumber1,wholeNumber2 as Integer = 3
Dim realNumber as Double = 3.0
Dim isRaining as Boolean = False
Dim greeting as String = "Hello, this is World speaking."
Dim longArray() As Long = {0, 1, 2, 3}
Dim twoDimensions(,) As Integer = {{0, 1, 2}, {10, 11, 12}}

```vbnet
         v = a
         d = b^2 - 4*a*c
         s3 = s1 & mid(s2,3,2)

```vbnet
         c += a
         c -= a
         c *= a
         c /= a
         c ^= a
         c <<= n
         c >>= n
         c &= a

var v;  // global to the class that encloses this file
class C{ var v }  // global to class C, each instance gets a new v
class C{fcn f{var v=123;}} // v can only be seen by f, initialized when C is
class C{fcn init{var [const] v=5;}} // init is part of the constructor,
   so vars are promoted yo class scope. This allows const vars to be created at
   construction time
var v=123; v="hoho"; //not typed
class C{var v} // C.v OK, but just v is not found
class C{var[const]v=4} // C.v=3 illegal (compile or run time, depending)
class C{var[mixin]v=4} // the compiler treats v as an int for type checking
class C{var[proxy]v=f; fcn f{println("my name is ",self.fcn.name)} }
   v acts like a property to run f so C.v is the same as C.f()
class C{reg r}         // C.r is compile time error
r:=5;  // := syntax is same as "reg r=5", convenience