Using the library like the cmdline about gojq HOT 6 CLOSED

What you are doing is giving the JSON as a string input. You need to decode to an interface.

	var input interface{}
	json.Unmarshal([]byte(`[{"how":"does", "this":"work"},{"how":"does", "this":"work"}]`), &input)

from gojq.

@itchyny thanks, sorry it took long to reply, I overlooked that the interface{} was in fact just that (the new output with your edit in tester.json:)

map[string]interface {}{"how":"does", "this":"work"} map[string]interface {}{"how":"does", "this":"work"}

I was trying to create a newline delimited JSON from an array that I'm GETting. I think this package is beyond my abilities at the moment.

EDIT: this question can be closed

from gojq.

You don't need to use gojq.

package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	var input []interface{}
	json.Unmarshal([]byte(`[{"how":"does", "this":"work"},{"how":"does", "this":"work"}]`), &input)
	for _, x := range input {
		xs, _ := json.Marshal(x)
		fmt.Println(string(xs))
	}
}

from gojq.

Thank you @itchyny! That's really nice of you. I didn't think of using the interface, that helps make it more generic (which is why I was looking at gojq for an implementation of an iterator). I ended up doing this:

	var ndJSONMarshalled []byte
	var arrayOfStrings []string
	var input []interface{}
	err := json.Unmarshal([]byte(body), &input)
	if err != nil {
		..
	}
	for _, line := range input {
		s, err := json.Marshal(line)
		if err != nil {
			..
		}
		arrayOfStrings = append(arrayOfStrings, string(s))
	}
	newLineJSONString := strings.Join(arrayOfStrings, "\n")
	newLineJSONBytes, err := ioutil.ReadAll(strings.NewReader(newLineJSONString))
	if err != nil {
		..
	}
	ndJSONMarshalled = append(ndJSONMarshalled, newLineJSONBytes...)
	// ioutil.WriteFile("tester.json", ndJSONMarshalled, 0644)

It works but it feels inefficient because I'm switching from strings to []byte so many times.

from gojq.

1. You don't need to ioutil.ReadAll(strings.NewReader to convert a string to bytes. Just []byte(str). Still allocation occurs though.
2. strings.Join is inefficient than using strings.Builder.
3. Anyway, building the JSON string (or bytes) allocates successive memory. You can write to the file using json.NewEncoder.

package main

import (
	"encoding/json"
	"log"
	"os"
)

func main() {
	body := []byte(`[{"how":"does", "this":"work"},{"how":"does", "this":"work"}]`)
	f, err := os.Create("test.json")
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()
	var input []interface{}
	if err := json.Unmarshal(body, &input); err != nil {
		log.Fatal(err)
	}
	enc := json.NewEncoder(f)
	for _, x := range input {
		if err := enc.Encode(x); err != nil {
			log.Fatal(err)
		}
	}
}

Good luck.

from gojq.

Thank you so much! You're a hero! I'm going to investigate how this works.

from gojq.