caucho
Resin 1.1
FAQ
Reference
JavaDoc
Demo
Java Tutorial

Getting Started
Configuration
Servlet
JSP
XTP/XSL
JavaScript
JS Library

Source Text
Literals
Regexp
Operators
Objects
Functions
Statements
Java Wrapping
 Statements

  1. empty
  2. block
  3. expression
  4. var
  5. if
  6. switch
  7. while
  8. for
  9. for ... in
  10. do ... while
  11. break
  12. continue
  13. labeled statements
  14. return
  15. with
  16. class
    1. extends
  17. Exceptions
  18. catch
    1. Matching Exceptions
  19. finally
  20. throw
  21. synchronize
  22. import

empty

  ;

The empty statement does nothing. Its primary use is to separate statements. (See automatic semicolon insertion.)

a = 3; a++; var b = 3; if (a) b = 9;

block

  {
    statement_1
    ...
    statement_n
  }

The block statement sequentially executes statement_1 through statement_n.

expression

  expr

The expression statement executes any expression expr.

var

  var id_1 [= expr_1], ..., id_n [= expr_n]

The var statement declares and initializes variables id_1 through id_n. If expr_i exists, id_i gets its value, otherwise id_i gets undefined.

The var statement is most important in declaring local variables in a function. Although variables can be used without the var statement, undeclared variables are necessarily global.

Local variable declaration
var b = "global";
var a = "initial";

function foo()
{
  var b = "local";
  a = "global";
}

foo();

a + ' ' + b
global global

Unlike Java and C, the scope of the declared variable is the entire function, not the enclosing block. So in the following example, the second declaration of a is equivalent to a simple assignment.

Local scope is entire function
function foo()
{
  var a = "initial";
  {
    var a = "inner";
  }
  return a;
}

foo();
inner

if

if (cond)
  statement
[else
   else-statement]
The if statement conditionally executes code. If cond is true, it executes statement. Otherwise it executes else-statement if the else statement exists.

cond may be any expression, except that assignments must be enclosed in parentheses to ensure assignment is not confused with equality.

Illegal
if (a = 3)
  writeln("bad bad bad");
Okay
if ((a = 3))
  writeln("discouraged, but okay");
Here are some simple examples of the if statement.
Taken Branch
a = 13
if (a < 20)
  writeln("small");
small
Not Taken Branch
a = 30
if (a < 20)
  writeln("small");
  
Else Statement
a = 30
if (a < 20)
  writeln("small");
else
  writeln("large");
large

switch JavaScript 1.2

switch (expr) {
case literal_1
   statement_list_1

...

case literal_n
   statement_list_n

[default:
   default_statement_list]
}
The switch statement executes one of a number of branches. It evaluates expr and selects the matching literal_i. If none of the literals match, it selects default. It then executes statement_list_i and any following statements in the switch. A branch in a statement_list_i breaks out of the switch statement.
switch fall-through
switch (1) {
case 0: writeln(0);
case 1: writeln(1);
        writeln(2);
case 3: writeln(3);
        break;
case 4: writeln(4);
}
1
2
3
switch default
switch ("c") {
case "a":
  writeln(0);
  break;
case "b":
  writeln(1);
  break;
default:
  writeln("default");
  break;
}
default

while

while (cond)
  statement
The while statement repeatedly executes code. While cond is true, it executes statement.

Like if, cond may be any expression, except that assignments must be enclosed in parentheses to ensure assignment is not confused with equality.

i = 4
while (i--)
  writeln("Hello, world")
Hello, world
Hello, world
Hello, world
Hello, world

for

for ([init]; [cond]; [incr])
  statement
The for statement repeatedly executes code. While cond is true, it executes statement. After executing statement, it executes incr.

The for statement is equivalent to:

init;
while (cont) {
  statement;
  incr;
}
except it executes incr after a continue.

for (var i = 0; i < 4; i++)
  writeln("Hello, world")
Hello, world
Hello, world
Hello, world
Hello, world

for ... in

for ([var] i in expr])
  statement

The for ... in statement iterates over property names of an object. It does not guarantee any order.

o = {a:1, b:2, c:3}
for (var i in o)
  writeln(i);
c
a
b

o = [3, 2, 1]
for (var i in o)
  writeln(i);
2
0
1

do ... while JavaScript 1.2

do
  statement
while (expr)
do executes statement as long as expr is true. statement is guaranteed to be executed at least once.

i = 7
do
  writeln(i);
while (i < 3);
7

break

break [label]
break immediately terminates an enclosing loop or jumps to the end of a labelled block.

continue

continue [label]
continue jumps to the end of a loop, allowing it to execute again.

labeled statements JavaScript 1.2

labelstatement
A labeled statement executes as any other statement, except that a break executed in the statement will terminate the statement. If statement is a loop, a continue within the statement will continue the loop.

foo:
{
  a = 13;
  break foo;
  a = 19;
}
writeln(a);
13


loop:
for (var i = 0; i < 3; i++) {
  for (var j = 0; j < 10; j++) {
    if (j == 3)
      break loop;
  }
}
writeln(i);
0

return

return [expr]
The return statement immediately terminates the enclosing function and returns the value of expr as the function's value. If expr is missing, the function returns undefined.
Returning a value
a = 12
function foo() {
  return 1 + 3;
  a = 19;       // never executed
}

foo() + ' ' + a
4 12
Returning without a value
a = 12
function foo() {
  return 
     1 + 3   // treated as following statement, so never executed.
}

foo() + ' ' + a
4 12

with

with (expr)
  statement
