
Descobri que para procurar o tamanho do arquivo em bytes, uso 'c'.
Assim, posso procurar o tamanho do arquivo com 1000 bytes usando: find . -tamanho 1000c
Mas e quanto a diferentes tipos de tamanho, como Mb, Gb ou até bits? Que caracteres ou letras preciso usar?
Responder1
POSIXespecifica apenas nenhum sufixo ou um c
sufixo. Sem sufixo, os valores são interpretados como blocos de 512 bytes; com um c
sufixo, os valores são interpretados como contagens de bytes, conforme você determinou.
Algumas implementações suportam mais sufixos; por exemploGNUfind
apoia
b
para blocos de 512 bytesc
para bytesw
para palavras de 2 bytesk
para kibibytesM
para mebibytesG
para gibibytes
Responder2
find . -size 1000c # files whose size¹ is exactly 1000 bytes (not characters)
find . -size -1000c # strictly less than 1000 bytes (0 - 999)
find . -size +1000c # strictly more than 1000 bytes (1001 - ∞)
Então, usando sh
a sintaxe POSIX, você pode fazer:
EiB=$((1024*(PiB=1024*(TiB=1024*(GiB=1024*(MiB=1024*(KiB=1024)))))))
EB=$((1000*( PB=1000*( TB=1000*( GB=1000*( MB=1000*( kB=1000)))))))
find . -size "$(( 12 * GiB ))c" # exactly 12GiB (12,884,901,888 bytes)
find . -size "$(( 12 * GB ))c" # exactly 12GB (12,000,000,000 bytes)
find . -size "-$(( 12 * GB ))c" # 0 - 11,999,9999,999 bytes
...
Sem o c
sufixo, cuidado, o comportamento pode ser surpreendente:
find . -size 1000 # files whose size, in number of 512-byte units (rounded *up*)
# is 1000. So, that's file whose size in bytes ranges from
# 1000*512-511 (999*512+1) to 512*1000
find . -size -1000 # files whose size is 999*512 bytes or less
find . -size +1000 # files whose size is 1000*512+1 bytes or more
É isso para a especificação POSIX do find
utilitário.
Agora, várias find
implementações suportam sufixos adicionais, mas cuidado, pois os mesmos sufixos podem ser interpretados de maneira diferente por implementações diferentes.
Comoanotado por @StephenKitt,GNUfind
suporta cwbkMG
byte, word, unidade de 512 bytes, kibibyte, mebibyte, gibibyte, mas se comporta como o POSIX find
exige, pois, find . -size -12G
por exemplo, não é o mesmo que o find . -size "-$((12 * GiB))c"
anterior, pois são arquivos cujo tamanho em número de gibibyte (arredondado) é estritamente menos de 12, portanto, arquivos com 11 GiB ou menos.
Por exemplo, find . -size -1G
encontra apenas arquivos vazios (arquivos de tamanho 0). Um arquivo de um byte é considerado 1GiB, pois os tamanhos são arredondados para o próximo GiB.
caixa ocupadafind
suporta cwbk
sufixos, mas os interpreta de maneira diferente do GNU find
. É tambématualmente não é compatível com POSIX para lidar com tamanhos sem sufixos.
Para ocupadobox find
,find . -size -12G
élike find . -size "-$(( 12 * GiB ))c"
e find . -size -1
é para tamanhos que variam de 0 a 511 em vez de apenas 0.
caixa de brinquedofind
(como encontrado no Android, por exemplo) se comporta como o busybox find
nesse aspecto (e também énão é compatível com POSIX). Outra diferença é que os sufixos não diferenciam maiúsculas de minúsculas e TPE
para tebibyte, pebibyte e exbibyte também são suportados e um d
sufixo adicional (decimal) pode ser usado para especificar que as unidades são potências de 1000 em vez de 1024. Por exemplo, -size 1kd
encontra arquivos que são exatamente 1000 bytes (1 kilobyte) em vez de 1024 bytes (1 kibibyte) para arquivos -size 1k
.
No toybox find
, o manuseio do sufixo é feito como parte de sua atolx()
função que não é usada apenas para find
. Observe, entretanto, que como isso suporta 0xffff
números hexadecimais, há um conflito, pois cbedCBED
também são dígitos hexadecimais. -size -0x2c
não é para menos de 0x2 bytes, mas para menos de 0x2c (44) unidades de 512 bytes. E -size 010c
é tratado como -size 8c
(octal), outra não conformidade do POSIX.
FreeBSD/Libélula BSD find
support ckMGTP
(not bwE
), mas embora se comporte conforme exigido pelo POSIX sem sufixo, ele se comporta como busybox/toybox e não como GNU find
quando há um sufixo².
sfind
ou o find
built-in do shell bosh se comporta como o do FreeBSD, exceto que os sufixos não diferenciam maiúsculas de minúsculas e bwE
são suportados e números octais/decimais e algunsexpressões aritméticas de produto(como 6x12x8k
) são aceitos.
Pelo que posso dizer, todos osOpenBSD,NetBSD,Ilumos,Solaris,AIX,HP/UXsuporta apenas sem sufixo para unidades de 512 bytes ou c
para bytes conforme POSIX necessário.
Uma tabela de resumo:
Tradicional/POSIX | GNU | FreeBSD | encontrar | caixa ocupada | caixa de brinquedo | |
---|---|---|---|---|---|---|
sufixos | c | cwbkMG | ckMGTP | cwbkmgtpeCWBKMGTPE | cwbk | cwbkmgtpeCWBKMGTPE (+d) |
formato numérico | decimal | decimal | decimal | dezembro/out/hex/expr | decimal | dezembro/out/hex |
-size $n |
($n-1)*512+1..$n*512 | ($n-1)*512+1..$n*512 | ($n-1)*512+1..$n*512 | ($n-1)*512+1..$n*512 | $n*512 | $n*512 |
-size -$n |
0 .. ($n-1)*512 | 0 .. ($n-1)*512 | 0 .. ($n-1)*512 | 0 .. ($n-1)*512 | 0 ..$n*512-1 | 0 ..$n*512-1 |
-size +$n |
($n*512)+1 .. ∞ | ($n*512)+1 .. ∞ | ($n*512)+1 .. ∞ | ($n*512)+1 .. ∞ | ($n*512)+1 .. ∞ | ($n*512)+1 .. ∞ |
-size ${n}c |
$ n | $ n | $ n | $ n | $ n | $ n |
-size -${n}c |
0..$n-1 | 0..$n-1 | 0..$n-1 | 0..$n-1 | 0..$n-1 | 0..$n-1 |
-size +${n}c |
$n+1.. ∞ | $n+1.. ∞ | $n+1.. ∞ | $n+1.. ∞ | $n+1.. ∞ | $n+1.. ∞ |
-size $n$unit |
N / D | ($n-1)*$unidade+1 .. $n*$unidade | $n*$unidade | $n*$unidade | $n*$unidade | $n*$unidade |
-size -$n$unit |
N / D | 0 .. ($n-1)*$unidade | 0 .. $n*$unidade-1 | 0 .. $n*$unidade-1 | 0 .. $n*$unidade-1 | 0 .. $n*$unidade-1 |
-size +$n$unit |
N / D | $n*$unidade+1 .. ∞ | $n*$unidade+1 .. ∞ | $n*$unidade+1 .. ∞ | $n*$unidade+1 .. ∞ | $n*$unidade+1 .. ∞ |
Então, resumindo, para portabilidade, sua melhor aposta é usar o c
sufixo, apenas números decimais sem zeros à esquerda e calcular as unidades manualmente.
Para completar, o L
qualificador glob de zsh
( kmgt
sem distinção entre maiúsculas e minúsculas, mas pP
é para unidade de 512 bytes, não pebibyte) se comporta como POSIX/GNU find
( *(LM-12)
expande para arquivos cujo tamanho está entre 0 e 11 mebibytes, por exemplo).
¹ É o tamanho informado no st_size
atributo da estrutura retornada lstat()
cujo significado para arquivos não regulares pode variar entre sistemas.
² Existe o mesmo tipo de distinção no FreeBSD find
/ sfind
para os -Xtime
predicados onde, por exemplo, -mtime +1
corresponde a arquivos com 2 dias ou mais (idade 86400*2 - ∞) enquanto -mtime +1d
corresponde a arquivos com mais de um dia (idade 86400.000000001 - ∞ ). Com GNU find
, veja também ! -newermt -1day
(ou 1 day ago
ou yesterday
).
Responder3
Para complementar o que Stephen Kitt mencionou, cuidado com o gnu findarredondao tamanho para a granularidade especificada antes de comparar!
Se você fizer
truncate --size=1000 dummy_file_1000
truncate --size=1024 dummy_file_1024
então
find . -size 1k
find . -size 1024c
vainãodê o mesmo resultado!
Vercomando find: comportamento -size
Resumindo - find . -size 1k
listará todos os arquivos com tamanho∈[1,1024], enquanto find . -size 1024c
listará apenas os arquivos cujo tamanho real é exatamente 1024 bytes.