Perguntas[sort](unix)

Eu tenho esse arquivo

1  you
3  me
2  their
4  us

este pipe funciona bem (ele ordena a primeira coluna por número, a segunda por letras) é um pipe de outro usuário encontrado aqui

paste <(awk '{print $1}' file.txt | sort -k1n) <(awk '{print $2}' \
file.txt | gsort -V)

mas agora use uma palavra com espaços

1  "and me"
3  me
2  their
4  us

O mesmo comando produz isso

1   me
2   their
3   us
4   "and

Como produzir um resultado como esse?

1   and me
2   their
3   us
4

Eu tentei:

• remover número 4

• use "e eu"

• use 'e eu'

Mas me dê o resultado incorreto

Com esta linha de comando vejo os processos e o uso da ram no mb

ps aux | awk '{print $6/1024 " MB\t\t" $11}' | ordenar -rn|menos

O problema é o tipo

9.95703 MB      /usr/lib/systemd/systemd-journald
9.89062 MB      /usr/sbin/winbindd
9.76953 MB      /usr/sbin/winbindd
9.69922 MB      php-fpm:
9.69922 MB      php-fpm:
9.69531 MB      php-fpm:
9.69531 MB      php-fpm:
9.69531 MB      php-fpm:
93.4297 MB      db_arc1_FREE
9.31641 MB      winbindd:
9.31641 MB      /usr/sbin/snmpd

Como classificar corretamente para que a saída fique assim?

93.4297 MB      db_arc1_FREE
9.95703 MB      /usr/lib/systemd/systemd-journald
9.89062 MB      /usr/sbin/winbindd
9.76953 MB      /usr/sbin/winbindd
9.69922 MB      php-fpm:
9.69922 MB      php-fpm:
9.69531 MB      php-fpm:
9.69531 MB      php-fpm:
9.69531 MB      php-fpm:
9.31641 MB      winbindd:
9.31641 MB      /usr/sbin/snmpd

Eu esperaria que o -gsinalizador diga sortpara tratar os campos como números de ponto flutuante, mas:

cat << EOF | sort -g -k1,2
0 0
0 1.0
0 .5 
0 5.0
EOF

dá

0 0
0 1.0
0 .5 
0 5.0

Portanto the .5não é tratado como um 0.5. Este é um bug conhecido ou o quê?

ps: não estou pedindo solução alternativa, já resolvi comsed

Eu tenho um arquivo muito grande que desejo classificar em ordem alfabética. É um arquivo separado por tabulações, mas eu realmente preciso ter certeza de que o arquivo está classificado começando pelo primeiro caractere da linha, independentemente de ser espaço ou qualquer outra coisa.

Exemplo do arquivo de entrada:

2090802 V19 I must be the third in the group 
20908 02    V18 I must be the first in file, as col 1 is another value
2090802 V17 I must be the second in the group 
2090802 V16 I must be the first in the group of 2090802

Com o comando sort test.txt > test-s.txtobtenho esta saída:

2090802 V16 I must be the first in the group of 2090802
2090802 V17 I must be the second in the group 
20908 02    V18 I must be the first in file, as col 1 is another value
2090802 V19 I must be the third in the group 

Parece que o programa de classificação vê a primeira coluna com o mesmo valor (ignorando o espaço na linha 3) e classifica o arquivo usando a próxima (V16, V17, V18 e V19).

Porém, quero que o valor 20908 02seja considerado distinto e meu resultado esperado deve ser este:

20908 02    V18 I must be the first in file, as col 1 is another value
2090802 V16 I must be the first in the group of 2090802
2090802 V17 I must be the second in the group 
2090802 V19 I must be the third in the group 

Tentei com o -bargumento, e também -tdar outro separador, mas ainda não obtive o resultado desejado.

Como posso classificar o arquivo considerando cada caractere da linha, sem ignorar os espaços em branco?

Estou acompanhando a configuração de algum sistema no formato JSON em um sistema de controle de revisão.

Infelizmente, essa configuração é recuperada usando algum comando proprietário de código fechado, e a saída muda de uma execução para a próxima, pois a ordem nos objetos e matrizes é mais ou menos aleatória.

Uma vez, ele produzirá:

{
  "fru": [
    {
      "name": "foo",
      "attr": [
         {"name": "colour", "value": "blue"},
         {"name": "length", "value": 12}
      ]
    },
    {
      "name": "bar",
      "attr": [
         {"name": "colour", "value": "red"},
         {"name": "length", "value": 1}
      ]
    }
  ],
  "tags": ["x", "y"]
}

E da próxima vez:

{
  "tags": ["y", "x"],
  "fru": [
    {
      "name": "bar",
      "attr": [
         {"name": "length", "value": 1},
         {"name": "colour", "value": "red"}
      ]
    },
    {
      "name": "foo",
      "attr": [
         {"name": "colour", "value": "blue"},
         {"name": "length", "value": 12}
      ]
    }
  ]
}

