Daniel Kaplan's questions

Estou usando o Cygwin no Windows 10, mas também uso o Ubuntu com WSL2. Não posso reproduzir isso com o último. Quando digito man killcygwin, diz No manual entry for kill. Quando digito man /bin/kill, parece mostrar o arquivo correto, mas está imprensado entre jargões binários:

Como executo manpara visualizar esta página corretamente?

Por contexto, estou usando zsh. Toda vez que uso locate, quero passar os sinalizadores -ie .-A

Normalmente, se eu conseguir, crio um aliascom o mesmo nome do comando existente para fazer isso. Mas de acordo com esta pergunta , os aliases não podem aceitar argumentos, então eu tenho que usar uma função. Normalmente paro por aí porque a ideia de uma função com o mesmo nome de um comando parece errada para mim, embora não possa dizer por quê.

Eu estava prestes a finalmente criar tal função quando tive este pensamento: este é um padrão comum para mim, querendo sinalizar os padrões para o comando; existe uma maneira mais fácil de fazer isso? Talvez o zsh forneça uma solução melhor para esse problema?

Isso me levou a outro pensamento: é um antipadrão substituir um comando existente? Eu sempre fiz isso porque me permite pular uma associação na minha cabeça: por exemplo, "Por que não lltem uma manpágina? Ah sim: llrealmente significa ls -la. Eu preciso fazer man ls, não man ll. Etc."

Para resumir:

1. Está certo/idiomático substituir um comando existente por um alias/função?
2. O zsh ou alguma outra ferramenta fornece uma maneira mais direta de sinalizadores padrão para um comando específico?

Eu corro updatedb assim:updatedb --localpaths="/a /b"

/aé uma unidade removível. /bé o disco rígido local. Embora /anem sempre seja acessível para mim, frequentemente quero executar locatepara descobrir se tenho um determinado arquivo nele (com base na última vez que executei updatedb).

O problema é que, se eu executar updatedbquando não estiver conectado, recebo um erro:

/usr/bin/find: '/a': No such file or directory

O banco de dados obtém as informações mais recentes sobre /b, mas remove /aos dados existentes de . Existe uma maneira de manter /aos dados quando /anão está conectado durante updatedb?

Acho que isso pode ser possível com vários bancos de dados, um para /ae outro para /b. Em seguida, um script pode verificar se /aestá ou não conectado quando decide se deve ou não updatedb.

Mas a página de manual para ambos os comandos assume que eu sei muito mais do que sei (por exemplo, o que FINDOPTIONSsabe), então espero que haja uma solução mais fácil para esse problema.

Eu tive um problema em que queria encontrar o comprimento de cada caminho de um findcomando. Minha primeira tentativa foi executar algo assim:

find . -exec sh -c "echo {} | wc -c" \;

Eu tenho essa idéia desta resposta . (O comando acima não é minha pergunta, estou apenas usando-o como exemplo e é completamente artificial. Além disso, às vezes posso precisar de mais de um pipe.)

Mas quando o executei, houve erros na saída, provavelmente devido a caracteres especiais nos caminhos de saída. Infelizmente, não tenho conhecimento para solucionar quais caminhos causaram o problema e as mensagens de erro não eram informativas. Sem considerar...

Mais tarde, tropecei nesta resposta :

O findcomando executa o comando diretamente. O comando, incluindo o argumento do nome do arquivo, não será processado pelo shell ou qualquer outra coisa que possa modificar o nome do arquivo. É muito seguro.

Isso parece muito conveniente. Tão conveniente, de fato, que a -exec sh -c ..."cura" parece pior que a doença.

Então, minha pergunta é: o que devo fazer quando preciso canalizar comandos finde meus caminhos podem ter caracteres especiais? Existe uma solução genérica para este problema onde eu não tenha que considerar um monte de ressalvas? Estou usando bash.

Nota: Esta é uma pergunta semelhante: qual a melhor forma de enviar a saída de um comando find + exec para um pipeline? A diferença é que não estou necessariamente tentando canalizar a saída para fora do -exec. ou seja, se find ... -exec ... foo {} | bar \;é o caminho a seguir, está perfeitamente bem para mim. Estou apenas procurando um caminho genérico de menor resistência, a estrutura do comando não é importante para mim.

Com o bash, estou executando isto: declare -p | grep 'declare -- 'Isso imprime linhas inteiras. Quero imprimir essas mesmas linhas, mas queria excluir a correspondência em si. ou seja, posso fazer ... | grep pattern | sed 's/pattern//'como um único comando? Seria como o oposto da -oopção.

Meu comando gera isso:

...
declare -- MAX_CONNECTIONS_PER_SERVER="6"
declare -- OPTERR="1"
declare -- OSTYPE="linux-gnu"
...

Mas eu quero produzir isso:

...
MAX_CONNECTIONS_PER_SERVER="6"
OPTERR="1"
OSTYPE="linux-gnu"
...

Normalmente, eu apenas canalizaria isso para sed, mas coincidentemente, eu queria fazer isso duas vezes hoje. Eu olhei para a página de manual, mas não vi nenhuma opção que pudesse fazer isso.

