tinlyx's questions

Às vezes, preciso escrever strings JSON contendo um valor de string que é, em si, uma string JSON. Por exemplo, no seguinte objeto JSON:

echo '{"rec" : " {\"id\": 1, \"name\": \"x\"}" }' | jq .

{
  "rec": " {\"id\": 1, \"name\": \"x\"}"
}

o valor em "rec"é um json em formato de string {\"id\": 1, \"name\": \"x\"}".

É tedioso escrever essas strings JSON com escape, pois é preciso escapar cada aspa dupla "para \".

Minha pergunta é:

Dado o conteúdo { "id": 1, "name": "x"}, existe uma maneira automática usando bash/jq para escapar corretamente as aspas e fazer com que o formato entre aspas possa ser usado como um valor de string JSON "{\"id\": 1, \"name\": \"x\"}"?

Acabei de ver um exemplo de uso echopara colocar várias coisas no pipeline (para jq).

echo '{"A": {"a": 1}}' '{"A": {"b": 2}}' '{"B": 3}' |\
  jq --slurp 'reduce .[] as $item ({}; . * $item)'

Se bem entendi, isso parece colocar três objetos no pipeline de um lado e, do outro, jqrecebê-los e colocá-los em um array e reduzi-lo com um operador de mesclagem.

Isso é surpreendente para mim e não tenho certeza de como funciona ter várias coisas no arquivo stdin.

Mais especificamente, como o sistema sabe que a entrada é de três arquivos e onde cada arquivo começa/termina?

Se eu apenas fizer a parte echo echo '{"A":1}' '{"A": {"b": 2}}' '{"B": 3}', a saída não parece ter nenhum delimitador visível entre os três objetos:

{"A":1} {"A": {"b": 2}} {"B": 3}

As aspas simples têm alguns efeitos especiais que informam ao próximo filtro ( jq) os limites? Ou como jq conhece os limites?

(Isso é com Ubuntu 24.04, jq 1.7.1)

Em jqscripts, eu precisava criar objetos json usando pares de valores de caminho (que são mais gerais do que os antigos pares de valores-chave). Ou seja, em vez de uma chave, preciso utilizar um caminho, para que o valor seja criado em um nível mais profundo. (Esses caminhos são fornecidos externamente, então não os conheço antecipadamente.)

Por exemplo, em pseudocódigo que não funciona, gostaria de usar caminhos para criar um objeto como este:

jq -n '{"a"."x" : 3, "b"."y" : 4}'

para que ele crie o mesmo objeto json que jq -n '{"a":{"x" : 3}, "b":{"y" : 4}}', ou seja,

{
  "a": {
    "x": 3
  },
  "b": {
    "y": 4
  }
}

De certa forma, isso é semelhante ao mdir -pque permite criar diretamente um diretório de destino com todos os diretórios ancestrais ao longo do caminho. Mas preciso fazer isso para (muitos) objetos JSON. Daí a pergunta:

Qual é a maneira mais simples de criação de objetos por pares caminho-valor usando jq nativo (talvez mais algum bash)?

(Estou procurando uma solução de baixa complexidade sem programação séria. Isso é com jq-1.7.1. no Ubuntu 24.04 LTS)

-- Esclarecimento --

A entrada que tenho em mente é uma lista de caminhos mais uma lista de valores, como:

[".a.x", ".b.y"] 

e

[3, 4]

. O caminho é separado por pontos. Para simplificar, presumo que cada parte entre os pontos seja um identificador simples como y(não um identificador complexo como "y.z"). Ou seja, não considero (por enquanto) caminhos como:

[".a.x", ".b.\"y.z\""]

Eu queria usar jq para obter um valor específico bde dois caminhos possíveis ( e apenas esses dois ). Então, basicamente, eu queria dizer

jq '(path1 OR path2) | .b'

que deve funcionar se bestiver em um dos dois caminhos path1ou path2. Se ambos os caminhos tiverem b, o primeiro caminho terá precedência.

Por exemplo, ambos

echo '{"b":2}' | jq '.b'
echo '{"a": {"b":2}}' | jq '.a.b'

extrair bem .e .a.

Posso de alguma forma dizer

echo ... | jq '(MAGIC).b'

para fazê-lo funcionar para ambas as entradas acima?

O que tentei até agora é usar o operador recursivo ..:

jq '[..|.b?|values]|first'

Isso funciona em ambos:

echo '{"b":2}' | jq '[..|.b?|values]|first'
echo '{"a": {"b":2}}' | jq '..|.b?|values|first'

dar 2. Mas não é específico o suficiente e também permite bestar em qualquer lugar da árvore abaixo .. Também é difícil de ler. Além disso, pode não funcionar se os dois caminhos não estiverem relacionados entre pais e filhos.

(Isto é com jq 1.7 no Ubuntu 24.04 LTS)

Eu uso o wget, rsynce curlpara baixar arquivos regularmente (via https ou ssh). Um problema quando viajo é que servidores de acesso rápido em uma região tornam-se lentos (ou até inacessíveis) em outra. Minha estratégia atual é usar espelhos e mudar para espelhos locais para cada região.

Eu queria saber se existem ferramentas de linha de comando Unix que permitem baixar um arquivo de vários espelhos como fonte. Os espelhos não precisam ser usados ​​em paralelo. Eles são usados ​​como backups, e o mais rápido é usado se a conexão for perdida.

A linha de comando deve ser semelhante a:

xxget url1 url2 

-- Atualizar --

Conforme apontado pela resposta aceita, a documentação do aria2c possui um exemplo que faz exatamente isso:

Download from 2 sources:

$ aria2c http://a/f.iso ftp://b/f.iso

Estou tentando exportar todos os valores de uma lista redis usando redis-clicomo uma lista de strings em scripts de shell. No entanto, existem alguns textos indesejados dos quais não consegui me livrar.

Para a seguinte lista q1:

redis:6379> 5 lpush q1 "{\"id\":1}"
(integer) 1
(integer) 2
(integer) 3
(integer) 4
(integer) 5
redis:6379> 

Se eu exportar diretamente usando LRANGE, o resultado terá um número de linha e um parêntese no início de cada linha (que precisa ser removido).

:/# redis-cli -h redis LRANGE q1 0 -1
1) "{\"id\":1}"
2) "{\"id\":1}"
3) "{\"id\":1}"
4) "{\"id\":1}"
5) "{\"id\":1}"