Isso significa que, do ponto de vista de git diff, tudo muda de uma execução para outra, mesmo que seja exatamente o mesmo sistema.

Em todas as matrizes, a ordem não é relevante. A ordem também não importa nos atributos dos objetos. Então, se eu pudesse pós-processar essa saída para que os objetos e arrays tivessem seus atributos e membros em uma ordem consistente, eu garantiria que a saída não mudaria quando o sistema não mudasse e as mudanças vistas por git diffseriam mais provavelmente refletirá as mudanças no sistema.

jq -Sme ajuda bastante:

• classificando atributos dentro de objetos
• colocar atributos de objetos separados e membros da matriz em linhas separadas ( git diffé baseado em linhas).

Para o exemplo acima, isso me dá:

{
  "fru": [
    {
      "attr": [
        {
          "name": "colour",
          "value": "blue"
        },
        {
          "name": "length",
          "value": 12
        }
      ],
      "name": "foo"
    },
    {
      "attr": [
        {
          "name": "colour",
          "value": "red"
        },
        {
          "name": "length",
          "value": 1
        }
      ],
      "name": "bar"
    }
  ],
  "tags": [
    "x",
    "y"
  ]
}

E:

{
  "fru": [
    {
      "attr": [
        {
          "name": "length",
          "value": 1
        },
        {
          "name": "colour",
          "value": "red"
        }
      ],
      "name": "bar"
    },
    {
      "attr": [
        {
          "name": "colour",
          "value": "blue"
        },
        {
          "name": "length",
          "value": 12
        }
      ],
      "name": "foo"
    }
  ],
  "tags": [
    "y",
    "x"
  ]
}

Isso é melhor, mas ainda não está lá, pois os arrays não estão classificados (compreensivelmente).

Observe que o arquivo da vida real é mais complexo com arrays contendo outros arrays de objetos contendo mais arrays...

