We have already traveled a little way down this path. We have walked through basic variable types, and an array was mentioned as a type. Check out Part One of this excerpt series here. And Part Two here.
Editor's Note: This article is excerpted from chapter 10 of Open Source Starter Guide for IBM i Developers, by Pete Helgren.
Hashes are really just objects that have name/value pairs (key/value pairs) that on the face of it, don’t have much utility. But as we stray into the Web world and use JSON as a way of representing/moving data, the whole name/value pairing becomes pretty powerful.
Let’s first take a look at arrays because I think they will be pretty familiar to RPG programmers and programmers in general. In JavaScript we can construct an array in one of a couple of ways:
Like most things in JavaScript, we are dealing with dynamically typed data, so we can have any kind of stuff stuffed into an array. To retrieve data from an array, you just reference the cell the data is stored in:
which would return 1984.
We could also create an array like this:
which would return 1492.
The new Array() syntax should ring a few bells, and at least one light bulb should go on. You should be thinking to yourself, “Wait a minute, if it has a constructor, it must be an object!” Right you are! So what else does an array object have that we might make use of? Take a look at the following example:
Using the data from above, the output would be:
Item at 0 is 42
Item at 1 is life
Item at 2 is 1984
Item at 3 is 1492
Item at 4 is zebra
So the array will have a length object that is a count of the items in the array. We can also “push” things onto the array and “pop” things off:
myarray.pop(); // removes the last element
myarray.push('antelope'); // adds 'antelope' to the end of the array
Then iterate through them again:
Hashes have a similar “feel,” but because they are basically arrays without the index, you can access the contents differently. Rather than referencing their position in the stack, you reference the location by the “name” or “key” of the name/value pair. So let’s recreate the array as a hash making up keys to reference each value.
One way we could create our hash is like so:
And if we wanted to get a single value, we could reference its location using the name/ key:
We can get an array of keys in the hash/object by using the Object.keys method. It will return the following for the myhash object:
OK. Cool enough, but what use is it? In the command-line environment, iterating through key/value pairs may not be all that helpful. Certainly it has some utility, but how often will I be constructing and iterating though objects at the command line? Probably not very often. But hook this up to something with large amounts of I/O, like a database or a Web page, or both, and suddenly sorting through arrays of data or extracting data from objects becomes pretty important. Put the data and program that iterates through in on two different servers, and, man, most of your time could be spent parsing and sorting through data. That is where the concept of a “hash” becomes very useful! I briefly mentioned JSON, and it has become the “lingua franca” of the data-exchange world. The reason that the JSON format is so useful is ... well, let me show you an example, and you can tell me.
Let’s say we have an array of objects, and each of those objects represents a person. Take a look at this:
Classic JSON format! The only difference here is that with JSON all of the keys/names are in double quotes. That’s it! The utility comes in that as we evaluate each “record” in the array. Each array element contains an object {}. Those objects all have the same properties: firstname,lastname, age, and eyecolor. They don’t have to have the same properties—this looks more like an array of database records, but in any case, we can walk through the array and interrogate each object in the array pretty simply:
The output looks like this:
Item |
0 |
with |
firstname |
is |
John |
Item |
0 |
with |
lastname |
is |
Doe |
Item |
0 |
with |
age is 50 |
|
|
Item |
0 |
with |
eyecolor |
is |
blue |
Item |
1 |
with |
firstname |
is |
Pete |
Item |
1 |
with |
lastname |
is |
Helgren |
Item |
1 |
with |
age is 56 |
|
|
Item |
1 |
with |
eyecolor |
is |
green |
Item |
2 |
with |
firstname |
is |
Bubba |
Item |
2 |
with |
lastname |
is |
Gump |
Item |
2 |
with |
age is 32 |
|
|
Item |
2 |
with |
eyecolor |
is |
brown |
Item |
3 |
with |
firstname |
is |
Frank |
Item |
3 |
with |
lastname |
is |
Zappa |
Item |
3 |
with |
age is 56 |
|
|
Item |
3 |
with |
eyecolor |
is |
gray |
Item 4 with firstname is Ima Item 4
with lastname is Minion Item 4 with
age is 18
Item 4 with eyecolor is black Item 5
with firstname is Ima Item 5 with
lastname is Hacker Item 5 with age is
15
Item 5 with eyecolor is crossed
Basically we iterated through the array and the properties of each object in the array. You’ll find yourself doing this quite a bit when you are working with HTML—perhaps when you build a drop-down list of values, formatted as a select option, or when you create a report in HTML. We basically have five lines of code! Not bad (unless we are paid by the line).
Next time: Part 4 - Functions. Can't wait? You can pick up Peter Helgren's book, Open Source Starter Guide for IBM i Developers at the MC Press Bookstore Today!
LATEST COMMENTS
MC Press Online