Retornar apenas a parte de uma linha após um padrão de correspondência é uma pergunta muito semelhante. Talvez seja até uma duplicata. Pode-se argumentar que o meu é um pouco mais estreito: é garantido que o padrão que estou grepping e o padrão que estou removendo serão os mesmos. Eu quero remover x. A questão quer remover .*x.

Estou trabalhando em um script e realmente me ajudaria, nesse contexto, se eu pudesse ver um dump de todos os nomes e valores de variáveis ​​definidas pelo script. Aqui está um exemplo:

foo="1"
bar="2"

print_script_variables 

baz="3"

print_script_variables 

Isso geraria:

foo="1"
bar="2"

foo="1"
bar="2"
baz="3"

Existe algo como print_script_variables? Tenho a sensação de que analisar os scripts que você está executando é uma tarefa tola.

Se isso não existir, eu apenas digitaria um monte de echocomandos à mão. Isso é meio chato, porque eu gostaria de mudar para onde coloco print_script_variablesenquanto soluciono problemas sem ter que me preocupar com quais variáveis ​​entram e saem do escopo.

Este é um script bash, mas eu uso zsh no meu terminal, então algo que funcionasse em ambos seria o ideal.

Eu tenho um arquivo com uma estrutura assim:

M: a
M: b
Player: c
M: d
Sequencer.Play( SpineAnimation(foo, speaker)@0 )
Player: e
M: f
Sequencer.Play( SpineAnimation(bar, speaker)@0 )
...

Como faço para converter isso em um arquivo como este:

M: a
M: b
Player: c
M foo: d
Player: e
M bar: f
...

Em outras palavras, se a próxima linha tiver Sequencer.Play( SpineAnimation(..., quero pegar a palavra depois dela e colocá-la antes dos dois pontos na linha atual.

Não tenho certeza de qual seria a melhor ferramenta para isso, estou pensando awk, mas, novamente, acho que será muito complicado com essa ferramenta. Estou aberto a usar qualquer comando para fazer isso. Eu tentei fazer algo como a resposta aqui: Mesclar duas linhas em uma, escolhendo palavras selecionadas de ambas. Mas essa pergunta não parece trivialmente diferente porque a Sequencer.Playlinha nem sempre está lá.

Eu tenho esses dados JSON que se parecem com isso:

[
  {
    "loginId": "7638749",
    "customerprofileDetails": {
      "securityQuestions": [
        "What is your favorite sports team?",
        "What is your favorite song?",
        "Who is your favorite artist?"
      ]
    }
  }
]

Eu tenho um script onde passo esse arquivo como o primeiro argumento. O script fica assim:

for json in `cat $PWD/$1 | jq -cr '.[]'` ; do
    echo "$json"
done

Por algum motivo, quando executo este script, ele gera isso:

> fileFromJson.sh tmp2.json
{"loginId":"7638749","customerprofileDetails":{"securityQuestions":["What
is
your
favorite
sports
team?","What
is
your
favorite
song?","Who
is
your
favorite
artist?"]}}

Por que essas novas linhas estão lá e o que está causando esse problema? Quando eu apenas executo cat $PWD/tmp2.json | jq -cr '.[]', ele imprime em uma linha. Estou usando o MacOS se isso importa.

Eu tenho um arquivo que se parece com isso:

[
  {
    "billingAccountNumber": "x",
    "paymentResponseObject": {
      "uiErrorDipslayMessage": "",
      "transactionStatus": "S",
      "transactionDescription": "",
      "transactionCode": "",
      "confirmationNumber": "1"
    }
  },
  {
    "billingAccountNumber": "y",
    "paymentResponseObject": {
      "uiErrorDipslayMessage": "",
      "transactionStatus": "S",
      "transactionDescription": "",
      "transactionCode": "",
      "confirmationNumber": "2"
    }
  },
  {
    "billingAccountNumber": "z",
    "paymentResponseObject": {
      "uiErrorDipslayMessage": "",
      "transactionStatus": "S",
      "transactionDescription": "",
      "transactionCode": "",
      "confirmationNumber": "3"
    }
  }
]

Os dados não são exatamente assim, e eu tenho mais de três elementos. A partir desses dados, quero criar três arquivos: x.json, y.json, e z.json. Eu quero que o conteúdo de cada um desses arquivos seja o conteúdo do arquivo paymentResponseObject.

Existe uma maneira de fazer isso com jq? Eu descobri como fazer isso em awk, mas é muito desajeitado e quero repetir esse processo com esquemas diferentes. Eu tenho que reescrever 80% do awkscript para cada esquema.

Eu tenho um grupo de arquivos json. Cada arquivo contém um objeto json e todos eles têm o mesmo esquema. Existe um campo no json para o qual quero renomear o arquivo. Como eu posso fazer isso?

Eu cheguei a esta solução:

find . -name '*.json' | xargs -i mv {} $(cat {} | jq '.billingAccountList[0]' | tr -d \").json

Mas não funciona, pois catestá tentando interpretar o {}. Eu esperava que os xargs o interpretassem. Dá-me este erro:

cat: {}: No such file or directory