Encoding Large Data Streams with MarshalJSON without Loading All Objects in Memory

Wanting to encode a large stream of data using json.Encoder without loading all of it into memory at once is a common problem. Unfortunately, the encoding/json package does not provide direct support for this.

Current Workaround

The current solution, as you mentioned, is to manually build the JSON string yourself. This involves writing the JSON structure piece by piece, as data becomes available from the stream. This is an efficient approach, but it can be tedious and error-prone.

Proposed Patch

To improve this process, one could modify the encoding/json package. Specifically, the reflectValueQuoted function in encoding/json/encode.go could be modified to handle channels like arrays. This would enable direct streaming of data from channels into the JSON output.

Here's a proposed change to the Array case in reflectValueQuoted:

case reflect.Array:
    e.WriteByte('[')
    n := v.Len()
    for i := 0; i  0 {
            e.WriteByte(',')
        }
        e.reflectValue(v.Index(i))
    }
    e.WriteByte(']')

// Add the following case for channels:
case reflect.Chan:
    e.WriteByte('[')
    i := 0
    for {
        x, ok := v.Recv()
        if !ok {
            break
        }
        if i > 0 {
            e.WriteByte(',')
        }
        e.reflectValue(x)
        i  
    }
    e.WriteByte(']')

Benefits of the Patch

This patch would make it much easier to encode large data streams without loading all objects into memory. It would also eliminate the need for manual string concatenation, reducing the risk of errors and improving code readability.

Conclusion

Although the proposed patch is not part of the current encoding/json package, it demonstrates a potential improvement that could make streaming JSON data more efficient and convenient.