How can I edit this JSON file with bash script and jq

The following jq expression applies the transformation to each element of the top-level array (you only have a single element in that array in the question). The transformation involves building a new array from the given keys and values by replacing the value of the most recently added key+value with the value for the element being added to the end. This creates an array of length n+1 (where n is the number of keys and values in the original array element) where the first value is the value that should be discarded, 11.11.11.11 in the question, and where the last key is the key that should be discarded, host5 in the question. With .[1:-1] (which could also be written del(first,last)) we discard the first and last elements and are left with a list of n-1 keys and values.

jq 'map(to_entries | reduce .[] as $a ([{}]; last.value = $a.value | . += [$a]) | .[1:-1] | from_entries)' file

Here's the jq expression on its own, in an easier-to-read format:

map(
  to_entries |
  reduce .[] as $a (
    [{}];
    last.value = $a.value |
    . += [$a]
  ) |
  del(first, last) |
  from_entries
)

Given the following JSON document in file,

[
  {
    "host0": "11.11.11.11",
    "host1": "22.22.22.22",
    "host2": "33.33.33.33",
    "host3": "44.44.44.44",
    "host4": "55.55.55.55",
    "host5": "66.66.66.66"
  },
  {
    "server0": "Atlantis",
    "server1": "Gotham",
    "server2": "Rivendell",
    "server3": "Asgard",
    "server4": "Hogwarts",
    "server5": "Neverland"
  }
]

... the jq command would produce the following:

[
  {
    "host0": "22.22.22.22",
    "host1": "33.33.33.33",
    "host2": "44.44.44.44",
    "host3": "55.55.55.55",
    "host4": "66.66.66.66"
  },
  {
    "server0": "Gotham",
    "server1": "Rivendell",
    "server2": "Asgard",
    "server3": "Hogwarts",
    "server4": "Neverland"
  }
]

Note that there is no interpretation of the key or value strings.

Script that uses jq and edits the file:

#!/bin/sh
set -eu

jq '[.[] | to_entries[1:] | map(.key |= sub("(?<n>\\d+)$";"\((.n|tonumber)-1)")) | from_entries]' "$1" > "$1.tmp"
mv "$1.tmp" "$1"

Usage:

$ cat config.json
[{
  "host0": "11.11.11.11",
  "host1": "22.22.22.22",
  "host2": "33.33.33.33",
  "host3": "44.44.44.44",
  "host4": "55.55.55.55",
  "host5": "66.66.66.66"
}]

$ ./script.sh config.json

$ cat config.json
[
  {
    "host0": "22.22.22.22",
    "host1": "33.33.33.33",
    "host2": "44.44.44.44",
    "host3": "55.55.55.55",
    "host4": "66.66.66.66"
  }
]

The formatting changes a bit, but that shouldn't be a problem.

If you want to preserve formatting, or would like to use standard unix tools, using awk instead of jq is also possible, but way less robust:

awk -F\" 'BEGIN{OFS=FS} $2=="host0"{next} $2~/^host/{$2="host" substr($2,5)-1} 1' "$1" > "$1.tmp"

If javascript is allowed:

The idea beyond this, it's there's already a dedicated language to parse json as built-in aka
JavaScript Object Notation =)

#!/bin/sh

node -e '
    function renameKey (obj, oldKey, newKey) {
      obj[newKey] = obj[oldKey];
      delete obj[oldKey];
    }
    var j = require("./file.json"); // mandatory ./
    delete j[0]["host0"];
    let count = Object.keys(j[0]).length;
    for (let i = 0; i < count; i++) {
        let oldv = "host"+(i+1);
        let newv = "host"+i;
        renameKey(j[0], oldv, newv)
    }
    console.log(JSON.stringify(j, null, 4))
'

or

#!/bin/sh

node -p '
    JSON.stringify(
        require("./file.json")
        .map(x => {
            let ok;
            for (const [k, v] of Object.entries(x)) {
                if (ok)
                    x[ok] = v;
                ok = k;
            }
            delete x[ok];
            return x;
        })
        , null
        , 4
    )
'

Credits for emanuele6 from [email protected].

Output

[
  {
    "host0": "22.22.22.22",
    "host1": "33.33.33.33",
    "host2": "44.44.44.44",
    "host3": "55.55.55.55",
    "host4": "66.66.66.66"
  }
]

Another way, using rhino:

$ dpkg -s rhino
Installed-Size: 55
[...]
Description: JavaScript engine written in Java
 Rhino is an implementation of the JavaScript language written
 entirely in Java. It is typically embedded into Java applications to
 provide scripting to end users.
Original-Maintainer: Debian Java Maintainers <[email protected]>
Homepage: http://www.mozilla.org/rhino/

(hacky way, not to use in production)

rhino -e "
function renameKey (obj, oldKey, newKey) {
  obj[newKey] = obj[oldKey];
  delete obj[oldKey];
}
j = $(< file.json); // shell hack to read file without import fs lib
delete j[0]['host0'];
let count = Object.keys(j[0]).length;
for (let i = 0; i < count; i++) {
    let oldv = 'host'+(i+1);
    let newv = 'host'+i;
    renameKey(j[0], oldv, newv)
}
print(JSON.stringify(j, null, 4))
"

Using Raku (formerly known as Perl_6)

~$ raku -e 'my @json = lines[1..*-2]>>.split(/ <[:,]> /, :skip-empty); put qb[\[\{];  \
            @json = join ",\n", ([Z] @json[0..*]>>.[0], @json[1..*]>>.[1])>>.join(":");  \
            .put for @json; put qb[\}\]];'   file 

I hesitate to write this answer, but seems to me the OP might run into sorting errors. It's great that the jq answers already posted appear to maintain the input order, but at least one StackOverflow post says that's not guaranteed. From RFC_8259 :

> An object is an unordered collection of zero or more name/value   
> pairs, where a name is a string and a value is a string, number,   
> boolean, null, object, or array.

Above, the Raku code takes a literal approach to the text, reading lines into an array while [1..*-2] dropping the first and last bracketing lines (adjust this index if your JSON formatter places brackets/braces on 2 lines instead of one). Each line is split on <[:,]> a custom character class consisting of colon and comma, and :skip-empty empty elements are dropped. In this manner each @-array position contains two elements: host and IP.

Brackets/braces are put back in separate statements. The @json array is [Z] "zipped" together, dropping the first "IP" element (via @json[1..*]>>.[1] starting from 1.. instead of 0... Zipping stops when any item runs out of elements. Finally, colons, commas and newlines are joined back in.

Sample Input:

[{
  "host0": "11.11.11.11",
  "host1": "22.22.22.22",
  "host2": "33.33.33.33",
  "host3": "44.44.44.44",
  "host4": "55.55.55.55",
  "host5": "66.66.66.66"
}]

Sample Output:

[{
  "host0": "22.22.22.22",
  "host1": "33.33.33.33",
  "host2": "44.44.44.44",
  "host3": "55.55.55.55",
  "host4": "66.66.66.66"
}]

https://raku.org