Hoe kan ik de grootte van een bestand in een bash-script krijgen?

Je beste gok als je op een GNU-systeem werkt:

stat --printf="%s" file.any 

Van man stat :

% s totale grootte, in bytes

In een bash-script:

#!/bin/bash FILENAME=/home/heiko/dummy/packages.txt FILESIZE=$(stat -c%s "$FILENAME") echo "Size of $FILENAME = $FILESIZE bytes." 

OPMERKING: zie

file_size_kb=`du -k "$filename" | cut -f1` 

Het probleem met het gebruik van stat is dat het een GNU (Linux) extensie is. du -k en cut -f1 worden gespecificeerd door POSIX en zijn daarom overdraagbaar naar elk Unix-systeem.

Solaris wordt bijvoorbeeld geleverd met bash maar niet met stat . Dit is dus niet helemaal hypothetisch.

ls heeft een soortgelijk probleem doordat het exacte formaat van de uitvoer niet is gespecificeerd, dus het parseren van de uitvoer kan niet draagbaar worden gedaan . du -h is ook een GNU-extensie.

Blijf waar mogelijk bij draagbare constructies, en je zult iemands leven in de toekomst gemakkelijker maken. Misschien die van jou.

Reacties

• du geeft niet ‘ de grootte van het bestand, het geeft een indicatie van hoeveel ruimte het bestand gebruikt, wat subtiel verschilt (meestal is de grootte die wordt gerapporteerd door du de grootte van het bestand afgerond naar het dichtstbijzijnde aantal blokken, waarbij een blok doorgaans 512B of 1kB of 4kB is).
• @Gilles, beperkte bestanden (dwz bestanden met gaten erin) rapporteren minder dan de lengte.
• Dit, met --bytes of -b in plaats van -k, zou het geaccepteerde antwoord moeten zijn.
• @fralau: het OP wil ” dit toewijzen aan een bash-variabele zodat ze het later kunnen gebruiken “, dus het is veel waarschijnlijker dat ze een actuator willen een numerieke waarde, geen door mensen leesbare benadering. Bovendien is -h een GNU-extensie; het is niet standaard
• Het gebruik van du met --apparent-size vlag zal een more teruggeven exacte grootte (zoals vermeld op man: print apparent sizes, rather than disk usage; although the apparent size is usually smaller, it may be larger due to holes in ('sparse') files, internal fragmentation, indirect blocks, and the like)

Je zou ook het” word count “commando kunnen gebruiken (wc):

wc -c "$filename" | awk "{print $1}" 

Het probleem met wc is dat het “de bestandsnaam zal toevoegen en de uitvoer zal laten inspringen. Bijvoorbeeld:

$ wc -c somefile.txt 1160 somefile.txt 

Als je wilt voorkomen dat je een volledig geïnterpreteerde taal of stream-editor aaneenschakelt om een telling van de bestandsgrootte te krijgen, stuur je de invoer gewoon om vanuit het bestand zodat wc nooit de bestandsnaam ziet:

wc -c < "$filename" 

Dit laatste formulier kan worden gebruikt met opdrachtvervanging om gemakkelijk de waarde te pakken die u zocht als een shell-variabele, zoals vermeld door Gilles hieronder.

size="$(wc -c <"$filename")" 

Reacties

• wc -c <"$FILENAME" geeft de grootte zonder andere cruft, dus size=$(wc -c <"$FILENAME").
• Nog één punt: ik heb het net getest en wc -c < file lijkt erg snel te zijn, tenminste op OS X. I ‘ Ik vermoed dat wc de hersens heeft om te proberen het bestand te stateren als alleen -c is opgegeven.
• @EdwardFalk: GNU wc -c gebruikt fstat, maar zoekt dan naar het voorlaatste blok van het bestand en leest de laatste tot st_blksize bytes. Blijkbaar komt dit omdat bestanden in Linux ‘ s /proc en /sys hebben bijvoorbeeld stat-grootten die slechts bij benadering zijn , en wc wil de werkelijke grootte rapporteren, niet de stat-gerapporteerde grootte. Ik denk dat het raar zou zijn als wc -c een andere grootte zou rapporteren dan wc, maar het is ‘ heeft geen idee om gegevens uit het bestand te lezen als het ‘ een normaal schijfbestand is, en het ‘ niet in het geheugen zit. Of erger nog, near-line tape-opslag …
• Het lijkt erop dat printf nog steeds de inspringing ziet, bijv. printf "Size: $size" – > size: <4 spaces> 54339. Aan de andere kant negeert echo de witruimte. Enige manier om het consistent te maken?
• @keithpjolley: door fstat te bellen. Probeer strace wc -c </etc/passwd uit te voeren en u kunt zien wat het doet.