Se eu usar redis-cli --csv, haverá uma vírgula entre os valores (que precisa ser removida):

:/# redis-cli -h redis --csv LRANGE q1 0 -1
"{\"id\":1}","{\"id\":1}","{\"id\":1}","{\"id\":1}","{\"id\":1}"

Como posso fazer o redis exportar apenas os valores da lista, um em cada linha?

Instalei recentemente uma VM alpine-3.17 usando o virtualbox 7. Também instalei as adições de convidados e sou capaz de mapear pastas compartilhadas. Mas parece que não consigo copiar e colar do sistema operacional host.

Copiei alguns comandos no sistema operacional host (Ubuntu 22.04) e tentei colá Ctrl-Shift-V-lo no terminal alpino (a imagem mínima sem GUI). Mas nada é colado. Também tentei algumas outras combinações de teclas e tentei resolver o problema instalando e executando o bash. Mas mesmo assim não está aceitando colar.

Como habilitar copiar e colar para a linha de comando alpine Linux?

(Posso instalar uma GUI se for necessário).

Ao tentar converter json para csv, recebo um erro sobre null com a seguinte jqconsulta:

printf "[]" | jq -r '(map(keys) | add | unique) as $cols | map(. as $row | $cols | map($row[.])) as $rows | $cols, $rows[] | @csv'

Dá o seguinte erro,

jq: error (at <stdin>:0): Cannot iterate over null (null)

mas funciona bem se o array json não estiver vazio e tiver um objeto nele:

$ printf '[{"a":1}]' | jq -r '(map(keys) | add | unique) as $cols | map(. as $row | $cols | map($row[.])) as $rows | $cols, $rows[] | @csv'
"a"
1

A jqgramática parece ótima, mas não estou familiarizado com ela, pois comecei a usar essa ferramenta.

Alguém pode explicar como corrigir a consulta para não produzir nada quando a matriz estiver vazia? (primeiro exemplo).

Existe uma maneira de deixar o terminal mostrar a sequência de escape bruta? (por exemplo, aqueles usados ​​para controlar a cor)

Me deparei com esta pergunta do UNIX.SE e quero filtrar a saída "vermelha" ( Filtrar saída do comando por cor )

No entanto, os comandos nas respostas não funcionam para minha saída (por exemplo, o vermelho git statuspara "Arquivos não rastreados"). Eles funcionam para os exemplos lá echo -e '\033[00;31mtest\033[00m' | grep --color=none '[[:cntrl:]]'. A filtragem com grep --color=none '[[:cntrl:]]'funciona na minha saída, mas também mostra texto com outras cores.

Acho que o vermelho que vejo deve ser um vermelho diferente de \e[31m.

Existe uma maneira de permitir que o terminal produza sequências de escape brutas? (para que eu possa usar a sequência correta para filtrar a cor vermelha específica que vejo)

(bash, Ubuntu 18.04)

-- Atualizar --

Para esclarecimento, minha pergunta é sobre como mostrar a sequência de escape bruta.

A resposta do @egmont usando scriptfuncionou. Basicamente, eu só precisava usar scriptpara gravar a saída e usar uma das respostas da pergunta acima para encontrar o texto de cor vermelha, por exemplo:

script /tmp/a.txt
git status
exit
cat /tmp/a.txt | grep -Eo $'\e\\[31m[^\e]*\e\\[[03]?m'

A outra resposta / comentários também estão corretos ao apontar que meu uso de gitnão obteve a cor através do tubo.