Meu pensamento para resolver isso é classificar todas as matrizes, começando pelas mais profundas com base na representação da string JSON dos valores, por exemplo, .fru[0].attrclassificada com {"name": "colour", "value": "blue"}antes {"name": "length", "value": 12}porque a {"name":"colour","value":"blue"}string é classificada antes do comprimento um e, em seguida, a .frumatriz classificada com fooantes barporque {"attr":[..."blue"...(com o attratributo movido antes nameem ordem alfabética) é classificado antes {"attr":[..."red"....

Posso obter os caminhos de todos os arrays, primeiro a profundidade com:

$ jq -c '[paths(arrays)]|reverse' a
[["tags"],["fru",1,"attr"],["fru",0,"attr"],["fru"]]

Posso classificar uma matriz com base na representação da string JSON de seus membros com:

jq '.array|=sort_by(tojson)'

Mas como combinar os dois para aplicar o segundo a todos os arrays retornados pelo primeiro?

Ou existe uma maneira melhor de pós-processar esse JSON para que o pedido permaneça consistente?

Se jqnão for a melhor ferramenta para isso, ficarei feliz em considerar os módulos perldo JSONou os equivalentes Ruby/python.

Estou no Ubuntu 22 e tenho uma grande árvore de arquivos com nomes irritantes que incluem valores numéricos em várias posições. Algo como:

./2
./2/9
./2/10
./2/8
./1
./1/2
./1/1
./1/11
./11
./11/page 6
./11/page 05
./11/page 4

Quero classificar isso de acordo com os valores numéricos, ignorando qualquer coisa como 'página', para obter:

./1/1
./1/2
./1/11
./2/8
./2/9
./2/10
./11/page 4
./11/page 05
./11/page 6

Eu tentei sort -n, mas mesmo olhando apenas para os nomes dos diretórios de primeiro nível, isso não parece fazer o que eu esperava:

$ find . -mindepth 1 -type d | sort -n
./1
./11
./2

Existe uma opção útil para "classificar por cada número inteiro (não dígito)"?

Estou tentando classificar um arquivo genético com base em chr (coluna 2) e posição (coluna 3) que começam de baixo para cima. minha mesa esta assim em arquivo grande

SNP CHR BP  A1  A2  effect_allele_frequency BETA    standard_error  P
rs10875231  1   100000012   T   G   0.405   -0.0456807  0.02260471  0.04335677
rs6678176   1   100000827   C   T   0.383   0.02553138  0.02287662  0.2645817
rs78590530  1   100000948   A   G   0.016   0.171376    0.08757958  0.05035017
rs149636485 1   100001060   A   G   0.004   -0.03363731 0.1819208   0.8529224

Quero ordenar CHR (de 1 a 22) de forma que a posição também comece de baixo para cima desconsiderando outras colunas e para cada chr separadamente. Eu tentei este comando de classificação

sort -t $'\t' -nk3 myfile.tsv | sort -t $'\t' -nk2  > test.txt

dá ordem em chr (coluna 2), mas não em posição (coluna 3). parece que a coluna 1 interfere:

SNP CHR BP  A1  A2  effect_allele_frequency BETA    standard_error  P
rs1000033   1   226580387   G   T   0.416   0.02958699  0.02295015  0.1971771
rs1000050   1   162736463   T   C   0.378   0.06136397  0.02293639  0.007468015
rs1000070   1   222359612   C   T   0.381   0.02563547  0.02294139  0.2638107
rs1000073   1   157255396   G   A   0.387   -0.01470793 0.02273634  0.517414
rs1000085   1   66857915    C   G   0.024   -0.03536382 0.07555889  0.6394446
rs1000127   1   63432716    C   T   0.157   0.003052272 0.03045933  0.919875

Como posso classificar pela coluna 2 e depois apenas pela 3?

Eu estava executando um comando pipe com uma seção sendo a seguinte:

sort -t $'\t'  -T . -k1,1g

Quando eu estava monitorando, htopvi isso:

Qual é a razão por trás disso? Isso significa que meu comando está errado ou há algo errado com ele htop?

Estou executando o Ubuntu 20.0.4.

Considere este conteúdo do arquivo a seguir (suponha que o arquivo tenha o nome input) ...

/zzzzz foo bar
/hij zzz
xyz abc 
/abc 
ijk lmnop
qwer tyuiop 
abc def

Se eu executar /bin/sort input, recebo a seguinte saída ...

/abc 
abc def
/hij zzz
ijk lmnop
qwer tyuiop 
xyz abc 
/zzzzz foo bar

Como você pode ver, a barra inicial é totalmente ignorada pelo algoritmo de classificação. Não há nada na sortpágina de manual que diga algo sobre as barras sendo tratadas de qualquer forma especial.

Mas se eu substituir cada uma das barras pelo $caractere, esse comportamento não ocorre. Por exemplo, suponha que um arquivo nomeado newinputcontém esses valores ...

$zzzzz foo bar
$hij zzz
xyz abc 
$abc 
ijk lmnop
qwer tyuiop 
abc def

Em outras palavras, newinputé o mesmo que input, exceto pelo fato de que os /caracteres foram alterados para $caracteres. Quando eu faço /bin/sort newinput, eu recebo esses resultados ...

$abc 
$hij zzz
$zzzzz foo bar
abc def
ijk lmnop
qwer tyuiop 
xyz abc 

Como você pode ver, nesse caso, o $é realmente tratado como um caractere normal e classificável por /bin/sort.

Então, o que está acontecendo aqui? E como faço /bin/sortpara prestar atenção ao /personagem?

Desde já agradeço qualquer ideia e sugestão.

ATUALIZAÇÃO : Se eu fizer isso no Debian, a classificação funcionará corretamente, tanto em relação a quanto /a $.

Então, eu estou querendo saber se esse comportamento pode ser um "recurso" do Ubuntu.

Aqui está meu arquivo t.tsv delimitado por tabulação:

$ cat t.tsv
2022/05/05  -258.03
2022/05/07  -18.10
2022/05/09  -10.74
2022/05/09  -132.60
2022/05/12  -18.56
2022/05/12  -20.20
2022/05/17  -11.00
2022/05/17  -112.91
2022/05/17  -51.43
2022/05/17  -64.78
2022/05/18  -13.96
2022/05/18  -13.96
2022/05/18  -7.51
2022/05/19  -17.08
2022/05/20  -33.08

Estou usando a classificação do MacOS 12.4 (da página man: O utilitário de classificação é compatível com a especificação IEEE Std 1003.1-2008 (“POSIX.1”) ) para classificar primeiro por col 1 em alfa seq ascendente, depois por col2 em ascendente numérico.

$ cat t.tsv|sort --field-separator='\t' --key=1,1 --key=2,2n
2022/05/05  -258.03
2022/05/07  -18.10
2022/05/09  -10.74
2022/05/09  -132.60
2022/05/12  -18.56
2022/05/12  -20.20
2022/05/17  -11.00
2022/05/17  -112.91
2022/05/17  -51.43
2022/05/17  -64.78
2022/05/18  -13.96
2022/05/18  -13.96
2022/05/18  -7.51
2022/05/19  -17.08
2022/05/20  -33.08

Estou perplexo por que a segunda coluna não está sendo classificada em sequência numérica crescente quando a primeira coluna é a mesma. Numerosas respostas SE para essa mesma pergunta dizem que (a) você especifica colunas únicas como --key=1,1, e (b) você pode aplicar opções como -ndefinições de chave individuais como --key=2,2n.

Atualização: devo mencionar que meu shell é bash.