BSD “s (macOS” s) stat heeft een ander formaatargumentvlag en verschillende veldspecificaties. Van man stat(1):

• -f format: geef informatie weer in de opgegeven indeling. Zie het gedeelte FORMATS voor een beschrijving van geldige formaten.
• … het gedeelte FORMATS …
• z: de grootte van bestand in bytes.

Dus nu allemaal samen:

stat -f%z myfile1.txt 

OPMERKING: zie @ b01 “s antwoord voor het gebruik van het stat commando op GNU / Linux-systemen. 🙂

Opmerkingen

• Merk op dat dit een oplossing is die alleen BSD is. ‘ werkt niet met GNU stat, helaas.

Hangt af van wat je bedoelt met grootte .

size=$(wc -c < "$file") 

geeft u het aantal bytes dat uit het bestand kan worden gelezen. IOW, het is de grootte van de inhoud van het bestand. Het zal echter de inhoud van het bestand lezen (behalve als het bestand een gewoon bestand is of een symlink naar een gewoon bestand in de meeste wc implementaties als een optimalisatie). Dat kan bijwerkingen hebben. Bijvoorbeeld, voor een named pipe kan wat gelezen is niet meer opnieuw gelezen worden en voor zaken als /dev/zero of /dev/random die van oneindig groot, het zal even duren. Dat betekent ook dat je read toestemming voor het bestand nodig hebt, en het laatste toegangstijdstempel van het bestand kan worden bijgewerkt.

Dat is standaard en draagbaar, maar merk op dat sommige wc implementaties leidende blancos in die uitvoer kunnen bevatten. Een manier om er vanaf te komen is door gebruik te maken van:

size=$(($(wc -c < "$file"))) 

of om een fout over een lege rekenkundige uitdrukking in dash of yash wanneer wc geen uitvoer produceert (zoals wanneer het bestand “niet kan worden geopend):

size=$(($(wc -c < "$file") +0)) 

ksh93 heeft wc ingebouwd (mits u het inschakelt, kunt u het ook oproepen als command /opt/ast/bin/wc), wat het het meest efficiënt maakt voor gewone bestanden in die shell.

Verschillende systemen hebben een commando genaamd stat dat “is een interface naar de stat() of lstat() systeemoproepen.

Die rapportinformatie gevonden in de inode. Een van die informatie is het kenmerk st_size. Voor gewone bestanden is dat de grootte van de inhoud (hoeveel gegevens kunnen eruit worden gelezen als er geen fouten optreden (dat is wat de meeste wc -c -implementaties gebruiken bij hun optimalisatie) ). Voor symlinks is dat de grootte in bytes van het doelpad. Voor named pipes is dit, afhankelijk van het systeem, ofwel 0 ofwel het aantal bytes dat momenteel in de pipe-buffer aanwezig is. Hetzelfde geldt voor blokapparaten waarbij u, afhankelijk van het systeem, 0 krijgt of de grootte in bytes van de onderliggende opslag.

U heeft geen leesmachtiging voor het bestand nodig om die informatie te krijgen, alleen zoekmachtiging voor de directory waaraan het is gekoppeld.

In chronologische volgorde is er:

• IRIX stat (90 “s):

  stat -qLs -- "$file" 

  geeft het st_size attribuut van $file (lstat()) of:

  stat -s -- "$file" 

  hetzelfde behalve wanneer $file is een symlink, in welk geval het “de st_size van het bestand is na resolutie van de symlink.

