Пример кода на серверном javascript, взятый из очень ранней реализации/// This class introduces and demonstrates the server-side JavaScript facility.
Class JavaScript.Tutorial Extends %RegisteredObject
{

Property SampleProperty As %String [ InitialExpression = "SamplePropertyValue" ];

/// JavaScript can be used as the implementation language for class or instance methods of cache objects.
/// To use the facility, set the language keyword on the class or instance method to 'javascript'. This
/// instructs Studio to syntax check the method body as JavaScript. In previous versions of Cache, methods
/// with their language set to 'javascript' implicitly ran on the client. In current versions such methods 
/// have to be explicitly declared by using the new 'ClientMethod' or
/// 'ClientClassMethod' method introducers. Heres an example. This method won't generate any server code and 
/// cannot be called on the server.
ClientMethod Example1() [ Language = javascript ]
{
  // alert() is a function built into the browser, its part of the browsers intrinsic object model
  alert('Hello JavaScript');
}

/// This method is a regular method, so code will be generated and can be run on the server
ClassMethod Example2() [ Language = javascript ]
{
  // The server side javascript implementation has an intrinsic object model rooted in the 'Cache' object.
  // The Console object provides basic facilities to read and write to the console ( Terminal ). In this example
  // we write a string to the console 
  Cache.Console.WriteLine("Hello JavaScript");
}

/// This method demonstrates passing multiple arguments to Cache.Console.WriteLine
ClassMethod Example3() [ Language = javascript ]
{
  // The Cache.Console.WriteLine() method can take a variable number of arguments. Each is written to the console
  // followed by a newline
  var x = "This",y="Multiple Arguments";
  Cache.Console.WriteLine(x," is an example of ",y);
}

/// This method illustrates the difference between undefined in JavaScript and undefined in Cache
ClassMethod Example4() [ Language = javascript ]
{
  // Variables in javascript which are not assigned a value have the 'undefined' value. undefined is an object.
  // Cache does not have an undefined object so if these values are passed to cache either as method arguments
  // or return values from javascript methods, then Cache will treat them as undefined in the Cache sense
  var x; // undefined value
  if (x == undefined) {
    Cache.Console.WriteLine("x is undefined");
  }
  
  var y = "defined"; // define value
  
  // Call the helper method with an undefined value. This also illustrates how to call a method in the same class.
  // In javascript for cache, the 'this' object inside a class method refers to the class itself, whilst an instance
  // method will refer to the particular instance ( more on this later )
  this.HelperForExample4(x);
  
  // Call the helper method with a defined value
  this.HelperForExample4(y);
}

/// This is a helper method for example 4. Note that its written in COS and can be called from JavaScript
ClassMethod HelperForExample4(pArgument)
{
  If '$Data(pArgument) {
    Write "Passed Argument is undefined",!
  } else {
    Write pArgument,!
  }
}

/// This method illustrates the use of the Cache.Console.ReadLine() method
ClassMethod Example5() [ Language = javascript ]
{
  var x = Cache.Console.ReadLine();
  Cache.Console.WriteLine(x);
}

/// This method illustrates the use of the intrinsic object Cache.Class. Think of the Class object as an 'accessor' for
/// a Cache class. Cache classes appear as properties of the Cache.Class object. In the example below we are calling the 
/// Example4() class method on JavaScript.Tutorial. Also note the naming convention.  In COS names may begin with a
/// '%' character and may contain '.' characters within them. JavaScript doesn't allow those characters in names so we
/// have to have a naming convention in JavaScript to refer to such COS names. In JavaScript we substitute '$' for '%' 
/// and '_' for '.'
ClassMethod Example6() [ Language = javascript ]
{
  Cache.Class.JavaScript_Tutorial.Example4();
}

/// You can create new instances of Cache Classes by calling the %New() method on the class. Its very important to
/// have a clear understanding of the lifetime of objects created from within the JavaScript environment as the behavior
/// is different from Cache. When a object is created in this manner, the JavaScript environment 'owns' the object. It will
/// determine when the object is going to go out of scope and its memory be reclaimed. This is due to JavaScripts deferred
/// Garbage collection algorithm. If you don't care about the lifetime of objects then there is nothing special that has to
/// be done, the JavaScript engine will take care of things for you. However, if you DO care about having a object go out of
/// scope and have its %OnClose() method closed immediately then there is a special method that can be called. In JavaScript,
/// this is the $$Close() method. Call this if you want JavaScript to force the %OnClose() to be called.
ClassMethod Example7() [ Language = javascript ]
{
  // Create an instance of JavaScript.Tutorial, %OnNew() callback ( see below ) will be called
  var instance = Cache.Class.JavaScript_Tutorial.$New();
  
  // Write out the value of its SampleProperty
  Cache.Console.WriteLine(instance.SampleProperty);
  
  // Force the object to close, %OnClose() callback ( see below ) will be called
  instance.$$Close();
}

