Welcome to Software Development on Codidact!

Will you help us build our independent community of developers helping developers? We're small and trying to grow. We welcome questions about all aspects of software development, from design to code to QA and more. Got questions? Got answers? Got code you'd like someone to review? Please join us.

Review Suggested Edit

You can't approve or reject suggested edits because you haven't yet earned the Edit Posts ability.

As the [`walk` documentation](https://jqlang.github.io/jq/manual/#walk) describes:
> When an array is encountered, f is first applied to its elements and then to the array itself
In other words, `walk` is bottom-up. So when you apply your filter to your nested-array input, first you're flattening the innermost arrays into strings. Then the arrays at the next level out are arrays of strings, and they get flattened; and so on up the structure. It's not doing anything to your objects because you wrote the filter to only alter arrays.
You can see the definition of `walk` in the `jq` repository [here](https://github.com/jqlang/jq/blob/df95871dd7415627bda6d70ce0569d0a4fbc22c6/src/builtin.jq#L248C1-L256C5); from this it is easy to make a top-down variation that will do what you want, by simply moving the `f` from the right side of the pipe to the left.
```jq
def walktd(f):
def w:
f |
if type == "object"
then map_values(w)
elif type == "array" then map(w)
else .
end;
w;
walktd(if type == "array" and
all(type != "array" and type != "object")
then join("") else . end)
```
Alternatively, if you don't want to define your own function, you *can* do this with `walk` but you need to do a bunch of wrapping and unwrapping, in order to distinguish between a string that was produced by collapsing an array and a string that appeared in the original input:
```jq
walk(if type == "object"
then {
value: map_values(.value),
atom: false
}
elif type == "array"
then {
value: (if all(.atom) then map(.value) | join("") else map(.value) end),
atom: false
}
else {
value: .,
atom: true
}
end).value
```

Explanation
-
As the [`walk` documentation](https://jqlang.github.io/jq/manual/#walk) describes:
> When an array is encountered, f is first applied to its elements and then to the array itself
In other words, `walk` is bottom-up. So when you apply your filter to your nested-array input, first you're flattening the innermost arrays into strings. Then the arrays at the next level out are arrays of strings, and they get flattened; and so on up the structure. It's not doing anything to your objects because you wrote the filter to only alter arrays.
Solution 1
-
You can see the definition of `walk` in the [jq repository](https://github.com/jqlang/jq/blob/df95871dd7415627bda6d70ce0569d0a4fbc22c6/src/builtin.jq#L248C1-L256C5); from this it is easy to make a top-down variation that will do what you want, by simply moving the `f` from the right side of the pipe to the left.
```jq
def walktd(f):
def w:
f |
if type == "object"
then map_values(w)
elif type == "array" then map(w)
else .
end;
w;
walktd(if type == "array" and
all(type != "array" and type != "object")
then join("") else . end)
```
Solution 2
-
Alternatively, if you don't want to define your own function, you *can* do this with `walk` but you need to do a bunch of wrapping and unwrapping, in order to distinguish between a string that was produced by collapsing an array and a string that appeared in the original input:
```jq
walk(if type == "object"
then {
value: map_values(.value),
atom: false
}
elif type == "array"
then {
value: (if all(.atom) then map(.value) | join("") else map(.value) end),
atom: false
}
else {
value: .,
atom: true
}
end).value
```

Communities

Review Suggested Edit