Mastering Collection Traversal: JScript vs. JavaScript in Visual Studio

Table of Contents

This article delves into the methods of traversing collections using both JScript and JavaScript within the Visual Studio environment. Understanding collection traversal is fundamental for developers working with scripting languages to manipulate and access data efficiently. This article will illuminate the distinctions between JScript and JavaScript approaches, particularly when interacting with collections in Active Server Pages (ASP) pages.

Summary¶

In the realm of server-side scripting for Active Server Pages (ASP), developers often employ VBScript alongside JScript or JavaScript. When it comes to iterating through collections, these languages exhibit different methodologies. VBScript offers the straightforward FOR EACH...NEXT loop, a construct designed for simple collection traversal. Conversely, JScript and JavaScript necessitate the use of an enumerator object to achieve similar iteration. This distinction arises from the inherent design philosophies and object model implementations of these scripting languages. This article will explore these differences through practical examples, focusing on file system object manipulation.

More Information¶

To illustrate the contrasting approaches, we will use the file system object to navigate a directory, specifically C:\Text, and list all contained files. This scenario provides a tangible context for demonstrating collection traversal in both VBScript and JScript/JavaScript.

VBScript Example: Utilizing the FOR EACH...NEXT Loop¶

VBScript simplifies collection iteration with its FOR EACH...NEXT loop. This construct directly iterates over each element within a collection, making the code readable and concise. The following steps and code example outline how to achieve file listing using VBScript’s FOR EACH...NEXT loop:

1. Directory Setup: Begin by creating a new folder named “Text” in the root directory of drive C (C:\Text).
2. File Population: Populate the “Text” directory with at least five text files. These files will serve as the collection elements we intend to traverse.
3. ASP Page Creation: Create a new Active Server Pages (.asp) page. This page will house the VBScript code responsible for file listing.
4. VBScript Code Implementation: Embed the following VBScript code within the ASP page:

<% @LANGUAGE="VBScript" %>
<%
' Reference the FileSystemObject
set FSO = Server.CreateObject("Scripting.FileSystemObject")

' Reference the Text directory
set Folder = FSO.GetFolder("C:\Text")

' Reference the File collection of the Text directory
set FileCollection = Folder.Files

Response.Write("VBScript Method<BR>")

' Display the number of files within the Text directory
Response.Write("Number of files found: " & FileCollection.Count & "<BR>")

' Traverse through the FileCollection using the FOR EACH...NEXT loop
For Each FileName in FileCollection
    strFileName = FileName.Name
    Response.Write(strFileName & "<BR>")
Next

' De-reference all the objects
set FileCollection = Nothing
set Folder = Nothing
set FSO = Nothing
%>

This VBScript code first instantiates the FileSystemObject to interact with the file system. It then retrieves a reference to the “Text” folder and its file collection. The FOR EACH...NEXT loop iterates through each file in the FileCollection, extracting the filename and outputting it to the ASP page. Finally, the script dereferences the objects to release resources.

JScript or JavaScript Example: Employing the Enumerator Object¶

In contrast to VBScript, JScript and JavaScript require an enumerator object for collection traversal. This approach is rooted in the way these languages handle object iteration, particularly within the context of COM (Component Object Model) objects like FileSystemObject. The enumerator object provides a mechanism to sequentially access elements of a collection. To replicate the file listing functionality using JScript or JavaScript, follow these steps, substituting the VBScript code with the following JScript code in step 3 of the previous instructions:

<% @LANGUAGE="JScript" %>
<%
// Reference the FileSystemObject
var FSO = Server.CreateObject("Scripting.FileSystemObject");

// Reference the Text directory
var Folder = FSO.GetFolder("c:\\Text");

// Reference the File collection of the Text directory
 var FileCollection = Folder.Files;

Response.Write("JScript Method<BR>");

// Display the number of files within the Text directory
Response.Write("Number of files found: " + FileCollection.Count + "<BR>");

// Traverse through the FileCollection using the FOR loop and Enumerator
for(var objEnum = new Enumerator(FileCollection); !objEnum.atEnd(); objEnum.moveNext()) {
 strFileName = objEnum.item();
 Response.Write(strFileName + "<BR>");
}

// Destroy and de-reference enumerator object
delete objEnum;
objEnum = null;

// De-reference FileCollection and Folder object
FileCollection = null;
Folder = null;

// Destroy and de-reference FileSystemObject
delete FSO;
FSO = null;
%>

This JScript code mirrors the VBScript example in its objective but diverges in implementation. It also starts by creating a FileSystemObject and obtaining the file collection. However, instead of a FOR EACH...NEXT loop, it utilizes a FOR loop in conjunction with an Enumerator object. The Enumerator is instantiated with the FileCollection. The loop continues as long as !objEnum.atEnd() is true, indicating that the enumerator has not reached the end of the collection. objEnum.moveNext() advances the enumerator to the next item, and objEnum.item() retrieves the current item, which is then outputted. Crucially, the JScript code explicitly destroys and dereferences the Enumerator object (delete objEnum; objEnum = null;) along with other objects to manage resources effectively.

Syntax Note on Enumerator Instantiation¶

It’s worth noting that in JScript and JavaScript, the enumerator object is instantiated directly within the FOR loop’s initialization section. This is perfectly acceptable syntax and a common practice when using enumerators for collection traversal. The general syntax for the FOR statement is:

FOR(initialize; test; increment)
statement;

In our JScript example, var objEnum = new Enumerator(FileCollection) serves as the initialization, !objEnum.atEnd() as the test condition, and objEnum.moveNext() as the increment.

Output Discrepancies¶

The output generated by the VBScript and JScript/JavaScript examples will exhibit a subtle yet noticeable difference.

VBScript Output¶

The VBScript example, utilizing the FOR EACH...NEXT loop and accessing FileName.Name, will output only the file name and its extension.

VBScript Method
Number of files found: 5
test1.txt
test2.txt
test3.txt
test4.txt
test5.txt

JScript/JavaScript Output¶

Conversely, the JScript/JavaScript example, employing the enumerator object, outputs the full physical path of each file, including the folder path, filename, and extension. This is because the enumerator’s item() method returns a File object, and when this object is implicitly converted to a string for output using Response.Write, it defaults to its toString() representation, which includes the full path.

JScript Method
Number of files found: 5
C:\Text\test1.txt
C:\Text\test2.txt
C:\Text\test3.txt
C:\Text\test4.txt
C:\Text\test5.txt

This difference highlights how VBScript’s FOR EACH...NEXT loop and JScript/JavaScript’s enumerator, while achieving the same goal of collection traversal, might present data in slightly different formats depending on the object properties accessed and implicit type conversions within each language.

References¶

[Empty Reference Section - According to Instructions, no external links or references from original article.]

---

Feel free to leave a comment below if you have any questions or insights about collection traversal in JScript and JavaScript!