Recursively searching / comparing nested Hashtables? - powershell

Question

Let me start by apologising that the below data structure probably isn't written correctly. I dynamically created the hashes in the code and I'm not very good at trying to represent what gets created.
$Sailings= #{
'Arrivals' = #{
$DynamicKey_booking_Ref = #{
'GoingTo' = 'Port1';
'Scheduled' = '09:05';
'Expected' = '10:09';
'Status' = 'Delayed'
};
'Departures' = #{
$DynamicKey_booking_Ref = #{
'ArrivingFrom' = 'Port1';
'Scheduled' = '09:05';
'Expected' = '09:05';
'Status' = 'OnTime'
};
}
}
I typically access the data like this. (hopefully that confirm the structure I'm using):
$Sailings.Arrivals.PDH083.GoingTo which returns "Port1"
$Sailings.Arrivals.PDH083.Scheduled which returns "09:05"
where PDH083 in this example is a dynamically created key based on a booking ref.
What I am trying to do is compare this structure with another identical structure but with potentially different values. E.g. are these two elements the same?
$Sailings.Arrivals.PDH083.GoingTo = "Port1"
$Output.Arrivals.PDH083.GoingTo = "Port5555"
If they're not the same capture the difference and the path/key that was different. Then report on them at the end.
What I'm struggling to write is a recursive loop that can walk down to the last element and then compare it to the $output. While my hashes are fixed now, I'd like to allow for the possibility that more nested hashes might be added lower down at a later date. Is this something that can be done easily?
I've used
($Sailings.Arrivals.keys | ? {$Output.Arrivals.keys -notcontains $_})
to show missing keys, but I just can't fathom a similar / efficient way of doing this for the values. I again can see I can use .values but it's still and element at a time.

Answer 1

Here is a semi recursive example, which returns string representations of the paths for all the leaves in the tree. Hope it gives you ideas:
$Sailings = #{
'Arrivals' = #{
'PDH083' = #{
'GoingTo' = 'Port1'
'Scheduled' = '09:05'
'Expected' = '10:09'
'Status' = 'Delayed'
}
}
'Departures' = #{
'PDH083' = #{
'ArrivingFrom' = 'Port1'
'Scheduled' = '09:05'
'Expected' = '09:05'
'Status' = 'OnTime'
}
}
}
function Roam($arg, $result="") {
if(!($arg -is [Hashtable])) {
return "$result/$arg"
}
foreach($pair in $arg.GetEnumerator()) {
Roam $pair.value "$result/$($pair.key)"
}
}
Roam $Sailings
The if is stop condition, the first thing you should ask when you are designing recursive operations: When I have a result?
Suppose you are standing on the roots of a huge tree, and you have been given a task of mapping routes to every single leave of that tree, every turn to the left or right on the branches from the trunk to a leave. Overwhelming, eh? But think instead about finding out a route to a single leave, whichever from the myriad.
You start climbing, and reach first branch. Will you turn to the left or right? Doesn't matter. You decide to take the left branch, and write down on piece of paper left. You reach next branch, and for matter of fun turn right, writing down right. After a few branches you are carrying notes like left, right, right, left, right and so on, until (because trees don't usually produce loops) eventually there is no more climbing but only a leave in font of you.
You've done it! You mapped the whole (and only one) path to this single leave, and can now jump down (hoping the tree is not too tall) and represent the paper containing the route to your adoring friends. Reaching the leave was the stop condition.
But how about the other leaves? Imagine you have a weird superpower of cloning yourself. When you reach a branch, you clone yourself and the paper you are carrying. If you turn right, you add that right turn to the notes, but the clone goes left, and writes down left instead. On next branch you again clone yourself and the paper, and write down your chosen direction, and the clone does the same for its direction. You don't have to worry about the clones, (Maybe you are a clone yourself!) just repeat that until you've reached the one leave and can jump out.
The $result argument is that piece of paper, and originally it doesn't came from anywhere, it's empty.
Because all the leaves in you data structure are strings, you could also write the if statement like:
if($arg -is [String])
How about GetEnumerator? Hashtables are normally not ordered in PowerShell. We can't pick first or second or sixth pair. But your data structure branches to more directions than left and right, so the Hashtable has to be ordered to an Array as a crowd of people to a queue, so we can use foreach loop to send our clones to their paths. (We could replace that loop with recursion, but let it be)
So in the function call Roam $pair.value "$result/$arg" the first argument is the branch ahead, and the second one is the piece of paper we just added the current direction.
Recommendation: You don't need to scramble it through, even the first few chapters are enlightening. Structure and Interpretation of Computer Programs https://mitpress.mit.edu/sicp/full-text/book/book.html