Currently this program prints the file and directory names and their sizes in alphabetical order. But I am more interested in their relative sizes. It would, therefore, be more useful if the files were sorted by size rather than by name.
To be able to sort the files, you need some way of storing a complete list of all file sizes. One obvious way of doing this would be to add the file sizes to an array. In file_info2.rb, I create an empty array, $files, and each time a file is processed, I append its size to the array:
file_info2.rb
$files << fsize
I can then sort the file sizes to display low to high values or (by sorting and then reversing the array) to display from high to low values:
$files.sort # sort low to high $files.sort.reverse # sort high to low
The only trouble with this is that I now end up with an array of file sizes without the associated filenames. A better solution would be to use a Hash instead of an Array. I’ve done this in file_info3.rb. First, I create two empty Hashes:
file_info3.rb
$dirs = {}
$files = {}Now, when the processfiles method encounters a directory, it adds a new entry to the $dirs Hash using the full directory path, mypath, as the key and using the directory size, dsize, as the value:
$dirs[mypath] = dsize
Key-value pairs are similarly added to the $files hash. When the entire structure of subdirectories and files has been processed by recursive calls to the processfiles method, the $dirs hash variable will contain key-value pairs of directory names and sizes, and the $files hash will contain key-value pairs of file names and sizes.
All that remains now is for these hashes to be sorted and displayed. The standard sort method for a Hash sorts the keys, not the values. I want to sort the values (sizes), not the keys (names). To do this, I have defined a custom sort method (refer to Chapter 4 and Chapter 5 for guidance on defining custom comparisons using <=>):
$files.sort{|a,b| a[1]<=>b[1]}Here the sort method converts the $files Hash into nested arrays of [key,value] pairs and passes two of these, a and b, into the block between curly brackets. The second item (at index [1]) of each [key,value] pair provides the value. The sorting itself is done on the value using Ruby’s <=> comparison method. The end result is that this program now displays first a list of files in ascending order (by size) and then a similarly sorted list of directories. This is an example of its output:
..ch19logappmodelspost.rb : 36 bytes ..ch19say_hello.html.erb : 41 bytes ..ch13 estfile.txt : 57 bytes ..ch012helloname.rb : 67 bytes ..ch9div_by_zero.rb : 71 bytes ..ch12 est.rb : 79 bytes ..ch4dir_array.rb : 81 bytes ..ch3for_to.rb : 89 bytes
Digging Deeper
Recursion is an important programming technique that can, however, be quite difficult to understand. Here I will explain recursion one step at a time.
Recursion Made Simple
If you’ve never used recursion before, the recursive “directory-walking” methods in this chapter may need a little explanation. To clarify how recursion works, let’s look at a much simpler example. Load the recursion.rb program:
recursion.rb
$outercount = 0
def addup( aNum )
aNum += 1
$outercount +=1
puts( "aNum is #{aNum}, $outercount is #{$outercount}" )
if $outercount < 3 then
addup( aNum ) #<= recursive call to addup method
end
puts("At END: aNum is #{aNum},outercount is #{$outercount}")
end
addup( 0 ) #<= This is where it all beginsThis contains the recursive method, addup, whose sole purpose in life is to count from 1 to 3. The addup method receives an integer value as an incoming argument, aNum.
addup( aNum )
There is also global variable, $outercount, which lives “outside” the addup method. Whenever the addup method executes, 1 is added to aNum, and 1 is also added to $outercount. Then, just so long as $outercount is less than 3, the code inside the addup method calls the same method (addup) all over again, passing to it the new value of aNum:
if $outercount < 3 then
addup( aNum )
endLet’s follow what happens. The process is started off by calling addup with the value 0:
addup( 0 )
The addup method adds 1 to both aNum and $outercount, so both variables now have the value 1. The test ($outercount < 3) evaluates to true, so aNum is passed as an argument to addup. Once again, 1 is added to both variables, so aNum is now 2, and $outercount is also 2. Now aNum is once more passed to addup. Yet again 1 is added to both variables, giving each the value 3. This time, however, the test condition fails since $outercount is no longer less than 3. So, the code that calls addup is skipped, and you arrive at the last line in the method:
puts( "At END: aNum is #{aNum}, outercount is #{$outercount}" )This prints out the values of aNum and $outercount, which, as you expect, are both 3. Having arrived at the end of this method, the “flow of control” moves back to the line of code immediately following the code that originally called the method. Here, the line of code that called the addup method happens to be inside the method itself. Here it is:
addup( aNum )
And the first executable line that follows this is (once again) the final line of the method that prints out the values of the two variables:
puts( "At END: aNum is #{aNum}, outercount is #{$outercount}" )So, you have gone back to an earlier “point of execution”—the point at which you recursively called the addup method. At that time, the value of aNum was 2, and that is its value now. If this seems confusing, just try to think what would have happened if aNum had been 2 and then you called some other, unrelated method. On returning from that other method, aNum would, of course, still have had the value 2. That’s all that’s happened here. The only difference is that this method happened to call itself rather than some other method.
Once again, the method exits, and control returns to the next executable line following the code that called the method, and aNum’s value has taken another step back into its own history—it now has the value 1. The $outercount variable, however, lives outside the method and is unaffected by recursion, so it is still 3.
If you have access to a visual debugger, this entire process will become much clearer: You can place a breakpoint on line 9 (if $outercount < 3 then), add aNum and $outercount to the Watch window, and repeatedly step into the code after you hit the breakpoint.
This screenshot shows the recursion program being debugged visually in the IDE Ruby In Steel. I can step through the source code, use the call stack to keep track of the current “level” of recursion (how many times the addup method has been called), and use the Watch window to monitor the current values of the variables.