The with extends the variable scope by looking up variables in expr before using local or global variables.
Simple use of with
o = { a : 13 }
a = 1
with (o) {
  writeln(a);
  a = 7
}
writeln(a + ' ' + o.a)
13
1 7

class Resin 1.0

Resin provides some syntactic sugar to JavaScript's prototype-based object inheritance to simplify objects creation.

class object-name [extends parent-object] {
  function member0(...) { ... }
  ...
  function membern(...) { ... }
}

The class statement simplifies JavaScript objects without adding any new semantic power to the language.

Only functions are currently allowed as members in the class.

The following are (almost) equivalent. The first using Resin's class extension, and the second following JavaScript's definitions. The only difference between the two is that the JavaScript version unavoidably binds the functions to the global object.

Sample class definition
class Car {
  function getColor() { return this.color; }
  function setColor(color) { this.color = color; }
  function start() { this.started = true; }
  function Car()
  {
    this.color = "red";
    this.started = false;
  }
}
The Car class using strict EcmaScript
function Car()
{
  this.color = "red";
  this.started = false;
}

function getColor() { return this.color; }
Car.prototype.getColor = getColor;

function setColor(color) { this.color = color; }
Car.prototype.setColor = setColor;

function start() { this.started = true; }
Car.prototype.start = start;

extends

The optional extends part of the class eases inheritance. Again, this adds nothing to the semantic power of the language but makes the code far more readable.

The following are equivalent

Using extends in Resin
class Car {
}
class Honda extends Car {
}
The equivalent of extends in strict EcmaScript
function Car() {}

function Honda() {}
Honda.prototype.prototype = Car.prototype;

Exceptions

Resin extends JavaScript to support Java exceptions. By supporting Java exceptions, Resin allows a tighter binding to Java components. If a server-side bean throws an exception, a Resin script can catch it and gracefully handle the error.

Since the JavaScript programs are compiled into Java bytecodes, the exception handling mechanism is essentially the same as for Java. The only real difference is the pattern matching for selecting a catch block.

catch Resin 1.0

try 
  protected statement

catch (exception_1 [var_1])
  handler_statement_1

...

catch ([exception_n [var_n]])
  handler_statement_n

This syntax is essentially the same as Java's exception handling. For clarity, repeating catch blocks and the optional finally block have been omitted.

protected statement list
catch ([exception [var]])
  handler statement

The second form of the catch block protects all statements in the enclosing block up to the catch statement. Scripts can use this to establish error handlers at the end of the script without having to wrap the bulk of the script in a try block.

for (var i = 0; i < 10; i++) {
  addBook(authors[i], titles[i], prices[i]);

  catch (SQLException e) {
    writeln("Failed database insertion: " + e);
  }
}

Matching Exceptions

Resin exception matching uses a string suffix match instead of the Java type match. Resin compares the catch statement name to the thrown exception's class name. If the class name ends in the catch statement name, the exception is considered to match.

Like Java's exceptions, if the exception class does not match, Resin will try the parent for a match. However, Resin will only catch descendants of Exception. It will not catch Throwable nor will it catch Error or its descendants.

If the catch expression is empty, it will match all exceptions.

try {
  foo();
} catch (IOException) {
}
java.io.Exception             caught
java.io.FileNotFoundException caught
java.lang.Exception           ignored
com.foobar.IOException        caught

finally Resin 1.0

try 
  protected statement
finally
  handler statement

protected statement list
finally
  handler statement
The finally statement guarantees the protected statement will be executed. The handler statement will execute for normal execution, for exceptions, and when break and return statements leave the protected statement.

throw Resin 1.0

throw exception;
The throw statement throws an exception. The Java VM unwinds the executation stack until it finds the nearest matching catch handler. All finally blocks are executed and synchronization locks are released.

synchronize Resin 1.0

synchronize (object)
  statement
  1. Convert the JavaScript object to its Java equivalent. For Java wrapped objects, this just involves unwrapping the object. Pure JavaScript objects are unconverted.
  2. Acquire Java object monitor using the JVM monitorenter.
  3. Evaluate statement
  4. Release the monitor on any exit: normal, break, return, or exception.

The following example synchronizes the underlying Java HashMap, not the JavaScript wrapper.

map = new java.util.HashMap();

synchronize (map) {
  map.put("foo", map.get("foo") + 1);
}

The following example synchronizes the Number Object, not the JavaScript primitive number.

number = new Number(1);
number.a = 1

synchronize (number) {
  number.a += 3;
}

import Resin 1.0

import scriptname;
Imports functions from another file, allowing scripts to share common functions and allowing developers to break their code into manageable chunks.

The imported file is treated as its own JavaScript file with its own global object. Its global statements execute before the global code of the importing file.

The import statement only imports the functions from the imported file. Global variables are not imported. The imported functions use the global object of the imported file, not the global object their imported into.

Imported scripts are looked up along a SCRIPTPATH. The initial value of SCRIPTPATH is:

.:$RESIN_HOME/scripts

Where $RESIN_HOME/lib/resin.jar is the resin.jar file.

com/caucho/test.js
var a = 10;

writeln("Import Execution");

function getA() { return a; }
import com.caucho.test;

writeln("Hello, world");
Import Execution
Hello, world
Import functions but not variables
var a
import com.caucho.test;

writeln(getA() + ' ' + a);
Import Execution
10 undefined


Functions   Java Wrapping
Copyright © 1998-2000 Caucho Technology. All rights reserved.
Last modified: Thu, 16 Sep 1999 14:56:48 -0700 (PDT)