/// Contrast this example with Example7. Here the object isn't closed and will only be closed when JavaScript garbage
/// collects the object. If you close the terminal following Example8 you will see the %OnClose() method called before
/// the process exits.
ClassMethod Example8() [ Language = javascript ]
{
  // Create an instance of JavaScript.Tutorial, %OnNew() callback ( see below ) will be called
  var instance = Cache.Class.JavaScript_Tutorial.$New();
  
  // Write out the value of its SampleProperty
  Cache.Console.WriteLine(instance.SampleProperty);
}

/// You can also force ALL objects that are eligible for garbage collection to be collected by calling the
/// %JavaScript.Runtime.%GarbageCollect() method
ClassMethod Example9() [ Language = javascript ]
{
  // Create an instance of JavaScript.Tutorial, %OnNew() callback ( see below ) will be called
  var instance = Cache.Class.JavaScript_Tutorial.$New();
  
  // Write out the value of its SampleProperty
  Cache.Console.WriteLine(instance.SampleProperty);
  
  // Make instance elligible for collection
  instance = null;
  
  // Force a Garbage Collection
  Cache.Class.$JavaScript_Runtime.$GarbageCollect();
}

/// This method illustrates an alternatve means of creating an object with the JavaScript 'new' command
ClassMethod Example10() [ Language = javascript ]
{
  // Create an instance with the JavaScript 'new' command
  var instance = new Cache.Class.JavaScript_Tutorial;
  
  // Write out the value of its SampleProperty
  Cache.Console.WriteLine(instance.SampleProperty);
  
  // Make instance elligible for collection
  instance = null;
  
  // Force a Garbage Collection
  Cache.Class.$JavaScript_Runtime.$GarbageCollect();
}

/// This method illustrates how to open and update an instance of a persistent Cache Object. Note also enumeration of property
/// names with the for/in syntax and indirect property value access with the [] syntax.
ClassMethod Example11() [ Language = javascript ]
{
  // Make sure Sample.Person is populated with sample data
  Cache.Class.Sample_Person.Populate(10);
  
  // Open instance number 1
  var instance = Cache.Class.Sample_Person.$OpenId(1);
  
  // Display the properties
  for (var property in instance) {
    Cache.Console.WriteLine(property," = ",instance[property]);
  }
  
  // Expand the home address
  var address = instance["Home"];
  
  for (var line in address) {
    Cache.Console.WriteLine(line," = ",address[line]);
  }
  
  // Update the name
  instance["Name"]="Buffy The Vampire Slayer";
  
  // Save the object
  instance.$Save();
  
  // Finished with this object
  instance.$$Close();
}

/// Access to Cache globals is through the intrinsic Cache.Global object
ClassMethod Example12() [ Language = javascript ]
{
   // Clean up any pre-existing data
   Cache.Global.Kill("^JavaScript");
   
   // Set some data, subscripts are specified by a JavaScript Array
   Cache.Global.Set("^JavaScript",["a"],"abba");
   Cache.Global.Set("^JavaScript",["b"],"beatles");
   Cache.Global.Set("^JavaScript",["c"],"clapton");
 
   // Traversal is natural
   var global="^JavaScript", array = [""], key = Cache.Global.Order(global,array);
   while (key !="") {
     
     // We are removing the last value from the array and replacing it with the new key
     array.pop();array.push(key);
     
     // Test to see if data exists at this node
     if (Cache.Global.Data(global,array)%2) {
       
       // Yes it does, get it
       var data = Cache.Global.Get(global,array);

      // Display the data and key       
       Cache.Console.WriteLine(key," = ",data);
       
     } else {
       
       // Just display the key
       Cache.Console.WriteLine(key);
     }
     
     // Get the next key
     key = Cache.Global.Order(global,array);
   }
}

/// This callback method is invoked by the <METHOD>%New</METHOD> method to 
/// provide notification that a new instance of an object is being created.
/// 
/// <P>If this method returns an error then the object will not be created.
/// <p>It is passed the arguments provided in the %New call.
/// When customizing this method, override the arguments with whatever variables and types you expect to receive from %New().
/// For example, if you're going to call %New, passing 2 arguments, %OnNew's signature could be:
/// <p>Method %OnNew(dob as %Date = "", name as %Name = "") as %Status
Method %OnNew(initvalue As %CacheString) As %Status [ Private, ProcedureBlock = 1, ServerOnly = 1 ]
{
  Write "Instance ",##this," of ",..%ClassName(1)," Created",!
  Quit $$$OK
}

/// This callback method is invoked by the <METHOD>%Close</METHOD> method to 
/// provide notification that the current object is being closed.
/// 
/// <P>The return value of this method is ignored.
Method %OnClose() As %Status [ Private, ProcedureBlock = 1, ServerOnly = 1 ]
{
  Write "Instance ",##this," of ",..%ClassName(1)," Destroyed",!
  Quit $$$OK
}

}