Пример кода на серверном 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
}
}
