Technical Articles

Arrays Versus Lists in WinBatch

David A. Gray, MBA
Chief Wizard, WizardWrx

WinBatch offers two mechanisms for processing lists, each of which is intended to solve a different set of problems involving collections of related data.

Lists have been a part of the language since the beginning.
Arrays were added in 2000 to permit construction of more complex data structures such as tables.

WinBatch provides rich sets of functions for manipulating both lists and arrays. The purpose of this paper is to explain the similarities and differences between lists and arrays and show how each is better suited to a different class of problems.

Lists

Lists are implemented as strings. List items are delimited by a specified character. The characteristics of a list derive from these two factors. Lists have the following characteristics.

The size of a list can be adjusted as needed during the course of a program.
Delimiter characters cannot occur within any list item. For example, a tab delimited list cannot contain items that also contain tabs. If you add such an item to your list, it will be treated as one plus the number of embedded delimiters items.
Adding or removing items from a list requires copying the entire string into a new location in memory. This can become very slow, especially with large lists and repeated updates, as it causes the heap to become very fragmented. Fragmented heaps require the garbage collector to work extra hard to consolidate unused blocks of memory into contiguous blocks.
Everything in a list is a string. Therefore, numeric data, including handles, must be converted to a string before it can be stored in a list, and back to a number before it can be used as such.
Lists can represent only one dimension. More complex data structures such as tables and matrices are difficult to represent as lists.

Lists lend themselves to storing static lists such as small lookup tables, from which an item of interest is extracted by position, and lists, such as file lists, that are passed to dialog boxes.

Arrays

Arrays are implemented as lists or tables of pointers to memory locations that contain the data. Unlike lists, there are no practical restrictions on the value of any array element. Arrays have the following characteristics.

Arrays have a fixed size, which you must define before the array is populated. You must allocate the maximum number of elements that the array will need for the life of the program, so that the table of pointers can be created.
Because they require no delimiters, strings stored in arrays may contain any valid character.
Because arrays are tables of pointers, adding, removing, and rearranging items is quite fast because existing elements stay put. Conversely, adding an item to a string requires the entire string to be moved.
Arrays can store mixed data, such as strings, numbers, and handles, in their native format. This eliminates the need to convert such data to and from string values.
Arrays can have two or more dimensions. This makes it possible to represent tables and matrices as arrays.

Arrays work well for storing tables and matrices of data whose size is known in advance. For example, the 2003 versions and later of WIL contain functions that can read an entire CSV file into a matrix. Because they are implemented as pointer tables, arrays significantly outperform lists on large numbers (hundreds or thousands) of items. This applies even to locating items by number, because a list must be searched linearly to locate and extract the item.

Summary

The following table summarizes the differences between lists and arrays.

Property	Lists	Arrays
Size	Adjusts as items are added or removed.	Defined before first use.
Allowable Characters in Data	Any except item delimiter.	Any.
Adding or Removing Item	Entire list must be copied to another memory location.	Only new item is copied, and array pointer table updated with location of new item.
Sorting Items	Entire list must be copied at least once.	Only small pointer table must be copied.
Total memory requirement.	Enough room to hold up to two copies of list.	Enough room to hold all elements and up to two copies of pointer table.

Last Updated 19 August 2006