Argthtjtr

I am trying to remove null values from a json object using jq. I found this issue on their github and so now I'm trying to remove them with del.
I have this:

'{ id: $customerId, name, phones: ([{ original: .phone }, 

 { original: .otherPhone}]), email} | del(. | nulls)'

This doesn't seem to do anything. However if I replace nulls with .phones it does remove the phone numbers.

The following illustrates how to remove all the null-valued keys from a JSON object:

jq -n '{"a":1, "b": null, "c": null} | with_entries( select( .value != null ) )'

{

  "a": 1

}

Alternatively, paths/0 can be used as follows:

. as $o | [paths | {(.) : ($o[.])} ] | add

By the way, del/1 can also be used to achieve the same result, e.g. using this filter:

reduce keys as $k (.; if .[$k] == null then del(.[$k]) else . end)

Or less obviously, but more succinctly:

del( .[ (keys - [paths]) ] )

And for the record, here are two ways to use delpaths/1:

jq -n '{"a":1, "b": null, "c": null, "d":2} as $o

  | $o

  | delpaths( [  keys | select( $o[.] == null ) ] | map( [.]) )'





$ jq -n '{"a":1, "b": null, "c": null, "d":2}

  | [delpaths((keys - paths) | map([.])) ] | add'

In both these last two cases, the output is the same:
{
"a": 1,
"d": 2
}

[WARNING: the definition of walk/1 given in this response is problematic, not least for the reason given in the first comment; note also that jq 1.6 defines walk/1 differently.]

I am adding the new answer to emphasize the extended version of the script by @jeff-mercado. My version of the script assumes the empty values are as follows:

• 
  null;


• 
  - empty arrays;


• 
  {} - empty objects.

Removing of empty arrays and objects was borrowed from here https://stackoverflow.com/a/26196653/3627676.

def walk(f):

    . as $in | 

    if type == "object" then

        reduce keys as $key

            ( {}; . + { ($key): ( $in[$key] | walk(f) ) } ) | f

    elif type == "array" then 

        select(length > 0) | map( walk(f) ) | f

    else 

        f

    end;



walk(

    if type == "object" then

        with_entries(select( .value != null and .value != {} and .value !=  ))

    elif type == "array" then

        map(select( . != null and . != {} and .!=  ))

    else

        .

    end

)

That's not what del/1 was meant to be used for. Given an object as input, if you wanted to remove the .phones property, you'd do:

del(.phones)

In other words, the parameter to del is the path to the property you wish to remove.

If you wanted to use this, you would have to figure out all the paths to null values and pass it in to this. That would be more of a hassle though.

For an easier approach, you'll have to walk through the object tree to find null values. If found, remove the corresponding property (or otherwise filter it out). Using walk/1, your filter could be applied recursively to exclude the null values.

walk(

    if type == "object" then

        with_entries(select(.value != null))

    elif type == "array" then

        map(select(. != null))

    else

        .

    end

)

So if you had this for input:

{

    "foo": null,

    "bar": "bar",

    "biz": [1,2,3,4,null],

    "baz": {

        "a": 1,

        "b": null,

        "c": ["a","b","c","null",32,null]

    }

}

This filter would yield:

{

    "bar": "bar",

    "baz": {

        "a": 1,

        "c": ["a","b","c","null",32]

    },

    "biz": [1,2,3,4]

}

walk/1 will be added in a future version of jq so you'll have to add it. You can grab the definition here.

# Apply f to composite entities recursively, and to atoms

def walk(f):

  . as $in

  | if type == "object" then

      reduce keys_unsorted as $key

        ( {}; . + { ($key):  ($in[$key] | walk(f)) } ) | f

  elif type == "array" then map( walk(f) ) | f

  else f

  end;

[WARNING: the response below has several problems, not least those arising from the fact that 0|length is 0.]

Elaborating on an earlier answer, in addition to removing properties with null values, it's often helpful to remove JSON properties with empty array or object values (i.e., or {}), too.

ℹ️ — jq's walk() function (walk/1) makes this easy. walk() will be
available in a future version of jq (> jq-1.5), but its
definition
can be added to current filters.

The condition to pass to walk() for removing nulls and empty structures is:

walk(

  if type == "object" then with_entries(select(.value|length > 0))

  elif type == "array" then map(select(length > 0))

  else .

  end

)

Given this JSON input:

{

  "notNullA": "notNullA",

  "nullA": null,

  "objectA": {

    "notNullB": "notNullB",

    "nullB": null,

    "objectB": {

      "notNullC": "notNullC",

      "nullC": null

    },

    "emptyObjectB": {},

    "arrayB": [

      "b"

    ],

    "emptyBrrayB": 

  },

  "emptyObjectA": {},

  "arrayA": [

    "a"

  ],

  "emptyArrayA": 

}

Using this function gives the result:

{

  "notNullA": "notNullA",

  "objectA": {

    "notNullB": "notNullB",

    "objectB": {

      "notNullC": "notNullC"

    },

    "arrayB": [

      "b"

    ]

  },

  "arrayA": [

    "a"

  ]

}