Json key order

How to decode a JSON object into a, for instance, keyword list while preserving the same key order that the JSON string uses?

Elixir maps lose this information because of the underlaying Erlang map implementation.

According to the JSON specification, JSON objects are unordered. So if you get the same ordering, it is entirely coincidental or an implementation detail of the underlying library. But you can not rely on ordering of the entries there since they are, by specification, not ordered.

You may want to considering using a list instead if the ordering is absolutely required.


Precisely this. JSON specifies that objects are unordered but array’s are ordered, so if order is important then it should be an array, not an object.

I know specification says JSON objects are unordered but sometimes preserving the order can be useful.

Take for instances a situation where you want to read an external JSON file, apply some small changes and write it back preserving the order so to not create large diffs (the file can be under version control).

For instance in python you can do this with this code:

import json
from collections import OrderedDict
json.load(input_json, object_pairs_hook=OrderedDict)

In Elixir I am only able to write JSON objects in a custom order by using Keyword instead of Map but I haven’t find a way of reading a JSON object into a Keyword.

In jason it seems like objects are actually decoded into a list until the whole object is read and only at that moment the list is converted to a map:

But given jason seems to want to be spec compliant I’m not sure it would accept changing that.

Thanks, I am able to use this :jason implementation detail to get what I want.

It is a very far from optimal solution, surely not performant and relies on the order in which keys are decoded by Jason but it seems to work for my needs (it’s more like a script than something that should be done a lot of times per second).

I put it here just for people that may have my same requirements but I wrote it without optimizing it so be kind with your comments :smiley:

defmodule StringKeyword do
  defstruct data: []

  @spec decode!(binary) :: any
  def decode!(string) when is_bitstring(string) do
    Process.put(:key_count, 0)
    |> Jason.decode!(
      keys: fn key ->
        count = Process.get(:key_count)
        Process.put(:key_count, count + 1)
        {count, key}
    |> new()

  defp new(conf) when is_map(conf) do
    data =
      |> Map.to_list()
      |> Enum.sort_by(fn {{idx, _}, _} -> idx end)
      |> Enum.map(fn {{_, k}, v} -> {k, new(v)} end)

    %__MODULE__{data: data}

  defp new(list) when is_list(list), do: Enum.map(list, &new/1)

  defp new(value), do: value

defimpl Jason.Encoder, for: StringKeyword do
  def encode(%{data: value}, opts), do: Jason.Encode.keyword(value, opts)

defmodule Sorted do
  def run(input, output) do
    |> File.read!()
    |> StringKeyword.decode!()
    |> Jason.encode!(pretty: [indent: "    "])
    |> (&File.write!(output, &1)).()

Edited as per @LostKobrakai suggestion

How do you write the loaded json back? Wouldn’t the order of the keys be not deterministic in this step?

By using Jason.Encode.keyword/2. This function preserves the order of the Keyword in encoding it.

Why combine the data for the key into a string just to need a regex to separate it again. You can have a key like {count, key} in elixir maps.


This is exactly what I mean, I wrote this “without thinking” to much, just to see if it can work. Thanks for your suggestion!

1 Like