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.
Post History
As the walk documentation 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 fi...
Answer
#5: Post edited
by
r~~
·
2023-09-09T08:18:23Z (about 1 year ago)
revert meddling
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" andall(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
- ```
- 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
- ```
#4: Post edited
by
meta user
·
2023-09-05T06:13:40Z (about 1 year ago)
edit link, add headings
- 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
- ```
#3: Post edited
by
r~~
·
2023-09-04T04:56:19Z (about 1 year ago)
- 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
- ```
- 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
- ```
#2: Post edited
by
r~~
·
2023-09-04T04:52:51Z (about 1 year ago)
- 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)
- ```
- 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
- ```
#1: Initial revision
by
r~~
·
2023-09-04T01:19:14Z (about 1 year ago)
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)
```