WebScript for Objective-C Developers

WebScript uses a subset of Objective-C syntax, but its role within an application is significantly different. The following table summarizes some of the differences.


Objective-C	WebScript
Is compiled	Is interpreted
Supports primitive C data types	Supports only the class type
Performs type checking at compiled time	Never performs type checking
Requires method prototyping	Doesn't require method prototyping (that is, you don't declare methods before you use them)
Usually involves a .h and a .m file	Stands alone (unless inside of a component directory)
Supports all C language features	Has limited support for C language features; for example, doesn't support structures, pointers, enumerations, or unions
Methods not declared to return void must include a return statement	Methods aren't required to include a return statement
Has preprocessor support	Has no preprocessor support-that is, doesn't support the #define, #import, or #include statements
Uses reference counting to determine when to release instance variables	Automatically retains all instance variables for the life of the object that owns them. Automatically releases instance variables when the object is released.

Here are some of the more subtle differences between WebScript and Objective-C:

You don't need to retain instance variables in the init method or release them in the dealloc method. In general, you never have to worry about releasing variables. One exception: if you perform a mutableCopy on an object, you must release that copy.
Categories must not have an @interface declaration in WebScript.
The @ in WebScript signifies the initialization of an NSString, NSDictionary, or NSArray.
Instead of using operators like @selector, you simply enclose the selector in double quotes ("").
Certain operators from the C language aren't available in WebScript, notably the postdecrement, postincrement, and cast operators.
Boolean expressions never short-circuit.

Of course, the most significant difference between Objective-C and WebScript is that in WebScript, all variables must be objects. Some of the less obvious implications of this are:

You can't use methods that take non-object arguments (unless those arguments are integers or floats, which WebScript converts to NSNumbers). For example, in WebScript the following statement is invalid:
```
	// NO!! This won't work.NSRange is a structure.
	string = [NSString substringWithRange:aRange];
```

You can only use the "at sign" character (@) as a conversion character with methods that take a format string as an argument:

	// This is fine.
	[self logWithFormat:@"The value is %@", myVar];

	// NO!! This won't work. It prints the address of var1.
	[self logWithFormat:@"The values are %d and %s", var1, var2];

You need to substitute integer values for enumerated types.
For example, suppose you want to compare two numeric values using the enumerated type NSComparisonResult. This is how you might do it in Objective-C:
```
	result = [num1 compare:num2];
	if(result == NSOrderedAscending) /* This won't work in WebScript */
		/* num1 is less than num2 */
```
But this won't work in WebScript. Instead, you have to use the integer value of NSOrderedAscending, as follows:
```
	result = [num1 compare:num2];
	if(result == -1)
		/* num1 is less than num2 */
```
For a listing of the integer values of enumerated types, see the "Types and Constants" section in the Foundation Framework Reference.

Table of Contents Next Section