• zsh stat ingebouwd (nu ook bekend als zstat) in de zsh/stat module (geladen met zmodload zsh/stat) (1997):

  stat -L +size -- $file # st_size of file stat +size -- $file # after symlink resolution 

  of om in een variabele op te slaan:

  stat -L -A size +size -- $file 

  uiteraard is dat het meest efficiënt in die shell.

• GNU stat (2001); ook in BusyBox stat sinds 2 005 (gekopieerd van GNU stat):

  stat -c %s -- "$file" # st_size of file stat -Lc %s -- "$file" # after symlink resolution 

  (let op de betekenis van -L is omgekeerd vergeleken met IRIX of zsh stat.

• BSDs stat (2002):

  stat -f %z -- "$file" # st_size of file stat -Lf %z -- "$file" # after symlink resolution 

Of je kunt de stat() / lstat() -functie van een scripttaal zoals perl:

perl -le "print((lstat shift)[7])" -- "$file" 

AIX heeft ook een istat -opdracht die alle stat() (niet lstat() zal dumpen, dus zal niet werken op symlinks ) informatie en waarmee je achteraf zou kunnen verwerken, bijvoorbeeld:

LC_ALL=C istat "$file" | awk "NR == 4 {print $5}" 

(bedankt @JeffSchaller voor de hulp bij het uitzoeken van de details ).

In tcsh:

@ size = -Z $file:q 

(grootte na resolutie van symlink)

Lang voordat GNU zijn stat commando introduceerde, kon hetzelfde worden bereikt met GNU find commando met zijn -printf predikaat (al in 1991):

find -- "$file" -prune -printf "%s\n" # st_size of file find -L -- "$file" -prune -printf "%s\n" # after symlink resolution 

Een probleem is echter dat het niet werk als $file begint met - of een find predikaat is (zoals !, ( …).

De standaardopdracht om de stat() / lstat() informatie is ls.

POSIXly kunt u doen:

LC_ALL=C ls -dn -- "$file" | awk "{print $5; exit}" 

en voeg -L toe voor hetzelfde na resolutie van symlink. Dat werkt niet voor apparaatbestanden, hoewel het 5 ^e -veld het hoofdnummer van het apparaat is in plaats van de grootte.

Voor blokapparaten, systemen waarbij stat() retourneert 0 voor st_size, hebben meestal andere APIs om de grootte van het blokapparaat te rapporteren. Linux heeft bijvoorbeeld de BLKGETSIZE64 ioctl(), en de meeste Linux-distributies worden nu geleverd met een blockdev commando dat er gebruik van kan maken:

blockdev --getsize64 -- "$device_file" 

Daarvoor heeft u echter leestoestemming voor het apparaatbestand nodig. Het is gewoonlijk mogelijk om de grootte op een andere manier af te leiden. Bijvoorbeeld (nog steeds op Linux):

lsblk -bdno size -- "$device_file" 

Zou moeten werken, behalve voor lege apparaten.

Een aanpak die voor iedereen werkt doorzoekbare bestanden (dus inclusief gewone bestanden, de meeste blokapparaten en sommige tekenapparaten) is om het bestand te openen en tot het einde te zoeken:

• Met zsh (na het laden van de zsh/system module):

  {sysseek -w end 0 && size=$((systell(0)))} < $file 

• Met ksh93:

  < "$file" <#((size=EOF)) 

  of

  { size=$(<#((EOF))); } < "$file" 

• met perl:

  perl -le "seek STDIN, 0, 2 or die "seek: $!"; print tell STDIN" < "$file" 

Voor named pipes hebben we “gezien dat sommige systemen (tenminste AIX, Solaris, HP / UX) de hoeveelheid gegevens in de pipe-buffer beschikbaar maken in stat()” s st_size. Sommige (zoals Linux of FreeBSD) doen dat niet.

Op Linux tenminste, kun je de FIONREAD ioctl() na het openen van de pipe (in lees- en schrijfmodus om te voorkomen dat hij blijft hangen):

fuser -s -- "$fifo_file" && perl -le "require "sys/ioctl.ph"; ioctl(STDIN, &FIONREAD, $n) or die$!; print unpack "L", $n" <> "$fifo_file" 

Merk echter op dat, hoewel het niet “t leest de inhoud van de pijp, het louter openen van de genoemde pijp hier kan nog steeds bijwerkingen hebben. We “gebruiken fuser om eerst te controleren of een proces de pijp al heeft geopend om dat te verlichten, maar dat is niet waterdicht, aangezien fuser kan niet alle processen kunnen controleren.

Tot nu toe hebben we “alleen gekeken naar de grootte van de primaire gegevens die bij de bestanden horen.Dat houdt geen rekening met de grootte van de metadata en alle ondersteunende infrastructuur die nodig is om dat bestand op te slaan.

Een ander inode-attribuut geretourneerd door stat() is st_blocks. Dat is het aantal blokken van 512 bytes dat wordt gebruikt om de gegevens van het bestand op te slaan (en soms enkele metagegevens zoals de uitgebreide attributen op ext4-bestandssystemen op Linux). “t neem de inode zelf op, of de vermeldingen in de mappen waaraan het bestand is gekoppeld.

Grootte en schijfgebruik zijn niet noodzakelijk nauw gerelateerd aan compressie, schaarste (soms wat metadata), extra infrastructuur zoals indirecte blokken in sommige bestandssystemen hebben een invloed op de laatste.

Dat is typisch wat du gebruikt om schijfgebruik te rapporteren. De meeste van de hierboven genoemde commandos zullen in staat zijn om krijg je die informatie.

• POSIXLY_CORRECT=1 ls -sd -- "$file" | awk "{print $1; exit}"
• POSIXLY_CORRECT=1 du -s -- "$file" (niet voor mappen waar dat de schijf usag zou zijn e van de bestanden erin).
• GNU find -- "$file" -printf "%b\n"
• zstat -L +block -- $file
• GNU stat -c %b -- "$file"
• BSD stat -f %b -- "$file"
• perl -le "print((lstat shift)[12])" -- "$file"

Reacties

• duidelijk het meest uitgebreide en informatieve antwoord. dank je. ik kan dit gebruiken om cross-platform bash-scripts te maken met behulp van de BSD- en GNU-statistiekeninfo
• Leuk feit: GNU coreutils wc -c gebruikt fstat, maar leest dan de laatste tot st_blksize bytes. Blijkbaar komt dit omdat bestanden in Linux ‘ s /proc en /sys hebben bijvoorbeeld statistische grootten die slechts bij benadering zijn . Dit is goed voor de juistheid, maar slecht als het einde van het bestand op schijf staat en niet in het geheugen (in het bijzonder indien gebruikt op veel bestanden in een lus). En erg slecht als het bestand wordt gemigreerd naar near-line tape-opslag , of bijv. een FUSE transparant-decompressie bestandssysteem.
• zou dit ook niet werken ls -go file | awk '{print $3}'
• @StevenPenny die -go zouden de SysV-bestanden zijn, ze zouden niet ‘ werken op BSDs (optioneel (XSI) in POSIX). U ‘ d hebt ook ls -god file | awk '{print $3; exit}' (-d nodig om in mappen te werken, exit voor symlinks met nieuwe regels in het doel). De problemen met apparaatbestanden blijven ook bestaan.
• @ αғsнιη de Unix API maakt geen onderscheid tussen tekstbestanden en binaire bestanden. Het ‘ bevat alle reeksen bytes. Sommige applicaties willen die bytes misschien als tekst interpreteren, maar uiteraard niet wc -c die het aantal bytes rapporteert.

Dit script combineert vele manieren om de bestandsgrootte te berekenen:

( du --apparent-size --block-size=1 "$file" 2>/dev/null || gdu --apparent-size --block-size=1 "$file" 2>/dev/null || find "$file" -printf "%s" 2>/dev/null || gfind "$file" -printf "%s" 2>/dev/null || stat --printf="%s" "$file" 2>/dev/null || stat -f%z "$file" 2>/dev/null || wc -c <"$file" 2>/dev/null ) | awk "{print $1}" 

Het script werkt op veel Unix-systemen inclusief Linux, BSD, OSX, Solaris, SunOS, etc.

De bestandsgrootte toont het aantal bytes. Het is de schijnbare grootte, namelijk de bytes die het bestand gebruikt op een typische schijf, zonder speciale compressie, of speciale schaarse gebieden, of niet-toegewezen blokken, enz.

Dit script heeft een productieversie met meer hulp en meer opties hier: https://github.com/SixArm/file-size

stat lijkt dit te doen met de minste systeemaanroepen:

$ set debian-live-8.2.0-amd64-xfce-desktop.iso $ strace stat --format %s $1 | wc 282 2795 27364 $ strace wc --bytes $1 | wc 307 3063 29091 $ strace du --bytes $1 | wc 437 4376 41955 $ strace find $1 -printf %s | wc 604 6061 64793 

ls -l filename geeft je veel informatie over een bestand, inclusief de bestandsgrootte, rechten en eigenaar.

De bestandsgrootte in de vijfde kolom, en wordt weergegeven in bytes. In het onderstaande voorbeeld is de bestandsgrootte iets minder dan 2 KB:

-rw-r--r-- 1 user owner 1985 2011-07-12 16:48 index.php 

Bewerken: Dit is blijkbaar niet zo betrouwbaar als het stat commando.

Reacties

• Ik denk dat zowel ls -l als stat commando betrouwbare informatie over de grootte geven. Ik heb geen enkele verwijzing naar het tegendeel gevonden. ls -s geeft de grootte in aantal blokken.
• @ dabest1 het ‘ is in zekere zin niet betrouwbaar dat in een andere unix, hun output kan anders zijn (en in sommige unixen is dat ook).
• Ja, IIRC, Solaris heeft niet ‘ t de groepsnaam standaard weergeven, wat leidt tot minder kolommen in de uitvoer.
• Aangezien de grootte puur numeriek is, omgeven door witruimte, en het datumjaar puur numeriek is, in een gedefinieerde indeling, zou het mogelijk zijn om een regexp te gebruiken om de gebruiker te behandelen + eigenaar als één veld, ongeacht of de groep aanwezig was of niet. (een oefening voor de lezer!)

du filename vertelt u het schijfgebruik in bytes.

Ik geef de voorkeur aan du -h filename, wat je de grootte geeft in een door mensen leesbaar formaat.

Opmerkingen

• that or stat -c "%s"😉
• Deze variant van du drukt de grootte af in blokken van 1024 bytes, geen simpele telling van bytes.
• Merk op dat standaard du een uitvoer geeft in eenheden van 512 bytes. GNU du gebruikt in plaats daarvan kibibytes, tenzij aangeroepen met POSIXLY_CORRECT in zijn omgeving.
• Voor bestanden van het type directory , dat geeft het schijfgebruik van de directory maar ook van alle andere bestanden erin (recursief).

Creëer kleine hulpprogramma-functies in uw shell-scripts waarnaar u kunt delegeren.

Voorbeeld

#! /bin/sh - # vim: set ft=sh # size utility that works on GNU and BSD systems size(){ case $(uname) in (Darwin | *BSD*) stat -Lf %z -- "$1";; (*) stat -c %s -- "$1" esac } for f do printf "%s\n" "$f : $(gzip < "$f" | wc -c) bytes (versus $(size "$f") bytes)" done 

Gebaseerd op info van @ Stéphane Chazelas “antwoord.

Opmerkingen

• Zie ook gzip -v < file > /dev/null om de comprimeerbaarheid van een bestand te controleren.
• @St é phaneChazelas niet zeker of ik denk dat het een verbetering was. die case-statements kunnen noobs gemakkelijk afschrikken; ik kan me zeker nooit herinneren hoe ik ze goed moet krijgen 🙂 zijn case-statements inherent draagbaarder sinds jij deed het? ik zie het punt als er meer dan twee gevallen zijn, maar verder … +
• Ik veronderstel dat het ‘ ook een kwestie van smaak is, maar hier is ‘ het typische geval waarin u ‘ een case wilt gebruiken statement. case is de Bourne / POSIX-constructie om patroonvergelijking uit te voeren. [[...]] is alleen ksh / bash / zsh (met variaties).

Ik heb gevonden een AWK 1-voering, en deze had een bug, maar ik heb deze opgelost. Ik heb ook PetaBytes toegevoegd na TeraBytes.

FILE_SIZE=234234 # FILESIZE IN BYTES FILE_SIZE=$(echo "${FILE_SIZE}" | awk "{ split( "B KB MB GB TB PB" , v ); s=1; while( $1>1024 ){ $1/=1024; s++ } printf "%.2f %s", $1, v[s] }") 

Gezien stat staat niet op elk systeem afzonderlijk, u kunt bijna altijd de AWK-oplossing gebruiken. Voorbeeld; de Raspberry Pi heeft geen stat maar wel awk .

Reacties

• Helemaal NIET wat het OP vroeg, maar leuk klein stukje werk.

Zelf vind ik de wc-optie leuk. In combinatie met bc kun je decimalen krijgen op zoveel plaatsen als je wilt.

Ik was op zoek naar het verbeteren van een script dat ik zo onhandig had uit de kolom bestandsgrootte van een ls – alh “commando. Ik wilde niet alleen gehele getallen bestandsgroottes, en twee decimalen leken te passen, dus na het lezen van deze discussie, kwam ik met de onderstaande code.

Ik raad aan om de regel bij de puntkommas te onderbreken als je dit in een script opneemt.

file=$1; string=$(wc -c $file); bite=${string% *}; okay=$(echo "scale=2; $bite/1024" | bc);friend=$(echo -e "$file $okay" "kb"); echo -e "$friend"

Mijn script wordt gpfl genoemd, voor “get picture file length”. Ik gebruik het nadat ik een mogrify heb gedaan op een bestand in imagemagick, voordat ik een afbeelding in een GUI jpeg-viewer open of opnieuw laad.

Ik weet niet hoe dit scoort als een antwoord, aangezien het veel leent van wat al is aangeboden en besproken. Dus ik laat het daar.

BZT

Opmerkingen

• Ik zou liever gebruiken ” stat ” of ” ls “. Meestal gebruik ik ‘ niet graag ” wc ” om bestandsgroottes te krijgen omdat het leest fysiek het hele bestand. Als je veel bestanden hebt, of bijzonder grote bestanden, kan dit veel tijd kosten. Maar je oplossing is creatief … + 1.
• Ik ben het eens met het idee van het gebruik van ” stat ” boven ” wc ” voor bestandsgrootte, maar als u ” wc -c ” gebruikt, worden er geen gegevens gelezen; in plaats daarvan wordt lseek gebruikt om bereken het aantal bytes in een bestand. lingrok.org/xref/coreutils/src/wc.c#228
• @ bbaja42 : merk op dat GNU Coreutils leest het laatste blok van het bestand, voor het geval stat.st_size slechts een benadering was (zoals voor Linux /proc en /sys bestanden). Ik denk dat ze besloten hebben om de hoofdcommentaar niet ingewikkelder te maken toen ze die logica een paar regels lager toevoegden: lingrok.org/xref/coreutils/src/wc.c#246

De snelste en eenvoudigste (IMO) methode is:

bash_var=$(stat -c %s /path/to/filename) 

Reacties

• Stem vervolgens een of meer van de bestaande antwoorden die stat vermelden; het is niet nodig om het opnieuw te herhalen …
• @JeffSchaller Ik heb zojuist het antwoord van Stephane ‘ op jouw instructies geüpdatet.Ik denk dat het te ingewikkeld is voor mijn doeleinden. Daarom plaatste ik dit eenvoudige antwoord voor gelijkgestemde zielen.
• Dank je; het ‘ is gewoon dat een zesde exemplaar van een ” stat ” antwoord is niet ‘ t vereenvoudigt deze Q & A, maar laat een nieuwe lezer zich liever afvragen ” hoe verschilt dit antwoord van de andere? ” en leidt het tot meer verwarring in plaats van minder.
• @JeffSchaller denk ik. Maar ik zou kunnen klagen over de vele du en wc antwoorden die een disclaimer zouden moeten hebben DOE DIT NOOIT in het echt leven. Ik gebruikte mijn antwoord vanavond in een echte applicatie en vond het de moeite waard om te delen. Ik denk dat we allemaal onze mening hebben haalt onze schouders op .