Home > Articles


  • Print
  • + Share This

Chapter 3: Datatypes, Arrays, and Strings

This chapter discusses the declaration of variables in JScript .NET, the correlation of variables with common language runtime (CLR) types, and how the compiler makes intelligent decisions between legacy JScript semantics and new performance-oriented JScript .NET semantics.

The discussion in this chapter moves from the new data typing syntax used in JScript .NET straight to the base language datatypes. A thorough explanation of strongly typing variables is followed an exploration of how to create arrays. Both the legacy JScript style array and the newer CLR-style array are discussed. The only other remaining datatype of importance is the string. Strings are the basis for the majority of programs.

Strongly Typing in JScript .NET

Strongly typed variables allow the JScript .NET compiler to use appropriately sized internal data structures when performing operations. Typed data doesn't have to be converted to and from different datatypes when basic operations and assignments occur. It always occupies the appropriate amount of memory space for its size, thus allowing the developer to optimize for size and use smaller datatypes when appropriate. Furthermore, it allows the compiler to remove various checks that were once required when the same variable could at one point be a string and at another point an integer.

How to Strongly Type Variables

So how do you start taking advantage of these new improvements in JScript .NET? You declare variables to give them scope and you type variables so that the compiler uses the optimized operations and removes the type checks during runtime. You declare all variables by using the var keyword. Any additional access modifiers needed to complete the declaration can precede the var keyword. An additional modifier, a custom attribute, can also be applied (both access modifiers and attributes are discussed in Chapter 6, "Creating Classes"). The following example demonstrates how to declare a nontyped variable named UnknownVar:

// Untyped variable declaration in Global Code
var UnknownVar;


For a complete explanation of the access modifiers and custom attributes, you can jump to Chapter 6, which discusses class members. The following are some of the important modifiers you can learn more about in Chapter 6:

  • The public keyword makes variables available outside the current scope but does not make the variable global.

  • The static keyword makes variables persistent after they go out of scope, effectively making the variable a global variable yet limited to being global inside the current scope, without additional modifiers.

  • The private keyword declares variables as locally scoped variables that are available only to code within the current scope.

The scope-related modifiers are available only from within a class definition. So, for the most part, you won't be using them in the early chapters of this book.

Simply declaring a variable doesn't do anything more than give that variable a scope. If you performed a declaration within a class, the variable would be scoped to that class. If you performed the same declaration within a method, the variable would be scoped to the function level. Because the declaration in the preceding example occurs in global code, it creates a global variable named UnknownVar of type Object. This doesn't provide any performance benefits, and the variable isn't strongly typed. To strongly type a variable, you use the syntax name:type (where name is the name of the variable and type is the variable type). The colon after name tells the compiler that you want to strongly type the variable. The following is an example of strongly typing several variables (notice that whitespace doesn't matter to the compiler):


Notice that the introduction of whitespace (that is, space characters, tabs, and carriage returns) in the code doesn't matter to the compiler and doesn't affect the way the compiler parses the source code.

var StringVar:String
var IntVar   :Int32
var BoolVar:    Boolean
var ArrayVar   :   String[]

All these statements create valid variables that are strongly typed. The whitespace between the variable name, colon, and type name doesn't matter because the compiler ignores whitespace. You can make the type name a short name, or you can make it a fully qualified name by appending the namespace to the type name. After you type this code, the compiler will throw warnings if you try to assign invalid values. Assigning to StringVar an object of some type that can't be converted to a string would result in a compiler error, as would assigning a string to IntVar.

Providing Initial Values for Variables

You can initialize variables with default values. You might want to do this to ensure that you have some working values before the code starts operating on them. You can also see some of the compiler errors by creating some initialization expressions where the type of the initializing value is of a different type than the variable to which the value is being assigned. For example, the following example assigns the string constant "Hello" to StringVar and the value 10 to IntVar:

import System;
import System.Collections;

// Valid Initializers
var StringVar:String = "Hello";
var IntVar:Int32 = 10;
var HashVar:Hashtable = new Hashtable();

// Tricky Initializers
var String2Var:String = 23;
var Int2Var:Int32 = "27";

// Invalid initializers
var IntVar:Int32 = "Hello";

The new keyword creates a new instance of a hashtable. The next assignment is rather tricky—it assigns a numeric value to String2Var. You would think that this would result in a compiler error, but JScript converts the numeric constant 23 to the string constant "23". Furthermore, the JScript compiler turns the string constant "27" into the numeric constant 27 so that Int2Var contains a numeric value. The next couple initializers throw some errors because you can't assign a string constant that can't be parsed as a number into a numeric variable. Notice that the example does not provide invalid syntax for assigning initializer values to a String object because any type or value can be converted to a string to be assigned to the String object. We'll discuss this further in the section "Using the String Object," later in this chapter.


Every object in the .NET framework supports the ToString() method, which returns the string representation of an object (which can be a name, a serialized version of the object, or any other textual representation). Therefore, assigning any value or object to a String object does not throw an error in JScript .NET because JScript converts any objects or initializer values into string values before continuing. Note that this can cause strange values to be assigned to string variables and can sometimes cause code to go down a code path you wouldn't normally expect.

Performance and Strongly Typed Variables

The performance benefits of strongly typing variables are extremely obvious when you look at the process of performing operations on each type of code. You can directly operate on strongly typed variables without the extra level of indirection that is required for traditional JScript variables. In JScript, the underlying object currently referenced by a variable is checked for type and then converted, if necessary, to a type that is compatible with the current operation. In JScript .NET code, the operation occurs automatically. If the type is incompatible, an exception is thrown, and this forces you, as the programmer, to preemptively check variable operations or to wrap them in try...catch blocks (discussed in Chapter 8, "Exception Handling") and handle the exceptions. It also means that in well-programmed code, several operations are saved for each variable operation.

A second performance advantage has to do with the JScript compiler and is a direct result of not typing variables. The JScript compiler team assumed that there would be quite a bit of legacy code to deal with, and it wanted to see performance benefits without having to recode all the existing samples and programs. The team decided that if the context of a variable and all assignments to that variable could be determined within a local scope, it could guess the type of a variable. Basically, this means that performance-oriented variables, such as loop variables and counters, are strongly typed if they are declared in a local scope. To declare a variable in local scope, you use the var keyword on the variable, but it doesn't have to be strongly typed because the compiler infers the type. This option is not available for global variables or variables that aren't declared within a particular scope (because the compiler sets them as global variables).

The Flexibility of Native JScript Variables

All the existing flexibility of native JScript variables is still available in JScript .NET. All String variables, for instance, are stored as JScript strings and are converted to CLR strings as needed at runtime. This conversion is completed by some helper functions in the JScript namespace that are called whenever a complex conversion needs to be made. Any variable declared as an Array object is considered to be a JScript array, and any variable declared as a System.Array object is considered to be a CLR array. The automatic conversions are in place, and interaction with the .NET platform is not an issue because the compiler provides services for conversion of all native JScript types to their equivalent CLR types. So, if flexibility and backward compatibility are issues when you're working with variables, or there is some behavior about classic JScript that you loved to use, then you should feel free use it. Just be aware of the performance issues involved and of the new syntaxes that you can take advantage of for creating faster and smaller code.

  • + Share This
  • 🔖 Save To Your Account

Related Resources

There are currently no related titles. Please check back later.