ASP Classic is a loosely typed language. No variable types in ASP (all variables are variants). Declaring variables is even optional unless you use the Option Explicit statement to force explicit declaration of all variables with Dim in that script. Using Option Explicit is strongly recommended to avoid incorrectly typing an existing variable and to avoid any confusion about variable scope.

For example, at the top of my common include file, I have the following:

<%@LANGUAGE=VBScript%>
<%
Option Explicit
'...more code here.

%>

Dim Fullname
Dim Age

Dim Weight

FullName = "Mike Prestwood"

Age = 32

Weight = 154.4

'Declaritive assignment not supported:

''Dim Married = "Y"   '>>>Not supported.

C++, Java, and C# all use C-like variable declaration.

C# has C-like variable declaration and although variables are case sensitive, VS.Net will auto-fix your variable names to the defined case.

C# offers many variable types. Some common types used include short, int, long, float, double, decimal, Int16, UInt16, Int32, Int64, string, and bool.

You can also specify the value when you declare a variable as in:

String FirstName = "Mike";

String LastName = "Prestwood";

Int16 Age = 42;

string FullName;

int16 Age;

double Weight;

FullName = "Mike Prestwood";

Age = 32;

Weight = 154.4;

Variable names are case sensitive.

The fundamental variable types in C++ are char, short int, int, long int, bool, float, double, long double, and wchar_t. The integer data types char, short, long and int can be either signed or unsigned. Signed variables are positive and negative. Unsigned variables are positive only.

int Age;

int Age = 43;

float a, b, c;

string FullName; //#include 

unsigned short int FamilyMemberCount;

Declaring variables is optional unless you click Program | Compiler Warnings while in the ObjectPAL editor for every form, script, and library you create. Using Compiler Warnings is strongly recommended to avoid incorrectly typing an existing variable and to avoid any confusion about variable scope. Also recommended is turning on Compile with Debug for every form, script, and library too for tighter, cleaner code.

Undeclared variables are AnyType variables. Common data types include Currency, Date, Datetime, Logical, LongInt, Number, SmallInt, String, and Time.

var
    FullName String
    Age SmallInt
    Weight Number

endVar

FullName = "Mike Prestwood"
Age = 32
Weight =154.4

msgInfo("", FullName + ", age=" + String(Age) 

             + ", weight=" + String(Weight))

 ObjectPAL Variables (var x SmallInt endVar)  

The Delphi language is a strongly typed language so you have to specifically declare variables and frequently use commands such as IntToStr and StrToInt.

Declare global variables in the interface section of a unit, variables declared within the implementation section (but not within a method) have a scope limited to the unit. You declare local variables in a var block outside (above) your begin..end code block. You cannot declare variables in-line (inside begin..end).

You can initialize global and unit variables but you cannot initialize local variables.

Delphi offers many variable types. Some common variable types include String, WideString, PChar, Integer, Boolean, Single, Double, Pointer, and Variant.

Note: D2009 introduced a new UnicodeString type.

procedure SomeProcedure;

var
  Fullname: String;
  Age: Integer;

  X, Y, Z: Double;

  MyArray: array [1..100] of Char;

begin

end;

//You can initialize global variables.

var

  ClickCounter: Integer = 0;

 Delphi Variables (var x: Integer = 0;)  

Prism supports type inference where you just use a variable and the compiler will then choose the lowest type possible (such as an Integer before a LongInt). With Prism, you frequently do not have to use commands to convert from one type to another.

Variable names are not case sensitive. The Prism language offers both old-style declaring variables before the begin as well as in-line variable declaration.

Prism does support variable initialization too.

Prism offers many variable types. Some common variable types include Integer, LongInt, Single, Double, Boolean, and String.

Syntax Example:   var FName: String; //This is old-style. begin FName := "Mike Prestwood"; MessageBox.Show(FName); Var Age: LongInt; //Local variables. Age:=36; MessageBox.Show(Fname + " is " + Age + " years old"); //Assign values too... Var Wife: String:="Lisa"; Var WifeAge: Integer:=32; messagebox.Show(wife + " is " + Wifeage + "."); end;

Variable names are case sensitive.

The Java basic types are boolean, byte, short, int, long, float, double, and char. You can also declare a variable to hold a particular instance of a class such as String.

int a;

int a, b;

int age = 43;

String FullName;

JavaScript is a loosely typed language. Each variable is cast in usage as string, number, boolean, function, or object.

Variable names are case sensitive.

Alternatively, you can specify the value when you declare a variable:

var FirstName = "Mike";

var LastName = "Prestwood";

var Age = 42;

var FirstName;

var LastName;

var Age;

Perl is a loosely typed language with only three types of variables: scalars, arrays, and hashes. Use $ for a scalar variable, @ for an array, or % for a hash (an associative array).

The scalar variable type is used for any type of simple data such as strings, integers, and numbers. In Perl, you identify and use a variable with a $ even within strings.

#!/usr/local/bin/perl -w

 
print("Content-type: text/html\n\n");

$fullname = 'Mike Prestwood';
$Age = 38;
$Weight = 162.4;

 

print "Your name is $fullname.
";
print "You are $Age and weigh $Weight.
";

 Perl Variables ($x = 0;)

PHP is a loosely typed language. No variable types in PHP. Declaring and using variables are a bit different than in other languages. In PHP, you identify and use a variable with a $ even within strings!

You assign by reference with & as in &$MyVar.

$fullname = 'Mike Prestwood';
$FullName = 'Wes Peterson';   //This is a different variable!
$Age = 38;
$Weight = 162.4;

 

echo "Your name is $fullname.
";
echo "You are $Age and weigh $Weight.
";

 PHP Variables ($x = 0;)

VB Classic is a loosely typed language. Declaring variables is optional unless you use the Option Explicit statement to force explicit declaration of all variables with Dim, Private, Public, or ReDim. Using Option Explicit is strongly recommended to avoid incorrectly typing an existing variable and to avoid any confusion about variable scope.

Undeclared variables are variants. To specifically declare a variant, use:

Dim x As Variant

Dim x 

Common data types include Byte (0..255), Boolean, Integer (2-byte integers), Long (4-byte integers), Currency, Single (32-bit number), Double (64-bit number), Date, String, and variant.

Variables declared with Dim at the module level are available to all procedures within the module. At the procedure level, variables are available only within the procedure.

Dim FullName As String
Dim Age As Integer
Dim Weight As Double

FullName = "Mike Prestwood"

Age = 32

Weight = 154.4

'Declaritive assignment not supported:

''Dim Married As String = "Y"   '>>>Not supported.

 VB Classic Variables (Dim x As Integer)

Variables are case sensitive but VS.Net will auto-fix your variable names to the defined case. You can declare variables in-line wherever you need them and declarative variable assignment is supported.

Syntax Example:   Dim FullName As String Dim Age As Integer Dim Weight As Double FullName = "Mike Prestwood" Age = 32 Weight = 154.4 'Declaritive variable assignment: Dim Married As String = "Y" MsgBox(Married)