File size: Difference between revisions
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
|||
Line 5: | Line 5: | ||
=={{header|11l}}== |
=={{header|11l}}== |
||
< |
<syntaxhighlight lang="11l">V size1 = fs:file_size(‘input.txt’) |
||
V size2 = fs:file_size(‘/input.txt’)</ |
V size2 = fs:file_size(‘/input.txt’)</syntaxhighlight> |
||
=={{header|8086 Assembly}}== |
=={{header|8086 Assembly}}== |
||
Line 12: | Line 12: | ||
This program runs under MS-DOS. |
This program runs under MS-DOS. |
||
< |
<syntaxhighlight lang="asm">putch: equ 2 ; Print character |
||
puts: equ 9 ; Print $-terminated string |
puts: equ 9 ; Print $-terminated string |
||
setdta: equ 1Ah ; Set DTA |
setdta: equ 1Ah ; Set DTA |
||
Line 79: | Line 79: | ||
colspc: db ': $' ; Colon and space |
colspc: db ': $' ; Colon and space |
||
section .bss |
section .bss |
||
dta: resb 512 ; Disc transfer area</ |
dta: resb 512 ; Disc transfer area</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 109: | Line 109: | ||
DOS 2.5 returns file size in number of sectors. It is required to read the whole file to calculate its size in bytes. |
DOS 2.5 returns file size in number of sectors. It is required to read the whole file to calculate its size in bytes. |
||
{{libheader|Action! Tool Kit}} |
{{libheader|Action! Tool Kit}} |
||
< |
<syntaxhighlight lang="action!">INCLUDE "D2:IO.ACT" ;from the Action! Tool Kit |
||
PROC Dir(CHAR ARRAY filter) |
PROC Dir(CHAR ARRAY filter) |
||
Line 155: | Line 155: | ||
size=FileSize(fname) |
size=FileSize(fname) |
||
PrintF("Size of ""%S"" is %U bytes%E",fname,size) |
PrintF("Size of ""%S"" is %U bytes%E",fname,size) |
||
RETURN</ |
RETURN</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 169: | Line 169: | ||
The '''Sparta DOS X''' system stores the size of the file in the directory. The readout of the values is performed with the XIO 39 operation. In the ICAX3, ICAX4, ICAX5 registers values are returned in 24-byte format. Calculation according to the formula: ICAX3 + ICAX4 * 256 + ICAX5 * 65536. |
The '''Sparta DOS X''' system stores the size of the file in the directory. The readout of the values is performed with the XIO 39 operation. In the ICAX3, ICAX4, ICAX5 registers values are returned in 24-byte format. Calculation according to the formula: ICAX3 + ICAX4 * 256 + ICAX5 * 65536. |
||
{{libheader|Action! Tool Kit}} |
{{libheader|Action! Tool Kit}} |
||
< |
<syntaxhighlight lang="action!">INCLUDE"REAL.ACT" ;from the Action! Tool Kit |
||
proc MAIN() |
proc MAIN() |
||
Line 183: | Line 183: | ||
print("Size of REAL.ACT is ") printRD(DEVICE,FLEN) printe(" bytes") |
print("Size of REAL.ACT is ") printRD(DEVICE,FLEN) printe(" bytes") |
||
return |
return |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 190: | Line 190: | ||
=={{header|Ada}}== |
=={{header|Ada}}== |
||
< |
<syntaxhighlight lang="ada">with Ada.Directories; use Ada.Directories; |
||
with Ada.Text_IO; use Ada.Text_IO; |
with Ada.Text_IO; use Ada.Text_IO; |
||
Line 197: | Line 197: | ||
Put_Line (File_Size'Image (Size ("input.txt")) & " bytes"); |
Put_Line (File_Size'Image (Size ("input.txt")) & " bytes"); |
||
Put_Line (File_Size'Image (Size ("/input.txt")) & " bytes"); |
Put_Line (File_Size'Image (Size ("/input.txt")) & " bytes"); |
||
end Test_File_Size;</ |
end Test_File_Size;</syntaxhighlight> |
||
Note that reference to the root directory, if there is any, is [[OS]] specific. |
Note that reference to the root directory, if there is any, is [[OS]] specific. |
||
=={{header|Aime}}== |
=={{header|Aime}}== |
||
< |
<syntaxhighlight lang="aime">o_(stat("input.txt", ST_SIZE), "\n"); |
||
o_("/Cygwin.ico".stat(ST_SIZE), "\n");</ |
o_("/Cygwin.ico".stat(ST_SIZE), "\n");</syntaxhighlight> |
||
=={{header|ALGOL 68}}== |
=={{header|ALGOL 68}}== |
||
Line 208: | Line 208: | ||
special channel, e.g. a tape device. |
special channel, e.g. a tape device. |
||
Conceptually the procedure < |
Conceptually the procedure <syntaxhighlight lang="algol68">PROC set = (REF FILE file, INT page, line, character)VOID: ~ </syntaxhighlight> |
||
could be used to do a binary search find the last page's page number. And if it is known |
could be used to do a binary search find the last page's page number. And if it is known |
||
that every page has the same number of lines, and every line has the same number of '''char'''[s], |
that every page has the same number of lines, and every line has the same number of '''char'''[s], |
||
Line 219: | Line 219: | ||
=={{header|Arturo}}== |
=={{header|Arturo}}== |
||
< |
<syntaxhighlight lang="rebol">print volume "input.txt" |
||
print volume "/input.txt"</ |
print volume "/input.txt"</syntaxhighlight> |
||
=={{header|AutoHotkey}}== |
=={{header|AutoHotkey}}== |
||
< |
<syntaxhighlight lang="autohotkey">FileGetSize, FileSize, input.txt ; Retrieve the size in bytes. |
||
MsgBox, Size of input.txt is %FileSize% bytes |
MsgBox, Size of input.txt is %FileSize% bytes |
||
FileGetSize, FileSize, \input.txt, K ; Retrieve the size in Kbytes. |
FileGetSize, FileSize, \input.txt, K ; Retrieve the size in Kbytes. |
||
MsgBox, Size of \input.txt is %FileSize% Kbytes</ |
MsgBox, Size of \input.txt is %FileSize% Kbytes</syntaxhighlight> |
||
=={{header|AWK}}== |
=={{header|AWK}}== |
||
{{works with|gawk}} |
{{works with|gawk}} |
||
< |
<syntaxhighlight lang="awk">@load "filefuncs" |
||
function filesize(name ,fd) { |
function filesize(name ,fd) { |
||
if ( stat(name, fd) == -1) |
if ( stat(name, fd) == -1) |
||
Line 240: | Line 240: | ||
print filesize("input.txt") |
print filesize("input.txt") |
||
print filesize("/input.txt") |
print filesize("/input.txt") |
||
}</ |
}</syntaxhighlight> |
||
Some awk's don't have direct access to the filesystem, but can execute system-commands like dir (DOS/Windows) and ls |
Some awk's don't have direct access to the filesystem, but can execute system-commands like dir (DOS/Windows) and ls |
||
< |
<syntaxhighlight lang="awk">BEGIN { |
||
# Windows |
# Windows |
||
Line 281: | Line 281: | ||
close(command) |
close(command) |
||
return ship |
return ship |
||
}</ |
}</syntaxhighlight> |
||
Line 287: | Line 287: | ||
=={{header|Axe}}== |
=={{header|Axe}}== |
||
< |
<syntaxhighlight lang="axe">If GetCalc("appvINPUT")→I |
||
Disp {I-2}ʳ▶Dec,i |
Disp {I-2}ʳ▶Dec,i |
||
Else |
Else |
||
Disp "NOT FOUND",i |
Disp "NOT FOUND",i |
||
End</ |
End</syntaxhighlight> |
||
=={{header|BaCon}}== |
=={{header|BaCon}}== |
||
< |
<syntaxhighlight lang="freebasic">' file size |
||
' Return the entire message, FILELEN returns a NUMBER |
' Return the entire message, FILELEN returns a NUMBER |
||
FUNCTION printlen$(STRING name$) |
FUNCTION printlen$(STRING name$) |
||
Line 305: | Line 305: | ||
PRINT printlen$("input.txt") |
PRINT printlen$("input.txt") |
||
PRINT printlen$("/input.txt")</ |
PRINT printlen$("/input.txt")</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 320: | Line 320: | ||
=={{header|Batch File}}== |
=={{header|Batch File}}== |
||
Outputs file size of the first parameter (you can drag and drop a file in aswell). |
Outputs file size of the first parameter (you can drag and drop a file in aswell). |
||
< |
<syntaxhighlight lang="dos"> |
||
@echo off |
@echo off |
||
if not exist "%~1" exit /b 1 & rem If file doesn't exist exit with error code of 1. |
if not exist "%~1" exit /b 1 & rem If file doesn't exist exit with error code of 1. |
||
for /f %%i in (%~1) do echo %~zi |
for /f %%i in (%~1) do echo %~zi |
||
pause>nul |
pause>nul |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|BBC BASIC}}== |
=={{header|BBC BASIC}}== |
||
< |
<syntaxhighlight lang="bbcbasic"> file% = OPENIN(@dir$+"input.txt") |
||
IF file% THEN |
IF file% THEN |
||
PRINT "File size = " ; EXT#file% |
PRINT "File size = " ; EXT#file% |
||
Line 338: | Line 338: | ||
PRINT "File size = " ; EXT#file% |
PRINT "File size = " ; EXT#file% |
||
CLOSE #file% |
CLOSE #file% |
||
ENDIF</ |
ENDIF</syntaxhighlight> |
||
=={{header|Bracmat}}== |
=={{header|Bracmat}}== |
||
This solution assumes that the file can be opened for reading. The <code>fil</code> function is the Bracmat interface to the underlying C functions <code>fopen, fclose, fseek, ftell, fread, fgetc, fwrite, fputc</code> and <code>feof</code>. More than one file can be opened at the same time. Focus is shifted from one open file to another by mentioning the file name as the first argument. |
This solution assumes that the file can be opened for reading. The <code>fil</code> function is the Bracmat interface to the underlying C functions <code>fopen, fclose, fseek, ftell, fread, fgetc, fwrite, fputc</code> and <code>feof</code>. More than one file can be opened at the same time. Focus is shifted from one open file to another by mentioning the file name as the first argument. |
||
< |
<syntaxhighlight lang="bracmat">(getFileSize= |
||
size |
size |
||
. fil$(!arg,rb) {read in binary mode} |
. fil$(!arg,rb) {read in binary mode} |
||
Line 357: | Line 357: | ||
getFileSize$"c:\\boot.ini" |
getFileSize$"c:\\boot.ini" |
||
211 |
211 |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|C}}== |
=={{header|C}}== |
||
< |
<syntaxhighlight lang="c">#include <stdlib.h> |
||
#include <stdio.h> |
#include <stdio.h> |
||
Line 378: | Line 378: | ||
printf("%ld\n", getFileSize("/input.txt")); |
printf("%ld\n", getFileSize("/input.txt")); |
||
return 0; |
return 0; |
||
}</ |
}</syntaxhighlight> |
||
{{works with|POSIX}} |
{{works with|POSIX}} |
||
< |
<syntaxhighlight lang="c">#include <stdlib.h> |
||
#include <stdio.h> |
#include <stdio.h> |
||
#include <sys/stat.h> |
#include <sys/stat.h> |
||
Line 393: | Line 393: | ||
printf("%ld\n", foo.st_size); |
printf("%ld\n", foo.st_size); |
||
return 0; |
return 0; |
||
}</ |
}</syntaxhighlight> |
||
=={{header|C sharp|C#}}== |
=={{header|C sharp|C#}}== |
||
< |
<syntaxhighlight lang="csharp">using System; |
||
using System.IO; |
using System.IO; |
||
Line 408: | Line 408: | ||
} |
} |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|C++}}== |
=={{header|C++}}== |
||
< |
<syntaxhighlight lang="cpp">#include <iostream> |
||
#include <fstream> |
#include <fstream> |
||
Line 426: | Line 426: | ||
std::cout << getFileSize("/input.txt") << std::endl; |
std::cout << getFileSize("/input.txt") << std::endl; |
||
return 0; |
return 0; |
||
}</ |
}</syntaxhighlight> |
||
'''optimized ''' |
'''optimized ''' |
||
< |
<syntaxhighlight lang="cpp">#include <iostream> |
||
#include <fstream> |
#include <fstream> |
||
Line 436: | Line 436: | ||
std::cout << std::ifstream("input.txt", std::ios::binary | std::ios::ate).tellg() << "\n" |
std::cout << std::ifstream("input.txt", std::ios::binary | std::ios::ate).tellg() << "\n" |
||
<< std::ifstream("/input.txt", std::ios::binary | std::ios::ate).tellg() << "\n"; |
<< std::ifstream("/input.txt", std::ios::binary | std::ios::ate).tellg() << "\n"; |
||
}</ |
}</syntaxhighlight> |
||
===C++ 17=== |
===C++ 17=== |
||
< |
<syntaxhighlight lang="cpp">#include <filesystem> |
||
#include <iostream> |
#include <iostream> |
||
Line 454: | Line 454: | ||
print_file_size("input.txt"); |
print_file_size("input.txt"); |
||
print_file_size("/input.txt"); |
print_file_size("/input.txt"); |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 465: | Line 465: | ||
There is not function to get the file size, therefore we seek to the end and query the file pointer position. |
There is not function to get the file size, therefore we seek to the end and query the file pointer position. |
||
< |
<syntaxhighlight lang="clean">import StdEnv |
||
fileSize fileName world |
fileSize fileName world |
||
Line 476: | Line 476: | ||
= (size, world) |
= (size, world) |
||
Start world = fileSize "input.txt" world</ |
Start world = fileSize "input.txt" world</syntaxhighlight> |
||
=={{header|Clojure}}== |
=={{header|Clojure}}== |
||
< |
<syntaxhighlight lang="clojure">(require '[clojure.java.io :as io]) |
||
(defn show-size [filename] |
(defn show-size [filename] |
||
(println filename "size:" (.length (io/file filename)))) |
(println filename "size:" (.length (io/file filename)))) |
||
(show-size "input.txt") |
(show-size "input.txt") |
||
(show-size "/input.txt")</ |
(show-size "/input.txt")</syntaxhighlight> |
||
=={{header|COBOL}}== |
=={{header|COBOL}}== |
||
<syntaxhighlight lang="cobol"> |
|||
<lang Cobol> |
|||
identification division. |
identification division. |
||
program-id. FileInfo. |
program-id. FileInfo. |
||
Line 530: | Line 530: | ||
end-if |
end-if |
||
. |
. |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|ColdFusion}}== |
=={{header|ColdFusion}}== |
||
< |
<syntaxhighlight lang="coldfusion"><cfscript> |
||
localFile = getFileInfo(expandpath("input.txt")); |
localFile = getFileInfo(expandpath("input.txt")); |
||
rootFile = getFileInfo("/input.txt"); |
rootFile = getFileInfo("/input.txt"); |
||
Line 541: | Line 541: | ||
Size of input.txt is #localFile.size# bytes. |
Size of input.txt is #localFile.size# bytes. |
||
Size of /input.txt is #rootFile.size# bytes. |
Size of /input.txt is #rootFile.size# bytes. |
||
</cfoutput></ |
</cfoutput></syntaxhighlight> |
||
=={{header|Common Lisp}}== |
=={{header|Common Lisp}}== |
||
< |
<syntaxhighlight lang="lisp">(with-open-file (stream (make-pathname :name "input.txt") |
||
:direction :input |
:direction :input |
||
:if-does-not-exist nil) |
:if-does-not-exist nil) |
||
Line 552: | Line 552: | ||
:direction :input |
:direction :input |
||
:if-does-not-exist nil) |
:if-does-not-exist nil) |
||
(print (if stream (file-length stream) 0)))</ |
(print (if stream (file-length stream) 0)))</syntaxhighlight> |
||
(osicat-posix:stat-size (osicat-posix:stat #P"input.txt")) |
(osicat-posix:stat-size (osicat-posix:stat #P"input.txt")) |
||
=={{header|D}}== |
=={{header|D}}== |
||
< |
<syntaxhighlight lang="d">import std.file, std.stdio, std.path, std.file, std.stream, |
||
std.mmfile; |
std.mmfile; |
||
Line 578: | Line 578: | ||
e.msg.writefln; |
e.msg.writefln; |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>File 'file_size.exe' has size: |
<pre>File 'file_size.exe' has size: |
||
Line 586: | Line 586: | ||
=={{header|Delphi}}== |
=={{header|Delphi}}== |
||
< |
<syntaxhighlight lang="delphi">program SizeOfFile; |
||
{$APPTYPE CONSOLE} |
{$APPTYPE CONSOLE} |
||
Line 606: | Line 606: | ||
Writeln('input.txt ', CheckFileSize('input.txt')); |
Writeln('input.txt ', CheckFileSize('input.txt')); |
||
Writeln('\input.txt ', CheckFileSize('\input.txt')); |
Writeln('\input.txt ', CheckFileSize('\input.txt')); |
||
end.</ |
end.</syntaxhighlight> |
||
=={{header|E}}== |
=={{header|E}}== |
||
< |
<syntaxhighlight lang="e">for file in [<file:input.txt>, <file:///input.txt>] { |
||
println(`The size of $file is ${file.length()} bytes.`) |
println(`The size of $file is ${file.length()} bytes.`) |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Eiffel}}== |
=={{header|Eiffel}}== |
||
< |
<syntaxhighlight lang="eiffel"> |
||
class |
class |
||
APPLICATION |
APPLICATION |
||
Line 638: | Line 638: | ||
environment:EXECUTION_ENVIRONMENT |
environment:EXECUTION_ENVIRONMENT |
||
end |
end |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Elena}}== |
=={{header|Elena}}== |
||
ELENA 4.x : |
ELENA 4.x : |
||
< |
<syntaxhighlight lang="elena">import system'io; |
||
import extensions; |
import extensions; |
||
Line 650: | Line 650: | ||
console.printLine(File.assign("\input.txt").Length) |
console.printLine(File.assign("\input.txt").Length) |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Elixir}}== |
=={{header|Elixir}}== |
||
< |
<syntaxhighlight lang="elixir">IO.puts File.stat!("input.txt").size |
||
IO.puts File.stat!("/input.txt").size</ |
IO.puts File.stat!("/input.txt").size</syntaxhighlight> |
||
=={{header|Emacs Lisp}}== |
=={{header|Emacs Lisp}}== |
||
Line 660: | Line 660: | ||
<code>file-attributes</code> returns <code>nil</code> in that case. |
<code>file-attributes</code> returns <code>nil</code> in that case. |
||
< |
<syntaxhighlight lang="lisp">(message "sizes are %s and %s" |
||
(nth 7 (file-attributes "input.txt")) |
(nth 7 (file-attributes "input.txt")) |
||
(nth 7 (file-attributes "/input.txt")))</ |
(nth 7 (file-attributes "/input.txt")))</syntaxhighlight> |
||
=={{header|Erlang}}== |
=={{header|Erlang}}== |
||
< |
<syntaxhighlight lang="erlang">-module(file_size). |
||
-export([file_size/0]). |
-export([file_size/0]). |
||
Line 682: | Line 682: | ||
io:format("~s could not be opened~n",[Filename]) |
io:format("~s could not be opened~n",[Filename]) |
||
end. |
end. |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Euphoria}}== |
=={{header|Euphoria}}== |
||
< |
<syntaxhighlight lang="euphoria">include file.e |
||
function file_size(sequence file_name) |
function file_size(sequence file_name) |
||
Line 708: | Line 708: | ||
test("input.txt") -- in the current working directory |
test("input.txt") -- in the current working directory |
||
test("/input.txt") -- in the file system root</ |
test("/input.txt") -- in the file system root</syntaxhighlight> |
||
=={{header|F_Sharp|F#}}== |
=={{header|F_Sharp|F#}}== |
||
< |
<syntaxhighlight lang="fsharp">open NUnit.Framework |
||
open FsUnit |
open FsUnit |
||
Line 719: | Line 719: | ||
let local = System.IO.FileInfo(__SOURCE_DIRECTORY__ + "\input.txt") |
let local = System.IO.FileInfo(__SOURCE_DIRECTORY__ + "\input.txt") |
||
let root = System.IO.FileInfo(System.IO.Directory.GetDirectoryRoot(__SOURCE_DIRECTORY__) + "input.txt") |
let root = System.IO.FileInfo(System.IO.Directory.GetDirectoryRoot(__SOURCE_DIRECTORY__) + "input.txt") |
||
local.Length = root.Length |> should be True</ |
local.Length = root.Length |> should be True</syntaxhighlight> |
||
=={{header|Factor}}== |
=={{header|Factor}}== |
||
< |
<syntaxhighlight lang="factor">"input.txt" file-info size>> . |
||
1321 |
1321 |
||
"file-does-not-exist.txt" file-info size>> |
"file-does-not-exist.txt" file-info size>> |
||
"Unix system call ``stat'' failed:"...</ |
"Unix system call ``stat'' failed:"...</syntaxhighlight> |
||
=={{header|FBSL}}== |
=={{header|FBSL}}== |
||
FileLen returns -1 if the file is not found. FileLen will also accept a file handle and give the file length of the open file. |
FileLen returns -1 if the file is not found. FileLen will also accept a file handle and give the file length of the open file. |
||
< |
<syntaxhighlight lang="qbasic">#APPTYPE CONSOLE |
||
print FileLen("sync.log") |
print FileLen("sync.log") |
||
print FileLen("\sync.log") |
print FileLen("\sync.log") |
||
PAUSE |
PAUSE |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Forth}}== |
=={{header|Forth}}== |
||
< |
<syntaxhighlight lang="forth">: .filesize ( addr len -- ) 2dup type ." is " |
||
r/o open-file throw |
r/o open-file throw |
||
dup file-size throw <# #s #> type ." bytes long." cr |
dup file-size throw <# #s #> type ." bytes long." cr |
||
Line 744: | Line 744: | ||
s" input.txt" .filesize |
s" input.txt" .filesize |
||
s" /input.txt" .filesize</ |
s" /input.txt" .filesize</syntaxhighlight> |
||
=={{header|Fortran}}== |
=={{header|Fortran}}== |
||
Line 750: | Line 750: | ||
Since Fortran 95 the size of standard external files may be determined simply by using INQUIRE(SIZE=...). |
Since Fortran 95 the size of standard external files may be determined simply by using INQUIRE(SIZE=...). |
||
The following previous example pertains to FORTRAN 77 and is now superceded. |
The following previous example pertains to FORTRAN 77 and is now superceded. |
||
<syntaxhighlight lang="fortran"> |
|||
<lang Fortran> |
|||
use :: iso_fortran_env, only : FILE_STORAGE_SIZE |
use :: iso_fortran_env, only : FILE_STORAGE_SIZE |
||
Line 761: | Line 761: | ||
enddo |
enddo |
||
end |
end |
||
</ |
</syntaxhighlight> |
||
The original example, now obsolete ... |
The original example, now obsolete ... |
||
Line 773: | Line 773: | ||
But if one wrote Fortran on a B6700 system, its F77 compiler offered additional attributes that could be returned via an INQUIRE statement: MAXRECSIZE really was the length of the longest record in the disc file (whether fixed record lengths or variable record lengths), BLOCKSIZE reported the number of records per block of disc space, AREASIZE the size of a disc space allocation area, and AREAS their number, while KIND reveals the code number of the type of file (not via a .txt suffix or whatever). Armed with these values, the file size could be determined in bits, bytes, words (six characters/word), records, blocks and areas. |
But if one wrote Fortran on a B6700 system, its F77 compiler offered additional attributes that could be returned via an INQUIRE statement: MAXRECSIZE really was the length of the longest record in the disc file (whether fixed record lengths or variable record lengths), BLOCKSIZE reported the number of records per block of disc space, AREASIZE the size of a disc space allocation area, and AREAS their number, while KIND reveals the code number of the type of file (not via a .txt suffix or whatever). Armed with these values, the file size could be determined in bits, bytes, words (six characters/word), records, blocks and areas. |
||
These facilities were not carried forward into standardised Fortran 90, etc. So, one is stuck with devising a routine that reads all the records of a disc file, counting their length. This is straightforward, but tedious, as in the following fragment:< |
These facilities were not carried forward into standardised Fortran 90, etc. So, one is stuck with devising a routine that reads all the records of a disc file, counting their length. This is straightforward, but tedious, as in the following fragment:<syntaxhighlight lang="fortran"> 20 READ (INF,21, END = 30) L !R E A D A R E C O R D - but only its length. |
||
21 FORMAT(Q) !This obviously indicates the record's length. |
21 FORMAT(Q) !This obviously indicates the record's length. |
||
NRECS = NRECS + 1 !CALL LONGCOUNT(NRECS,1) !C O U N T A R E C O R D. |
NRECS = NRECS + 1 !CALL LONGCOUNT(NRECS,1) !C O U N T A R E C O R D. |
||
Line 784: | Line 784: | ||
RMAXR = NRECS !Where it's at. |
RMAXR = NRECS !Where it's at. |
||
END IF !So much for the lengths. |
END IF !So much for the lengths. |
||
GO TO 20 !All I wanted to know...</ |
GO TO 20 !All I wanted to know...</syntaxhighlight> |
||
The LONGCOUNT routine uses two 32-bit integers (the first parameter being a two-element array) to deliver a much larger capacity, given modern file size opportunities, but this is unnecessary if INTEGER*8 variables are available. The count will not include any contribution from record splitters such as CR, etc. A file more properly thought of as containing binary data (say, integer or floating-point values) will by chance have a CR or LF bit pattern here and there, and they will be taken as marking record splits when reading a file as being FORMATTED, which is the default setting. |
The LONGCOUNT routine uses two 32-bit integers (the first parameter being a two-element array) to deliver a much larger capacity, given modern file size opportunities, but this is unnecessary if INTEGER*8 variables are available. The count will not include any contribution from record splitters such as CR, etc. A file more properly thought of as containing binary data (say, integer or floating-point values) will by chance have a CR or LF bit pattern here and there, and they will be taken as marking record splits when reading a file as being FORMATTED, which is the default setting. |
||
=={{header|FreeBASIC}}== |
=={{header|FreeBASIC}}== |
||
< |
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64 |
||
#include "file.bi" |
#include "file.bi" |
||
Print FileLen("input.txt"), FileLen(Environ("SystemRoot") + "\input.txt") |
Print FileLen("input.txt"), FileLen(Environ("SystemRoot") + "\input.txt") |
||
Sleep</ |
Sleep</syntaxhighlight> |
||
=={{header|Frink}}== |
=={{header|Frink}}== |
||
< |
<syntaxhighlight lang="frink">println[newJava["java.io.File", "input.txt"].length[]] |
||
println[newJava["java.io.File", "/input.txt"].length[]]</ |
println[newJava["java.io.File", "/input.txt"].length[]]</syntaxhighlight> |
||
=={{header|Gambas}}== |
=={{header|Gambas}}== |
||
< |
<syntaxhighlight lang="gambas">Public Sub Main() |
||
Dim stInfo As Stat = Stat(User.home &/ "input.txt") |
Dim stInfo As Stat = Stat(User.home &/ "input.txt") |
||
Dim stInfo1 As Stat = Stat("/input.txt") |
Dim stInfo1 As Stat = Stat("/input.txt") |
||
Line 807: | Line 807: | ||
Print "/input.txt = " & stInfo1.Size & " bytes" |
Print "/input.txt = " & stInfo1.Size & " bytes" |
||
End</ |
End</syntaxhighlight> |
||
Output: |
Output: |
||
<pre> |
<pre> |
||
Line 815: | Line 815: | ||
=={{header|Go}}== |
=={{header|Go}}== |
||
< |
<syntaxhighlight lang="go">package main |
||
import "fmt" |
import "fmt" |
||
Line 831: | Line 831: | ||
printFileSize("input.txt") |
printFileSize("input.txt") |
||
printFileSize("/input.txt") |
printFileSize("/input.txt") |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Groovy}}== |
=={{header|Groovy}}== |
||
< |
<syntaxhighlight lang="groovy">println new File('index.txt').length(); |
||
println new File('/index.txt').length();</ |
println new File('/index.txt').length();</syntaxhighlight> |
||
=={{header|Haskell}}== |
=={{header|Haskell}}== |
||
< |
<syntaxhighlight lang="haskell">import System.IO |
||
printFileSize filename = withFile filename ReadMode hFileSize >>= print |
printFileSize filename = withFile filename ReadMode hFileSize >>= print |
||
main = mapM_ printFileSize ["input.txt", "/input.txt"]</ |
main = mapM_ printFileSize ["input.txt", "/input.txt"]</syntaxhighlight> |
||
or |
or |
||
< |
<syntaxhighlight lang="haskell">import System.Posix.File |
||
printFileSize filename = do stat <- getFileStatus filename |
printFileSize filename = do stat <- getFileStatus filename |
||
print (fileSize stat) |
print (fileSize stat) |
||
main = mapM_ printFileSize ["input.txt", "/input.txt"]</ |
main = mapM_ printFileSize ["input.txt", "/input.txt"]</syntaxhighlight> |
||
=={{header|HicEst}}== |
=={{header|HicEst}}== |
||
< |
<syntaxhighlight lang="hicest">READ(FILE="input.txt", LENgth=bytes) ! bytes = -1 if not existent |
||
READ(FILE="C:\input.txt", LENgth=bytes) ! bytes = -1 if not existent </ |
READ(FILE="C:\input.txt", LENgth=bytes) ! bytes = -1 if not existent </syntaxhighlight> |
||
=={{header|Icon}} and {{header|Unicon}}== |
=={{header|Icon}} and {{header|Unicon}}== |
||
Icon doesn't support 'stat'; however, information can be obtained by use of the system function to access command line. |
Icon doesn't support 'stat'; however, information can be obtained by use of the system function to access command line. |
||
< |
<syntaxhighlight lang="unicon">every dir := !["./","/"] do { |
||
write("Size of ",f := dir || "input.txt"," = ",stat(f).size) |stop("failure for to stat ",f) |
write("Size of ",f := dir || "input.txt"," = ",stat(f).size) |stop("failure for to stat ",f) |
||
}</ |
}</syntaxhighlight> |
||
Note: Icon and Unicon accept both / and \ for directory separators. |
Note: Icon and Unicon accept both / and \ for directory separators. |
||
=={{header|J}}== |
=={{header|J}}== |
||
< |
<syntaxhighlight lang="j">require 'files' |
||
fsize 'input.txt';'/input.txt'</ |
fsize 'input.txt';'/input.txt'</syntaxhighlight> |
||
=={{header|Java}}== |
=={{header|Java}}== |
||
< |
<syntaxhighlight lang="java">import java.io.File; |
||
public class FileSize |
public class FileSize |
||
Line 878: | Line 878: | ||
} |
} |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|JavaScript}}== |
=={{header|JavaScript}}== |
||
{{works with|JScript}} |
{{works with|JScript}} |
||
< |
<syntaxhighlight lang="javascript">var fso = new ActiveXObject("Scripting.FileSystemObject"); |
||
fso.GetFile('input.txt').Size; |
fso.GetFile('input.txt').Size; |
||
fso.GetFile('c:/input.txt').Size;</ |
fso.GetFile('c:/input.txt').Size;</syntaxhighlight> |
||
The following works in all browsers, including IE10. |
The following works in all browsers, including IE10. |
||
< |
<syntaxhighlight lang="javascript">var file = document.getElementById("fileInput").files.item(0); //a file input element |
||
if (file) { |
if (file) { |
||
var reader = new FileReader(); |
var reader = new FileReader(); |
||
Line 900: | Line 900: | ||
function errorHandler(event) { |
function errorHandler(event) { |
||
alert(event); |
alert(event); |
||
}</ |
}</syntaxhighlight> |
||
=={{header|jq}}== |
=={{header|jq}}== |
||
< |
<syntaxhighlight lang="sh">jq -Rs length input.txt |
||
jq -Rs length /input.txt</ |
jq -Rs length /input.txt</syntaxhighlight> |
||
The -R option causes the file to be read as text, and the -s option causes it to be read as a single string. |
The -R option causes the file to be read as text, and the -s option causes it to be read as a single string. |
||
=={{header|Julia}}== |
=={{header|Julia}}== |
||
< |
<syntaxhighlight lang="julia">println(filesize("input.txt")) |
||
println(filesize("/input.txt"))</ |
println(filesize("/input.txt"))</syntaxhighlight> |
||
=={{header|K}}== |
=={{header|K}}== |
||
< |
<syntaxhighlight lang="k">_size "input.txt" |
||
_size "/input.txt"</ |
_size "/input.txt"</syntaxhighlight> |
||
=={{header|Kotlin}}== |
=={{header|Kotlin}}== |
||
< |
<syntaxhighlight lang="scala">// version 1.0.6 |
||
import java.io.File |
import java.io.File |
||
Line 926: | Line 926: | ||
for (path in paths) |
for (path in paths) |
||
println("Length of $path is ${File(path).length()} bytes") |
println("Length of $path is ${File(path).length()} bytes") |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Lasso}}== |
=={{header|Lasso}}== |
||
< |
<syntaxhighlight lang="lasso">// local to current directory |
||
local(f = file('input.txt')) |
local(f = file('input.txt')) |
||
handle => { #f->close } |
handle => { #f->close } |
||
Line 938: | Line 938: | ||
handle => { #f->close } |
handle => { #f->close } |
||
#f->size |
#f->size |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Liberty BASIC}}== |
=={{header|Liberty BASIC}}== |
||
< |
<syntaxhighlight lang="lb">'input.txt in current directory |
||
OPEN DefaultDir$ + "/input.txt" FOR input AS #m |
OPEN DefaultDir$ + "/input.txt" FOR input AS #m |
||
PRINT "File size: "; lof(#m) |
PRINT "File size: "; lof(#m) |
||
Line 949: | Line 949: | ||
OPEN "c:/input.txt" FOR input AS #m |
OPEN "c:/input.txt" FOR input AS #m |
||
PRINT "File size: "; lof(#m) |
PRINT "File size: "; lof(#m) |
||
CLOSE #m</ |
CLOSE #m</syntaxhighlight> |
||
=={{header|Lingo}}== |
=={{header|Lingo}}== |
||
< |
<syntaxhighlight lang="lingo">---------------------------------------- |
||
-- Returns file size |
-- Returns file size |
||
-- @param {string} filename |
-- @param {string} filename |
||
Line 964: | Line 964: | ||
fp.closeFile() |
fp.closeFile() |
||
return len |
return len |
||
end</ |
end</syntaxhighlight> |
||
=={{header|LiveCode}}== |
=={{header|LiveCode}}== |
||
< |
<syntaxhighlight lang="livecode">// root folder |
||
set the defaultfolder to "/" |
set the defaultfolder to "/" |
||
repeat for each line fline in (the detailed files) |
repeat for each line fline in (the detailed files) |
||
Line 986: | Line 986: | ||
exit repeat |
exit repeat |
||
end if |
end if |
||
end repeat</ |
end repeat</syntaxhighlight> |
||
=={{header|Lua}}== |
=={{header|Lua}}== |
||
< |
<syntaxhighlight lang="lua">function GetFileSize( filename ) |
||
local fp = io.open( filename ) |
local fp = io.open( filename ) |
||
if fp == nil then |
if fp == nil then |
||
Line 997: | Line 997: | ||
fp:close() |
fp:close() |
||
return filesize |
return filesize |
||
end</ |
end</syntaxhighlight> |
||
=={{header|Maple}}== |
=={{header|Maple}}== |
||
< |
<syntaxhighlight lang="maple">FileTools:-Size( "input.txt" )</syntaxhighlight> |
||
< |
<syntaxhighlight lang="maple">FileTools:-Size( "/input.txt" )</syntaxhighlight> |
||
=={{header|Mathematica}} / {{header|Wolfram Language}}== |
=={{header|Mathematica}} / {{header|Wolfram Language}}== |
||
<syntaxhighlight lang="mathematica"> |
|||
<lang Mathematica> |
|||
FileByteCount["input.txt"] |
FileByteCount["input.txt"] |
||
FileByteCount[FileNameJoin[{$RootDirectory, "input.txt"}]]</ |
FileByteCount[FileNameJoin[{$RootDirectory, "input.txt"}]]</syntaxhighlight> |
||
=={{header|MATLAB}} / {{header|Octave}}== |
=={{header|MATLAB}} / {{header|Octave}}== |
||
< |
<syntaxhighlight lang="matlab">d1 = dir('input.txt'); |
||
d2 = dir('/input.txt'); |
d2 = dir('/input.txt'); |
||
fprintf('Size of input.txt is %d bytes\n', d1.bytes) |
fprintf('Size of input.txt is %d bytes\n', d1.bytes) |
||
fprintf('Size of /input.txt is %d bytes\n', d2.bytes)</ |
fprintf('Size of /input.txt is %d bytes\n', d2.bytes)</syntaxhighlight> |
||
=={{header|MAXScript}}== |
=={{header|MAXScript}}== |
||
< |
<syntaxhighlight lang="maxscript">-- Returns filesize in bytes or 0 if the file is missing |
||
getFileSize "index.txt" |
getFileSize "index.txt" |
||
getFileSize "\index.txt"</ |
getFileSize "\index.txt"</syntaxhighlight> |
||
=={{header|Mirah}}== |
=={{header|Mirah}}== |
||
< |
<syntaxhighlight lang="mirah">import java.io.File |
||
puts File.new('file-size.mirah').length() |
puts File.new('file-size.mirah').length() |
||
puts File.new("./#{File.separator}file-size.mirah").length()</ |
puts File.new("./#{File.separator}file-size.mirah").length()</syntaxhighlight> |
||
=={{header|mIRC Scripting Language}}== |
=={{header|mIRC Scripting Language}}== |
||
< |
<syntaxhighlight lang="mirc">echo -ag $file(input.txt).size bytes |
||
echo -ag $file(C:\input.txt).size bytes</ |
echo -ag $file(C:\input.txt).size bytes</syntaxhighlight> |
||
=={{header|Modula-3}}== |
=={{header|Modula-3}}== |
||
< |
<syntaxhighlight lang="modula3">MODULE FSize EXPORTS Main; |
||
IMPORT IO, Fmt, FS, File, OSError; |
IMPORT IO, Fmt, FS, File, OSError; |
||
Line 1,045: | Line 1,045: | ||
| OSError.E => IO.Put("ERROR: Could not get file status.\n"); |
| OSError.E => IO.Put("ERROR: Could not get file status.\n"); |
||
END; |
END; |
||
END FSize.</ |
END FSize.</syntaxhighlight> |
||
=={{header|Nanoquery}}== |
=={{header|Nanoquery}}== |
||
< |
<syntaxhighlight lang="nanoquery">import Nanoquery.IO |
||
println new(File, "input.txt").length() |
println new(File, "input.txt").length() |
||
println new(File, "/input.txt").length()</ |
println new(File, "/input.txt").length()</syntaxhighlight> |
||
=={{header|NetRexx}}== |
=={{header|NetRexx}}== |
||
< |
<syntaxhighlight lang="netrexx">/* NetRexx */ |
||
options replace format comments java symbols binary |
options replace format comments java symbols binary |
||
Line 1,086: | Line 1,086: | ||
end |
end |
||
return</ |
return</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 1,103: | Line 1,103: | ||
=={{header|NewLISP}}== |
=={{header|NewLISP}}== |
||
< |
<syntaxhighlight lang="newlisp">(println (first (file-info "input.txt"))) |
||
(println (first (file-info "/input.txt")))</ |
(println (first (file-info "/input.txt")))</syntaxhighlight> |
||
=={{header|Nim}}== |
=={{header|Nim}}== |
||
< |
<syntaxhighlight lang="nim">import os |
||
echo getFileSize "input.txt" |
echo getFileSize "input.txt" |
||
echo getFileSize "/input.txt"</ |
echo getFileSize "/input.txt"</syntaxhighlight> |
||
=={{header|Objeck}}== |
=={{header|Objeck}}== |
||
< |
<syntaxhighlight lang="objeck"> |
||
use IO; |
use IO; |
||
... |
... |
||
File("input.txt")->Size()->PrintLine(); |
File("input.txt")->Size()->PrintLine(); |
||
File("c:\input.txt")->Size()->PrintLine(); |
File("c:\input.txt")->Size()->PrintLine(); |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Objective-C}}== |
=={{header|Objective-C}}== |
||
< |
<syntaxhighlight lang="objc">NSFileManager *fm = [NSFileManager defaultManager]; |
||
// Pre-OS X 10.5 |
// Pre-OS X 10.5 |
||
Line 1,127: | Line 1,127: | ||
// OS X 10.5+ |
// OS X 10.5+ |
||
NSLog(@"%llu", [[fm attributesOfItemAtPath:@"input.txt" error:NULL] fileSize]);</ |
NSLog(@"%llu", [[fm attributesOfItemAtPath:@"input.txt" error:NULL] fileSize]);</syntaxhighlight> |
||
=={{header|OCaml}}== |
=={{header|OCaml}}== |
||
< |
<syntaxhighlight lang="ocaml">let printFileSize filename = |
||
let ic = open_in filename in |
let ic = open_in filename in |
||
Printf.printf "%d\n" (in_channel_length ic); |
Printf.printf "%d\n" (in_channel_length ic); |
||
Line 1,137: | Line 1,137: | ||
printFileSize "input.txt" ;; |
printFileSize "input.txt" ;; |
||
printFileSize "/input.txt" ;;</ |
printFileSize "/input.txt" ;;</syntaxhighlight> |
||
For files greater than Pervasives.max_int, one can use the module [http://caml.inria.fr/pub/docs/manual-ocaml/libref/Pervasives.LargeFile.html Pervasives.LargeFile]: |
For files greater than Pervasives.max_int, one can use the module [http://caml.inria.fr/pub/docs/manual-ocaml/libref/Pervasives.LargeFile.html Pervasives.LargeFile]: |
||
< |
<syntaxhighlight lang="ocaml">let printLargeFileSize filename = |
||
let ic = open_in filename in |
let ic = open_in filename in |
||
Printf.printf "%Ld\n" (LargeFile.in_channel_length ic); |
Printf.printf "%Ld\n" (LargeFile.in_channel_length ic); |
||
close_in ic ;;</ |
close_in ic ;;</syntaxhighlight> |
||
Alternatively: |
Alternatively: |
||
< |
<syntaxhighlight lang="ocaml">#load "unix.cma" ;; |
||
open Unix ;; |
open Unix ;; |
||
Printf.printf "%d\n" (stat "input.txt").st_size ;; |
Printf.printf "%d\n" (stat "input.txt").st_size ;; |
||
Printf.printf "%d\n" (stat "/input.txt").st_size ;;</ |
Printf.printf "%d\n" (stat "/input.txt").st_size ;;</syntaxhighlight> |
||
The module Unix has also a [http://caml.inria.fr/pub/docs/manual-ocaml/libref/Unix.LargeFile.html LargeFile sub-module]. |
The module Unix has also a [http://caml.inria.fr/pub/docs/manual-ocaml/libref/Unix.LargeFile.html LargeFile sub-module]. |
||
Line 1,155: | Line 1,155: | ||
=={{header|Oforth}}== |
=={{header|Oforth}}== |
||
< |
<syntaxhighlight lang="oforth">File new("input.txt") size println |
||
File new("/input.txt") size println</ |
File new("/input.txt") size println</syntaxhighlight> |
||
=={{header|ooRexx}}== |
=={{header|ooRexx}}== |
||
< |
<syntaxhighlight lang="oorexx">Parse Version v |
||
Say v |
Say v |
||
fid='test.txt' |
fid='test.txt' |
||
Line 1,171: | Line 1,171: | ||
Say length(s) |
Say length(s) |
||
Say 'file' fid |
Say 'file' fid |
||
'type' fid</ |
'type' fid</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>J:\>rexx sft |
<pre>J:\>rexx sft |
||
Line 1,185: | Line 1,185: | ||
=={{header|Oz}}== |
=={{header|Oz}}== |
||
< |
<syntaxhighlight lang="oz">declare |
||
[Path] = {Module.link ['x-oz://system/os/Path.ozf']} |
[Path] = {Module.link ['x-oz://system/os/Path.ozf']} |
||
in |
in |
||
{Show {Path.size "input.txt"}} |
{Show {Path.size "input.txt"}} |
||
{Show {Path.size "/input.txt"}}</ |
{Show {Path.size "/input.txt"}}</syntaxhighlight> |
||
=={{header|Pascal}}== |
=={{header|Pascal}}== |
||
Line 1,196: | Line 1,196: | ||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
< |
<syntaxhighlight lang="perl">my $size1 = -s 'input.txt'; |
||
my $size2 = -s '/input.txt';</ |
my $size2 = -s '/input.txt';</syntaxhighlight> |
||
Or, to be 100% cross-platform: |
Or, to be 100% cross-platform: |
||
< |
<syntaxhighlight lang="perl">use File::Spec::Functions qw(catfile rootdir); |
||
my $size1 = -s 'input.txt'; |
my $size1 = -s 'input.txt'; |
||
my $size2 = -s catfile rootdir, 'input.txt';</ |
my $size2 = -s catfile rootdir, 'input.txt';</syntaxhighlight> |
||
Alternative way to get the size: |
Alternative way to get the size: |
||
< |
<syntaxhighlight lang="perl">my $size1 = (stat 'input.txt')[7]; # builtin stat() returns an array with file size at index 7 |
||
my $size2 = (stat '/input.txt')[7];</ |
my $size2 = (stat '/input.txt')[7];</syntaxhighlight> |
||
=={{header|Phix}}== |
=={{header|Phix}}== |
||
{{libheader|Phix/basics}} |
{{libheader|Phix/basics}} |
||
<!--< |
<!--<syntaxhighlight lang="phix">--> |
||
<span style="color: #008080;">function</span> <span style="color: #000000;">file_size<span style="color: #0000FF;">(<span style="color: #004080;">sequence</span> <span style="color: #000000;">file_name<span style="color: #0000FF;">)</span> |
<span style="color: #008080;">function</span> <span style="color: #000000;">file_size<span style="color: #0000FF;">(<span style="color: #004080;">sequence</span> <span style="color: #000000;">file_name<span style="color: #0000FF;">)</span> |
||
<span style="color: #004080;">object</span> <span style="color: #000000;">d</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">dir<span style="color: #0000FF;">(<span style="color: #000000;">file_name<span style="color: #0000FF;">)</span> |
<span style="color: #004080;">object</span> <span style="color: #000000;">d</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">dir<span style="color: #0000FF;">(<span style="color: #000000;">file_name<span style="color: #0000FF;">)</span> |
||
Line 1,228: | Line 1,228: | ||
<span style="color: #000000;">test<span style="color: #0000FF;">(<span style="color: #008000;">"input.txt"<span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- in the current working directory</span> |
<span style="color: #000000;">test<span style="color: #0000FF;">(<span style="color: #008000;">"input.txt"<span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- in the current working directory</span> |
||
<span style="color: #000000;">test<span style="color: #0000FF;">(<span style="color: #008000;">"/input.txt"<span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- in the file system root |
<span style="color: #000000;">test<span style="color: #0000FF;">(<span style="color: #008000;">"/input.txt"<span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- in the file system root |
||
<!--</ |
<!--</syntaxhighlight>--> |
||
=={{header|PHP}}== |
=={{header|PHP}}== |
||
< |
<syntaxhighlight lang="php"><?php |
||
echo filesize('input.txt'), "\n"; |
echo filesize('input.txt'), "\n"; |
||
echo filesize('/input.txt'), "\n"; |
echo filesize('/input.txt'), "\n"; |
||
?></ |
?></syntaxhighlight> |
||
=={{header|PicoLisp}}== |
=={{header|PicoLisp}}== |
||
< |
<syntaxhighlight lang="picolisp">(println (car (info "input.txt"))) |
||
(println (car (info "/input.txt")))</ |
(println (car (info "/input.txt")))</syntaxhighlight> |
||
=={{header|Pike}}== |
=={{header|Pike}}== |
||
< |
<syntaxhighlight lang="pike">import Stdio; |
||
int main(){ |
int main(){ |
||
write(file_size("input.txt") + "\n"); |
write(file_size("input.txt") + "\n"); |
||
write(file_size("/input.txt") + "\n"); |
write(file_size("/input.txt") + "\n"); |
||
}</ |
}</syntaxhighlight> |
||
=={{header|PL/I}}== |
=={{header|PL/I}}== |
||
<syntaxhighlight lang="pl/i"> |
|||
<lang PL/I> |
|||
/* To obtain file size of files in root as well as from current directory. */ |
/* To obtain file size of files in root as well as from current directory. */ |
||
Line 1,276: | Line 1,276: | ||
put skip list ('local file size=' || trim(i)); |
put skip list ('local file size=' || trim(i)); |
||
end test; |
end test; |
||
</syntaxhighlight> |
|||
</lang> |
|||
<pre> |
<pre> |
||
I used differently-named files to prove that local and root directory |
I used differently-named files to prove that local and root directory |
||
Line 1,285: | Line 1,285: | ||
=={{header|Pop11}}== |
=={{header|Pop11}}== |
||
< |
<syntaxhighlight lang="pop11">;;; prints file size in bytes |
||
sysfilesize('input.txt') => |
sysfilesize('input.txt') => |
||
sysfilesize('/input.txt') =></ |
sysfilesize('/input.txt') =></syntaxhighlight> |
||
=={{header|PostScript}}== |
=={{header|PostScript}}== |
||
<code>status</code> returns status information about a file if given a file name. This includes the size in pages (implementation-dependent), the size in bytes, creation and modification time and a final <code>true</code>. The values not needed here are simply <code>pop</code>ed off the stack. |
<code>status</code> returns status information about a file if given a file name. This includes the size in pages (implementation-dependent), the size in bytes, creation and modification time and a final <code>true</code>. The values not needed here are simply <code>pop</code>ed off the stack. |
||
< |
<syntaxhighlight lang="postscript">(input.txt ) print |
||
(input.txt) status pop pop pop = pop |
(input.txt) status pop pop pop = pop |
||
(/input.txt ) print |
(/input.txt ) print |
||
(/input.txt) status pop pop pop = pop</ |
(/input.txt) status pop pop pop = pop</syntaxhighlight> |
||
=={{header|PowerShell}}== |
=={{header|PowerShell}}== |
||
< |
<syntaxhighlight lang="powershell">Get-ChildItem input.txt | Select-Object Name,Length |
||
Get-ChildItem \input.txt | Select-Object Name,Length</ |
Get-ChildItem \input.txt | Select-Object Name,Length</syntaxhighlight> |
||
=={{header|PureBasic}}== |
=={{header|PureBasic}}== |
||
< |
<syntaxhighlight lang="purebasic">Debug FileSize("input.txt") |
||
Debug FileSize("/input.txt")</ |
Debug FileSize("/input.txt")</syntaxhighlight> |
||
=={{header|Python}}== |
=={{header|Python}}== |
||
< |
<syntaxhighlight lang="python">import os |
||
size = os.path.getsize('input.txt') |
size = os.path.getsize('input.txt') |
||
size = os.path.getsize('/input.txt')</ |
size = os.path.getsize('/input.txt')</syntaxhighlight> |
||
=={{header|R}}== |
=={{header|R}}== |
||
Line 1,316: | Line 1,316: | ||
R has a function file.info() in the base package that performs this function. Note that regardless of the OS, R uses forward slashes for the directories. |
R has a function file.info() in the base package that performs this function. Note that regardless of the OS, R uses forward slashes for the directories. |
||
< |
<syntaxhighlight lang="r">sizeinwd <- file.info('input.txt')[["size"]] |
||
sizeinroot <- file.info('/input.txt')[["size"]]</ |
sizeinroot <- file.info('/input.txt')[["size"]]</syntaxhighlight> |
||
=={{header|Racket}}== |
=={{header|Racket}}== |
||
< |
<syntaxhighlight lang="racket">#lang racket |
||
(file-size "input.txt") |
(file-size "input.txt") |
||
(file-size "/input.txt")</ |
(file-size "/input.txt")</syntaxhighlight> |
||
=={{header|Raku}}== |
=={{header|Raku}}== |
||
(formerly Perl 6) |
(formerly Perl 6) |
||
{{works with|Rakudo|2015.12}} |
{{works with|Rakudo|2015.12}} |
||
<lang |
<syntaxhighlight lang="raku" line>say 'input.txt'.IO.s; |
||
say '/input.txt'.IO.s;</ |
say '/input.txt'.IO.s;</syntaxhighlight> |
||
Cross-platform version of the second one: |
Cross-platform version of the second one: |
||
<lang |
<syntaxhighlight lang="raku" line>say $*SPEC.rootdir.IO.child("input.txt").s;</syntaxhighlight> |
||
=={{header|RapidQ}}== |
=={{header|RapidQ}}== |
||
Line 1,338: | Line 1,338: | ||
Method 1: display file size using file streams |
Method 1: display file size using file streams |
||
< |
<syntaxhighlight lang="rapidq">$INCLUDE "rapidq.inc" |
||
DIM file AS QFileStream |
DIM file AS QFileStream |
||
Line 1,349: | Line 1,349: | ||
PRINT "Size of input.txt is "; fileSize("input.txt") |
PRINT "Size of input.txt is "; fileSize("input.txt") |
||
PRINT "Size of \input.txt is "; fileSize("\input.txt")</ |
PRINT "Size of \input.txt is "; fileSize("\input.txt")</syntaxhighlight> |
||
Method 2: using DIR$ |
Method 2: using DIR$ |
||
< |
<syntaxhighlight lang="rapidq">FileName$ = DIR$("input.txt", 0) |
||
PRINT "Size of input.txt is "; FileRec.Size |
PRINT "Size of input.txt is "; FileRec.Size |
||
FileName$ = DIR$("\input.txt", 0) |
FileName$ = DIR$("\input.txt", 0) |
||
PRINT "Size of \input.txt is "; FileRec.Size</ |
PRINT "Size of \input.txt is "; FileRec.Size</syntaxhighlight> |
||
=={{header|Raven}}== |
=={{header|Raven}}== |
||
< |
<syntaxhighlight lang="raven">'input.txt' status.size |
||
'/input.txt' status.size</ |
'/input.txt' status.size</syntaxhighlight> |
||
=={{header|REBOL}}== |
=={{header|REBOL}}== |
||
< |
<syntaxhighlight lang="rebol">size? %info.txt |
||
size? %/info.txt |
size? %/info.txt |
||
size? ftp://username:password@ftp.site.com/info.txt |
size? ftp://username:password@ftp.site.com/info.txt |
||
size? http://rosettacode.org</ |
size? http://rosettacode.org</syntaxhighlight> |
||
=={{header|Red}}== |
=={{header|Red}}== |
||
< |
<syntaxhighlight lang="red">>> size? %input.txt |
||
== 39244 |
== 39244 |
||
>> size? %/c/input.txt |
>> size? %/c/input.txt |
||
== 39244</ |
== 39244</syntaxhighlight> |
||
=={{header|Retro}}== |
=={{header|Retro}}== |
||
The simple way is to open and read the size. This may crash if the file does not exist. |
The simple way is to open and read the size. This may crash if the file does not exist. |
||
< |
<syntaxhighlight lang="retro">with files' |
||
"input.txt" :R open &size sip close drop putn |
"input.txt" :R open &size sip close drop putn |
||
"/input.txt" :R open &size sip close drop putn</ |
"/input.txt" :R open &size sip close drop putn</syntaxhighlight> |
||
For added stability, check that the returned file handle is not zero: |
For added stability, check that the returned file handle is not zero: |
||
< |
<syntaxhighlight lang="retro">with files' |
||
"input.txt" :R open over 0 <> [ &size sip close drop ] ifTrue</ |
"input.txt" :R open over 0 <> [ &size sip close drop ] ifTrue</syntaxhighlight> |
||
Or, if you need to do this more often, setup a function that'll also display an error message if the file does not exist: |
Or, if you need to do this more often, setup a function that'll also display an error message if the file does not exist: |
||
< |
<syntaxhighlight lang="retro">with files' |
||
: getFileSize ( $-n ) |
: getFileSize ( $-n ) |
||
:R open 0 over = |
:R open 0 over = |
||
Line 1,395: | Line 1,395: | ||
"input.txt" getFileSize putn |
"input.txt" getFileSize putn |
||
"/input.txt" getFileSize putn</ |
"/input.txt" getFileSize putn</syntaxhighlight> |
||
=={{header|REXX}}== |
=={{header|REXX}}== |
||
Line 1,405: | Line 1,405: | ||
Note that some operating systems don't have a concept of a ''current directory'' or a ''file system root''. |
Note that some operating systems don't have a concept of a ''current directory'' or a ''file system root''. |
||
< |
<syntaxhighlight lang="rexx">/*REXX program determines a file's size (by reading all the data) in current dir & root.*/ |
||
parse arg iFID . /*allow the user specify the file ID. */ |
parse arg iFID . /*allow the user specify the file ID. */ |
||
if iFID=='' | iFID=="," then iFID='input.txt' /*Not specified? Then use the default.*/ |
if iFID=='' | iFID=="," then iFID='input.txt' /*Not specified? Then use the default.*/ |
||
Line 1,414: | Line 1,414: | ||
fSize: parse arg f; $=0; do while chars(f)\==0; $ = $ + length( charin( f, , 1e4) ) |
fSize: parse arg f; $=0; do while chars(f)\==0; $ = $ + length( charin( f, , 1e4) ) |
||
end /*while*/; call lineout f /*close file.*/ |
end /*while*/; call lineout f /*close file.*/ |
||
return $</ |
return $</syntaxhighlight> |
||
{{out|output|text= when using the default input:}} |
{{out|output|text= when using the default input:}} |
||
<pre> |
<pre> |
||
Line 1,422: | Line 1,422: | ||
===MS DOS version 2=== |
===MS DOS version 2=== |
||
< |
<syntaxhighlight lang="rexx">/*REXX pgm to verify a file's size */ |
||
parse arg iFID . /*let user specify the file ID. */ |
parse arg iFID . /*let user specify the file ID. */ |
||
if iFID=='' then iFID="FILESIZ.DAT" /*Not specified? Then use default*/ |
if iFID=='' then iFID="FILESIZ.DAT" /*Not specified? Then use default*/ |
||
Line 1,437: | Line 1,437: | ||
sz=sz+length(linein(f)) |
sz=sz+length(linein(f)) |
||
End |
End |
||
return sz</ |
return sz</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>size of FILESIZ.DAT: |
<pre>size of FILESIZ.DAT: |
||
Line 1,446: | Line 1,446: | ||
Note that CMS hasn't a concept of a ''root''. |
Note that CMS hasn't a concept of a ''root''. |
||
<br>Also note that the CMS system doesn't normally support the use of periods ('''.'''); it uses blanks instead. |
<br>Also note that the CMS system doesn't normally support the use of periods ('''.'''); it uses blanks instead. |
||
< |
<syntaxhighlight lang="rexx">/*REXX program determines a file's size (by reading all the data) on the default mDisk.*/ |
||
parse arg iFID /*allow the user specify the file ID. */ |
parse arg iFID /*allow the user specify the file ID. */ |
||
if iFID=='' | iFID=="," then iFID= 'INPUT TXT' /*Not specified? Then use the default.*/ |
if iFID=='' | iFID=="," then iFID= 'INPUT TXT' /*Not specified? Then use the default.*/ |
||
Line 1,454: | Line 1,454: | ||
fSize: parse arg f; $= 0; do while lines(f)\==0; $= $ + length( linein(f) ) |
fSize: parse arg f; $= 0; do while lines(f)\==0; $= $ + length( linein(f) ) |
||
end /*while*/ |
end /*while*/ |
||
return $</ |
return $</syntaxhighlight><br> |
||
=={{header|Ring}}== |
=={{header|Ring}}== |
||
< |
<syntaxhighlight lang="ring">See len(read('input.txt')) + nl |
||
see len(read('/input.txt')) + nl</ |
see len(read('/input.txt')) + nl</syntaxhighlight> |
||
=={{header|Ruby}}== |
=={{header|Ruby}}== |
||
< |
<syntaxhighlight lang="ruby">size = File.size('input.txt') |
||
size = File.size('/input.txt')</ |
size = File.size('/input.txt')</syntaxhighlight> |
||
=={{header|Run BASIC}}== |
=={{header|Run BASIC}}== |
||
< |
<syntaxhighlight lang="runbasic">print fileSize(DefaultDir$,"input.txt") ' current default directory |
||
print fileSize("","input.txt") ' root directory |
print fileSize("","input.txt") ' root directory |
||
Line 1,472: | Line 1,472: | ||
fileSize = lof(#f) ' Length Of File |
fileSize = lof(#f) ' Length Of File |
||
close #f |
close #f |
||
end function</ |
end function</syntaxhighlight> |
||
=={{header|Rust}}== |
=={{header|Rust}}== |
||
< |
<syntaxhighlight lang="rust">use std::{env, fs, process}; |
||
use std::io::{self, Write}; |
use std::io::{self, Write}; |
||
use std::fmt::Display; |
use std::fmt::Display; |
||
Line 1,492: | Line 1,492: | ||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Scala}}== |
=={{header|Scala}}== |
||
{{libheader|Scala}} |
{{libheader|Scala}} |
||
< |
<syntaxhighlight lang="scala">import java.io.File |
||
object FileSize extends App { |
object FileSize extends App { |
||
Line 1,503: | Line 1,503: | ||
println(s"$name : ${new File(name).length()} bytes") |
println(s"$name : ${new File(name).length()} bytes") |
||
println(s"/$name : ${new File(s"${File.separator}$name").length()} bytes") |
println(s"/$name : ${new File(s"${File.separator}$name").length()} bytes") |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Scheme}}== |
=={{header|Scheme}}== |
||
< |
<syntaxhighlight lang="scheme"> |
||
(define (file-size filename) |
(define (file-size filename) |
||
(call-with-input-file filename (lambda (port) |
(call-with-input-file filename (lambda (port) |
||
Line 1,517: | Line 1,517: | ||
(file-size "input.txt") |
(file-size "input.txt") |
||
(file-size "/input.txt") |
(file-size "/input.txt") |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Seed7}}== |
=={{header|Seed7}}== |
||
< |
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i"; |
||
const proc: main is func |
const proc: main is func |
||
Line 1,526: | Line 1,526: | ||
writeln(fileSize("input.txt")); |
writeln(fileSize("input.txt")); |
||
writeln(fileSize("/input.txt")); |
writeln(fileSize("/input.txt")); |
||
end func;</ |
end func;</syntaxhighlight> |
||
=={{header|Sidef}}== |
=={{header|Sidef}}== |
||
< |
<syntaxhighlight lang="ruby">say (Dir.cwd + %f'input.txt' -> size); |
||
say (Dir.root + %f'input.txt' -> size);</ |
say (Dir.root + %f'input.txt' -> size);</syntaxhighlight> |
||
=={{header|Slate}}== |
=={{header|Slate}}== |
||
< |
<syntaxhighlight lang="slate">(File newNamed: 'input.txt') fileInfo fileSize. |
||
(File newNamed: '/input.txt') fileInfo fileSize.</ |
(File newNamed: '/input.txt') fileInfo fileSize.</syntaxhighlight> |
||
=={{header|Smalltalk}}== |
=={{header|Smalltalk}}== |
||
{{works with|GNU Smalltalk}} |
{{works with|GNU Smalltalk}} |
||
< |
<syntaxhighlight lang="smalltalk">(File name: 'input.txt') size printNl. |
||
(File name: '/input.txt') size printNl.</ |
(File name: '/input.txt') size printNl.</syntaxhighlight> |
||
{{works with|Smalltalk/X}} |
{{works with|Smalltalk/X}} |
||
{{works with|VisualWorks Smalltalk}} |
{{works with|VisualWorks Smalltalk}} |
||
< |
<syntaxhighlight lang="smalltalk">'input.txt' asFilename fileSize |
||
'/input.txt' asFilename fileSize</ |
'/input.txt' asFilename fileSize</syntaxhighlight> |
||
=={{header|Standard ML}}== |
=={{header|Standard ML}}== |
||
< |
<syntaxhighlight lang="sml">val size = OS.FileSys.fileSize "input.txt" ;; |
||
val size = OS.FileSys.fileSize "/input.txt" ;</ |
val size = OS.FileSys.fileSize "/input.txt" ;</syntaxhighlight> |
||
=={{header|Stata}}== |
=={{header|Stata}}== |
||
Line 1,554: | Line 1,554: | ||
To get the size in byte of an arbitrary file, use [http://www.stata.com/help.cgi?file file seek]. Just replace input.txt with \input.txt if the file resides in the root directory of the current disk. |
To get the size in byte of an arbitrary file, use [http://www.stata.com/help.cgi?file file seek]. Just replace input.txt with \input.txt if the file resides in the root directory of the current disk. |
||
< |
<syntaxhighlight lang="stata">file open f using input.txt, read binary |
||
file seek f eof |
file seek f eof |
||
file seek f query |
file seek f query |
||
display r(loc) |
display r(loc) |
||
file close f</ |
file close f</syntaxhighlight> |
||
However, what is usually interesting is the size of a datatset. Use [http://www.stata.com/help.cgi?describe describe], either on the currently loaded dataset, or on a dataset on disk. The describe command will print the file size, but it's possible to use [http://www.stata.com/help.cgi?stored_results stored results] as well. |
However, what is usually interesting is the size of a datatset. Use [http://www.stata.com/help.cgi?describe describe], either on the currently loaded dataset, or on a dataset on disk. The describe command will print the file size, but it's possible to use [http://www.stata.com/help.cgi?stored_results stored results] as well. |
||
< |
<syntaxhighlight lang="stata">describe using test.dta |
||
display r(N)*r(width)</ |
display r(N)*r(width)</syntaxhighlight> |
||
=={{header|Tcl}}== |
=={{header|Tcl}}== |
||
< |
<syntaxhighlight lang="tcl">file size input.txt |
||
file size /input.txt</ |
file size /input.txt</syntaxhighlight> |
||
=={{header|Toka}}== |
=={{header|Toka}}== |
||
A trivial method follows: |
A trivial method follows: |
||
< |
<syntaxhighlight lang="toka">" input.txt" "R" file.open dup file.size . file.close |
||
" /input.txt" "R" file.open dup file.size . file.close</ |
" /input.txt" "R" file.open dup file.size . file.close</syntaxhighlight> |
||
A better method would be to define a new function that actually |
A better method would be to define a new function that actually |
||
checks whether the file exists: |
checks whether the file exists: |
||
< |
<syntaxhighlight lang="toka">[ "R" file.open |
||
dup 0 <> [ dup file.size . file.close ] ifTrue |
dup 0 <> [ dup file.size . file.close ] ifTrue |
||
drop |
drop |
||
Line 1,584: | Line 1,584: | ||
" input.txt" display-size |
" input.txt" display-size |
||
" /input.txt" display-size</ |
" /input.txt" display-size</syntaxhighlight> |
||
=={{header|TorqueScript}}== |
=={{header|TorqueScript}}== |
||
Line 1,592: | Line 1,592: | ||
TGE Version (Works with all versions containing the basic file i/o): |
TGE Version (Works with all versions containing the basic file i/o): |
||
{{works with|TGE}} |
{{works with|TGE}} |
||
< |
<syntaxhighlight lang="torque">%File = new FileObject(); |
||
%File.openForRead("input.txt"); |
%File.openForRead("input.txt"); |
||
Line 1,601: | Line 1,601: | ||
%File.close(); |
%File.close(); |
||
%File.delete();</ |
%File.delete();</syntaxhighlight> |
||
<br /> |
<br /> |
||
T3D Version (Only works with T3D): |
T3D Version (Only works with T3D): |
||
{{works with|T3D}} |
{{works with|T3D}} |
||
< |
<syntaxhighlight lang="torque">fileSize("input.txt");</syntaxhighlight> |
||
=={{header|TUSCRIPT}}== |
=={{header|TUSCRIPT}}== |
||
< |
<syntaxhighlight lang="tuscript"> |
||
$$ MODE TUSCRIPT |
$$ MODE TUSCRIPT |
||
-- size of file input.txt |
-- size of file input.txt |
||
Line 1,620: | Line 1,620: | ||
file_size=BYTES (file) |
file_size=BYTES (file) |
||
ERROR/STOP CLOSE (file) |
ERROR/STOP CLOSE (file) |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|UNIX Shell}}== |
=={{header|UNIX Shell}}== |
||
Line 1,628: | Line 1,628: | ||
''ls'' most likely gets the length from the file's inode. |
''ls'' most likely gets the length from the file's inode. |
||
< |
<syntaxhighlight lang="bash">size1=$(ls -l input.txt | tr -s ' ' | cut -d ' ' -f 5) |
||
size2=$(ls -l /input.txt | tr -s ' ' | cut -d ' ' -f 5)</ |
size2=$(ls -l /input.txt | tr -s ' ' | cut -d ' ' -f 5)</syntaxhighlight> |
||
''ls -l'' reports the size in 5th field, with spaces between fields. |
''ls -l'' reports the size in 5th field, with spaces between fields. |
||
Line 1,635: | Line 1,635: | ||
and ''cut'' extracts 5th field. |
and ''cut'' extracts 5th field. |
||
< |
<syntaxhighlight lang="bash"> |
||
echo "# ls:" |
echo "# ls:" |
||
ls -la input.txt |
ls -la input.txt |
||
Line 1,646: | Line 1,646: | ||
size2=$(wc -c < input.txt | tr -d ' ') |
size2=$(wc -c < input.txt | tr -d ' ') |
||
echo $size1, $size2 |
echo $size1, $size2 |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{Out}} Test run at compileonline.com: |
{{Out}} Test run at compileonline.com: |
||
<pre> |
<pre> |
||
Line 1,666: | Line 1,666: | ||
''wc'' may actually read the whole file and count the bytes. Some implementations, like [http://git.savannah.gnu.org/cgit/coreutils.git/tree/src/wc.c wc.c] from GNU coreutils, can optimize ''wc -c'' by getting the length from the file's inode. |
''wc'' may actually read the whole file and count the bytes. Some implementations, like [http://git.savannah.gnu.org/cgit/coreutils.git/tree/src/wc.c wc.c] from GNU coreutils, can optimize ''wc -c'' by getting the length from the file's inode. |
||
< |
<syntaxhighlight lang="bash">size1=$(wc -c < input.txt | tr -d ' ') |
||
size2=$(wc -c < /input.txt | tr -d ' ')</ |
size2=$(wc -c < /input.txt | tr -d ' ')</syntaxhighlight> |
||
The peculiar use of ''wc -c < file'', not ''wc -c file'', is to prevent printing the file's name. Then ''wc'' only reports the size. Some versions of ''wc'' print spaces before the number; ''tr'' deletes all these spaces. |
The peculiar use of ''wc -c < file'', not ''wc -c file'', is to prevent printing the file's name. Then ''wc'' only reports the size. Some versions of ''wc'' print spaces before the number; ''tr'' deletes all these spaces. |
||
Line 1,678: | Line 1,678: | ||
{{works with|OpenBSD|3.8}} |
{{works with|OpenBSD|3.8}} |
||
< |
<syntaxhighlight lang="bash">size1=$(stat -f %z input.txt) |
||
size2=$(stat -f %z /input.txt)</ |
size2=$(stat -f %z /input.txt)</syntaxhighlight> |
||
===Z Shell=== |
===Z Shell=== |
||
{{works with|zsh}} |
{{works with|zsh}} |
||
< |
<syntaxhighlight lang="bash"># from module 'zsh/stat', load builtin 'zstat' |
||
zmodload -F zsh/stat b:zstat |
zmodload -F zsh/stat b:zstat |
||
size1=$(zstat +size input.txt) |
size1=$(zstat +size input.txt) |
||
size2=$(zstat +size /input.txt)</ |
size2=$(zstat +size /input.txt)</syntaxhighlight> |
||
=={{header|Ursa}}== |
=={{header|Ursa}}== |
||
< |
<syntaxhighlight lang="ursa">decl file f |
||
f.open "input.txt" |
f.open "input.txt" |
||
Line 1,699: | Line 1,699: | ||
f.open "/input.txt" |
f.open "/input.txt" |
||
out (size f) endl console |
out (size f) endl console |
||
f.close</ |
f.close</syntaxhighlight> |
||
=={{header|VBScript}}== |
=={{header|VBScript}}== |
||
{{works with|Windows Script Host|*}} |
{{works with|Windows Script Host|*}} |
||
<syntaxhighlight lang="vbscript"> |
|||
<lang VBScript> |
|||
With CreateObject("Scripting.FileSystemObject") |
With CreateObject("Scripting.FileSystemObject") |
||
WScript.Echo .GetFile("input.txt").Size |
WScript.Echo .GetFile("input.txt").Size |
||
WScript.Echo .GetFile("\input.txt").Size |
WScript.Echo .GetFile("\input.txt").Size |
||
End With |
End With |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Vedit macro language}}== |
=={{header|Vedit macro language}}== |
||
< |
<syntaxhighlight lang="vedit">Num_Type(File_Size("input.txt")) |
||
Num_Type(File_Size("/input.txt"))</ |
Num_Type(File_Size("/input.txt"))</syntaxhighlight> |
||
=={{header|Visual Basic}}== |
=={{header|Visual Basic}}== |
||
{{works with|Visual Basic|6}} |
{{works with|Visual Basic|6}} |
||
< |
<syntaxhighlight lang="vb">Option Explicit |
||
---- |
---- |
||
Line 1,741: | Line 1,741: | ||
DisplayFileSize Environ$("SystemRoot"), "input.txt" |
DisplayFileSize Environ$("SystemRoot"), "input.txt" |
||
End Sub |
End Sub |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre>file size: 37 Bytes |
<pre>file size: 37 Bytes |
||
Line 1,752: | Line 1,752: | ||
{{works with|Visual Basic .NET|9.0+}} |
{{works with|Visual Basic .NET|9.0+}} |
||
< |
<syntaxhighlight lang="vbnet">Dim local As New IO.FileInfo("input.txt") |
||
Console.WriteLine(local.Length) |
Console.WriteLine(local.Length) |
||
Dim root As New IO.FileInfo("\input.txt") |
Dim root As New IO.FileInfo("\input.txt") |
||
Console.WriteLine(root.Length)</ |
Console.WriteLine(root.Length)</syntaxhighlight> |
||
=={{header|Wren}}== |
=={{header|Wren}}== |
||
Line 1,762: | Line 1,762: | ||
To check the size of a file in the root, just change "input.txt" to "/input.txt" in the following script. |
To check the size of a file in the root, just change "input.txt" to "/input.txt" in the following script. |
||
< |
<syntaxhighlight lang="ecmascript">import "io" for File |
||
var name = "input.txt" |
var name = "input.txt" |
||
System.print("'%(name)' has a a size of %(File.size(name)) bytes")</ |
System.print("'%(name)' has a a size of %(File.size(name)) bytes")</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 1,773: | Line 1,773: | ||
=={{header|X86 Assembly}}== |
=={{header|X86 Assembly}}== |
||
< |
<syntaxhighlight lang="x86asm"> |
||
; x86_64 linux nasm |
; x86_64 linux nasm |
||
Line 1,842: | Line 1,842: | ||
mov rdi, 1 |
mov rdi, 1 |
||
syscall |
syscall |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|XPL0}}== |
=={{header|XPL0}}== |
||
< |
<syntaxhighlight lang="xpl0">proc ShowSize(FileName); |
||
char FileName; int Size, C; |
char FileName; int Size, C; |
||
[Trap(false); \disable abort on error |
[Trap(false); \disable abort on error |
||
Line 1,859: | Line 1,859: | ||
[ShowSize("input.txt"); |
[ShowSize("input.txt"); |
||
ShowSize("/input.txt"); \root under Linux |
ShowSize("/input.txt"); \root under Linux |
||
]</ |
]</syntaxhighlight> |
||
=={{header|zkl}}== |
=={{header|zkl}}== |
||
< |
<syntaxhighlight lang="zkl">File.info("input.txt").println(); |
||
File.info("/input.txt").println();</ |
File.info("/input.txt").println();</syntaxhighlight> |
||
-->T(size,creation time,last mod time,isDir,mode), from stat(2) |
-->T(size,creation time,last mod time,isDir,mode), from stat(2) |
||
{{out}} |
{{out}} |
Revision as of 12:44, 27 August 2022
You are encouraged to solve this task according to the task description, using any language you may know.
Verify the size of a file called input.txt for a file in the current working directory, and another one in the file system root.
11l
V size1 = fs:file_size(‘input.txt’)
V size2 = fs:file_size(‘/input.txt’)
8086 Assembly
This program runs under MS-DOS.
putch: equ 2 ; Print character
puts: equ 9 ; Print $-terminated string
setdta: equ 1Ah ; Set DTA
stat: equ 4Eh ; Get file info
cpu 8086
bits 16
org 100h
section .text
mov si,curf ; Print file size for 'INPUT.TXT'
call pfsize ; (in current directory),
mov si,rootf ; Then for '\INPUT.TXT' in root directory
;;; Print file name and size for file in DS:SI
pfsize: mov ah,setdta ; Set disc transfer area pointer
mov dx,dta
int 21h
call puts0 ; Print the filename in SI
mov ah,puts ; Print colon and space
mov dx,colspc
int 21h
mov ah,stat ; Find file info
xor cx,cx ; We want a normal file
mov dx,si ; Filename is in SI
int 21h
jnc .ok ; Carry clear = found
mov ah,puts ; Carry set = not found = print 'not found'
mov dx,nofile
int 21h
ret
.ok: les bp,[dta+26] ; 32-bit file size in bytes at DTA+26
mov di,es ; DI:BP = 32-bit file size
mov bx,numbuf ; ASCII number buffer
mov cx,10 ; Divisor (10)
.dgt: xor dx,dx ; 32-bit division (to get digits)
mov ax,di ; can be done with chained DIVs
div cx
mov di,ax
mov ax,bp
div cx
mov bp,ax
add dl,'0' ; DX is now remainder, i.e. digit
dec bx ; Move digit pointer backwards,
mov [bx],dl ; Store ASCII digit,
or ax,di ; If the new divisor is not zero,
jnz .dgt ; then there is another digit.
mov ah,puts ; If so, the number is done,
mov dx,bx ; and we can print it.
int 21h
ret
;;; Print 0-terminated string in SI
puts0: push si ; Save SI register
mov ah,putch ; Print char syscall
.loop: lodsb ; Load character from SI
test al,al ; If zero,
jz .out ; then stop.
mov dl,al ; Tell DOS to print character
int 21h
jmp .loop ; go get another.
.out: pop si ; Restore SI register
ret
section .data
rootf: db '\' ; \INPUT.TXT (for root) and
curf: db 'INPUT.TXT',0 ; INPUT.TXT (for current directory)
nofile: db 'Not found.',13,10,'$' ; "Not found" message
db '0000000000' ; Number output buffer
numbuf: db ' bytes',13,10,'$'
colspc: db ': $' ; Colon and space
section .bss
dta: resb 512 ; Disc transfer area
- Output:
C:\>filesize INPUT.TXT: Not found. \INPUT.TXT: Not found. C:\>echo Hello! > INPUT.TXT C:\>filesize INPUT.TXT: 8 bytes. \INPUT.TXT: 8 bytes. C:\>cd testdir C:\TESTDIR>\filesize INPUT.TXT: Not found. \INPUT.TXT: 8 bytes C:\TESTDIR>echo Goodbye! > INPUT.TXT C:\TESTDIR>\filesize INPUT.TXT: 10 bytes \INPUT.TXT: 8 bytes
Action!
DOS 2.5
DOS 2.5 returns file size in number of sectors. It is required to read the whole file to calculate its size in bytes.
INCLUDE "D2:IO.ACT" ;from the Action! Tool Kit
PROC Dir(CHAR ARRAY filter)
BYTE dev=[1]
CHAR ARRAY line(255)
Close(dev)
Open(dev,filter,6)
DO
InputSD(dev,line)
PrintE(line)
IF line(0)=0 THEN
EXIT
FI
OD
Close(dev)
RETURN
CARD FUNC FileSize(CHAR ARRAY src,dst)
DEFINE BUF_LEN="100"
BYTE dev=[1]
BYTE ARRAY buff(BUF_LEN)
CARD len,size
size=0
Close(dev)
Open(dev,src,4)
DO
len=Bget(dev,buff,BUF_LEN)
size==+len
UNTIL len#BUF_LEN
OD
Close(dev)
RETURN (size)
PROC Main()
CHAR ARRAY filter="D:*.*", fname="D:INPUT.TXT"
CARD size
Put(125) PutE() ;clear screen
PrintF("Dir ""%S""%E",filter)
Dir(filter)
size=FileSize(fname)
PrintF("Size of ""%S"" is %U bytes%E",fname,size)
RETURN
- Output:
Dir "D:*.*" DOS SYS 037 DUP SYS 042 INPUT TXT 011 617 FREE SECTORS Size of "D:INPUT.TXT" is 1274 bytes
Sparta DOS X
The Sparta DOS X system stores the size of the file in the directory. The readout of the values is performed with the XIO 39 operation. In the ICAX3, ICAX4, ICAX5 registers values are returned in 24-byte format. Calculation according to the formula: ICAX3 + ICAX4 * 256 + ICAX5 * 65536.
INCLUDE"REAL.ACT" ;from the Action! Tool Kit
proc MAIN()
byte array astring
byte IOCB1=$350,ICAX3=IOCB1+12,ICAX4=IOCB1+13,ICAX5=IOCB1+14
real A,B,C,FLEN
open(1,"D:REAL.ACT",4,0) xio(1,0,39,"D:REAL.ACT") close(1)
IntToReal(ICAX3,FLEN)
IntToReal(ICAX4,A) astring="256" ValR(astring,B) RealMult(A,B,C) RealAdd(FLEN,C,FLEN)
IntToReal(ICAX5,A) astring="65536" ValR(astring,B) RealMult(A,B,C) RealAdd(FLEN,C,FLEN)
print("Size of REAL.ACT is ") printRD(DEVICE,FLEN) printe(" bytes")
return
- Output:
Size of D:REAL.ACT is 4995 bytes
Ada
with Ada.Directories; use Ada.Directories;
with Ada.Text_IO; use Ada.Text_IO;
procedure Test_File_Size is
begin
Put_Line (File_Size'Image (Size ("input.txt")) & " bytes");
Put_Line (File_Size'Image (Size ("/input.txt")) & " bytes");
end Test_File_Size;
Note that reference to the root directory, if there is any, is OS specific.
Aime
o_(stat("input.txt", ST_SIZE), "\n");
o_("/Cygwin.ico".stat(ST_SIZE), "\n");
ALGOL 68
There is no build in way to find the size of an arbitrary file, especially of the file is a special channel, e.g. a tape device.
Conceptually the procedure
PROC set = (REF FILE file, INT page, line, character)VOID: ~
could be used to do a binary search find the last page's page number. And if it is known that every page has the same number of lines, and every line has the same number of char[s], and the character set is not compressible, then the size could be quickly calculated. Otherwise every page, and every line would have to be tallied.
It is probably much easier to use some an operating system library. This library is not part of the standard ALGOL 68 language definition.
Arturo
print volume "input.txt"
print volume "/input.txt"
AutoHotkey
FileGetSize, FileSize, input.txt ; Retrieve the size in bytes.
MsgBox, Size of input.txt is %FileSize% bytes
FileGetSize, FileSize, \input.txt, K ; Retrieve the size in Kbytes.
MsgBox, Size of \input.txt is %FileSize% Kbytes
AWK
@load "filefuncs"
function filesize(name ,fd) {
if ( stat(name, fd) == -1)
return -1 # doesn't exist
else
return fd["size"]
}
BEGIN {
print filesize("input.txt")
print filesize("/input.txt")
}
Some awk's don't have direct access to the filesystem, but can execute system-commands like dir (DOS/Windows) and ls
BEGIN {
# Windows
printf("input.txt\t%s\n", system2var("for %I in (input.txt) do @echo %~zI"))
printf("\input.txt\t%s\n", system2var("for %I in (\input.txt) do @echo %~zI"))
# Non-Windows
printf("input.txt\t%s\n", getline2var("stat --printf=\"%s\" input.txt"))
printf("/input.txt\t%s\n", getline2var("stat --printf=\"%s\" /input.txt"))
}
# Windows system() method
function system2var(command ,tempfile, cmd, out, rec, data, i) {
tempfile = "C:\\TEMP\\TMP.TMP"
cmd = command " > " tempfile
system(cmd)
close(cmd)
while (getline rec < tempfile > 0) {
if ( ++i == 1 )
data = rec
else
data = data "\n" rec
}
return(data)
}
# Non-windows getline method
function getline2var(command ,fish, scale, ship) {
command = command " 2>/dev/null"
while ( (command | getline fish) > 0 ) {
if ( ++scale == 1 )
ship = fish
else
ship = ship "\n" fish
}
close(command)
return ship
}
See also UNIX_Shell]
Axe
If GetCalc("appvINPUT")→I
Disp {I-2}ʳ▶Dec,i
Else
Disp "NOT FOUND",i
End
BaCon
' file size
' Return the entire message, FILELEN returns a NUMBER
FUNCTION printlen$(STRING name$)
IF FILEEXISTS(name$) THEN
RETURN name$ & ": " & STR$(FILELEN(name$))
ELSE
RETURN "file " & name$ & " not found"
END IF
END FUNCTION
PRINT printlen$("input.txt")
PRINT printlen$("/input.txt")
- Output:
prompt$ bacon filelen.bac Converting 'filelen.bac'... done, 12 lines were processed in 0.004 seconds. Compiling 'filelen.bac'... cc -c filelen.bac.c cc -o filelen filelen.bac.o -lbacon -lm Done, program 'filelen' ready. prompt$ ./filelen input.txt: 15 file /input.txt not found
Batch File
Outputs file size of the first parameter (you can drag and drop a file in aswell).
@echo off
if not exist "%~1" exit /b 1 & rem If file doesn't exist exit with error code of 1.
for /f %%i in (%~1) do echo %~zi
pause>nul
BBC BASIC
file% = OPENIN(@dir$+"input.txt")
IF file% THEN
PRINT "File size = " ; EXT#file%
CLOSE #file%
ENDIF
file% = OPENIN("\input.txt")
IF file% THEN
PRINT "File size = " ; EXT#file%
CLOSE #file%
ENDIF
Bracmat
This solution assumes that the file can be opened for reading. The fil
function is the Bracmat interface to the underlying C functions fopen, fclose, fseek, ftell, fread, fgetc, fwrite, fputc
and feof
. More than one file can be opened at the same time. Focus is shifted from one open file to another by mentioning the file name as the first argument.
(getFileSize=
size
. fil$(!arg,rb) {read in binary mode}
& fil$(,END) {seek to end of file}
& fil$(,TEL):?size {tell where we are}
& fil$(,SET,-1) {seeking to an impossible position closes the file, and fails}
| !size {return the size}
);
getFileSize$"valid.bra"
113622
getFileSize$"c:\\boot.ini"
211
C
#include <stdlib.h>
#include <stdio.h>
long getFileSize(const char *filename)
{
long result;
FILE *fh = fopen(filename, "rb");
fseek(fh, 0, SEEK_END);
result = ftell(fh);
fclose(fh);
return result;
}
int main(void)
{
printf("%ld\n", getFileSize("input.txt"));
printf("%ld\n", getFileSize("/input.txt"));
return 0;
}
#include <stdlib.h>
#include <stdio.h>
#include <sys/stat.h>
int main(void)
{
struct stat foo;
stat("input.txt", &foo);
printf("%ld\n", foo.st_size);
stat("/input.txt", &foo);
printf("%ld\n", foo.st_size);
return 0;
}
C#
using System;
using System.IO;
class Program
{
static void Main(string[] args)
{
Console.WriteLine(new FileInfo("/input.txt").Length);
Console.WriteLine(new FileInfo("input.txt").Length);
}
}
C++
#include <iostream>
#include <fstream>
std::ios::off_type getFileSize(const char *filename) {
std::ifstream f(filename);
std::ios::pos_type begin = f.tellg();
f.seekg(0, std::ios::end);
std::ios::pos_type end = f.tellg();
return end - begin;
}
int main() {
std::cout << getFileSize("input.txt") << std::endl;
std::cout << getFileSize("/input.txt") << std::endl;
return 0;
}
optimized
#include <iostream>
#include <fstream>
int main()
{
std::cout << std::ifstream("input.txt", std::ios::binary | std::ios::ate).tellg() << "\n"
<< std::ifstream("/input.txt", std::ios::binary | std::ios::ate).tellg() << "\n";
}
C++ 17
#include <filesystem>
#include <iostream>
void print_file_size(const char* filename) {
try {
auto size = std::filesystem::file_size(filename);
std::cout << "Size of file " << filename << " is " << size << " bytes.\n";
} catch (const std::exception& ex) {
std::cerr << ex.what() << '\n';
}
}
int main() {
print_file_size("input.txt");
print_file_size("/input.txt");
}
- Output:
Size of file input.txt is 506 bytes. filesystem error: in file_size: No such file or directory [/input.txt]
Clean
There is not function to get the file size, therefore we seek to the end and query the file pointer position.
import StdEnv
fileSize fileName world
# (ok, file, world) = fopen fileName FReadData world
| not ok = abort "Cannot open file"
# (ok, file) = fseek file 0 FSeekEnd
| not ok = abort "Cannot seek file"
# (size, file) = fposition file
(_, world) = fclose file world
= (size, world)
Start world = fileSize "input.txt" world
Clojure
(require '[clojure.java.io :as io])
(defn show-size [filename]
(println filename "size:" (.length (io/file filename))))
(show-size "input.txt")
(show-size "/input.txt")
COBOL
identification division.
program-id. FileInfo.
data division.
working-storage section.
01 file-name pic x(256).
01 file-size-edited pic zzz,zzz,zzz.
01 file-details.
05 file-size pic x(8) comp-x.
05 file-date.
10 file-day pic x comp-x.
10 file-month pic x comp-x.
10 file-year pic xx comp-x.
05 file-time.
10 file-hour pic x comp-x.
10 file-minute pic x comp-x.
10 file-second pic x comp-x.
10 file-hundredths pic x comp-x.
procedure division.
main.
move "input.txt" to file-name
perform file-info
move "\input.txt" to file-name
perform file-info
stop run
.
file-info.
call "CBL_CHECK_FILE_EXIST"
using file-name, file-details
returning return-code
if return-code = 0
move file-size to file-size-edited
display function trim(file-name) " "
function trim(file-size-edited) " Bytes"
else
display function trim(file-name) " not found!"
end-if
.
ColdFusion
<cfscript>
localFile = getFileInfo(expandpath("input.txt"));
rootFile = getFileInfo("/input.txt");
</cfscript>
<cfoutput>
Size of input.txt is #localFile.size# bytes.
Size of /input.txt is #rootFile.size# bytes.
</cfoutput>
Common Lisp
(with-open-file (stream (make-pathname :name "input.txt")
:direction :input
:if-does-not-exist nil)
(print (if stream (file-length stream) 0)))
(with-open-file (stream (make-pathname :directory '(:absolute "") :name "input.txt")
:direction :input
:if-does-not-exist nil)
(print (if stream (file-length stream) 0)))
(osicat-posix:stat-size (osicat-posix:stat #P"input.txt"))
D
import std.file, std.stdio, std.path, std.file, std.stream,
std.mmfile;
void main() {
immutable fileName = "file_size.exe";
try {
writefln("File '%s' has size:", fileName);
writefln("%10d bytes by std.file.getSize (function)",
std.file.getSize(fileName));
writefln("%10d bytes by std.stream (class)",
new std.stream.File(fileName).size);
// mmfile can treat the file as an array in memory.
writefln("%10d bytes by std.mmfile (class)",
new std.mmfile.MmFile(fileName).length);
} catch (Exception e) {
e.msg.writefln;
}
}
- Output:
File 'file_size.exe' has size: 1066164 bytes by std.file.getSize (function) 1066164 bytes by std.stream (class) 1066164 bytes by std.mmfile (class)
Delphi
program SizeOfFile;
{$APPTYPE CONSOLE}
uses SysUtils;
function CheckFileSize(const aFilename: string): Integer;
var
lFile: file of Byte;
begin
AssignFile(lFile, aFilename);
FileMode := 0; {Access file in read only mode}
Reset(lFile);
Result := FileSize(lFile);
CloseFile(lFile);
end;
begin
Writeln('input.txt ', CheckFileSize('input.txt'));
Writeln('\input.txt ', CheckFileSize('\input.txt'));
end.
E
for file in [<file:input.txt>, <file:///input.txt>] {
println(`The size of $file is ${file.length()} bytes.`)
}
Eiffel
class
APPLICATION
create
make
feature {NONE} -- Initialization
make
-- Run application.
do
create input_file.make_open_read ("input.txt")
print(input_file.count)
print("%N")
input_file.close
create environment
input_file.make_open_read(environment.root_directory_name + "input.txt")
print(input_file.count)
input_file.close
end
feature -- Access
input_file: PLAIN_TEXT_FILE
environment:EXECUTION_ENVIRONMENT
end
Elena
ELENA 4.x :
import system'io;
import extensions;
public program()
{
console.printLine(File.assign("input.txt").Length);
console.printLine(File.assign("\input.txt").Length)
}
Elixir
IO.puts File.stat!("input.txt").size
IO.puts File.stat!("/input.txt").size
Emacs Lisp
This shows nil
if no such file since
file-attributes
returns nil
in that case.
(message "sizes are %s and %s"
(nth 7 (file-attributes "input.txt"))
(nth 7 (file-attributes "/input.txt")))
Erlang
-module(file_size).
-export([file_size/0]).
-include_lib("kernel/include/file.hrl").
file_size() ->
print_file_size("input.txt"),
print_file_size("/input.txt").
print_file_size(Filename) ->
case file:read_file_info(Filename) of
{ok, FileInfo} ->
io:format("~s ~p~n", [Filename, FileInfo#file_info.size]);
{error, _} ->
io:format("~s could not be opened~n",[Filename])
end.
Euphoria
include file.e
function file_size(sequence file_name)
object x
x = dir(file_name)
if sequence(x) and length(x) = 1 then
return x[1][D_SIZE]
else
return -1 -- the file does not exist
end if
end function
procedure test(sequence file_name)
integer size
size = file_size(file_name)
if size < 0 then
printf(1,"%s file does not exist.\n",{file_name})
else
printf(1,"%s size is %d.\n",{file_name,size})
end if
end procedure
test("input.txt") -- in the current working directory
test("/input.txt") -- in the file system root
F#
open NUnit.Framework
open FsUnit
[<Test>]
let ``Validate that the size of the two files is the same`` () =
let local = System.IO.FileInfo(__SOURCE_DIRECTORY__ + "\input.txt")
let root = System.IO.FileInfo(System.IO.Directory.GetDirectoryRoot(__SOURCE_DIRECTORY__) + "input.txt")
local.Length = root.Length |> should be True
Factor
"input.txt" file-info size>> .
1321
"file-does-not-exist.txt" file-info size>>
"Unix system call ``stat'' failed:"...
FBSL
FileLen returns -1 if the file is not found. FileLen will also accept a file handle and give the file length of the open file.
#APPTYPE CONSOLE
print FileLen("sync.log")
print FileLen("\sync.log")
PAUSE
Forth
: .filesize ( addr len -- ) 2dup type ." is "
r/o open-file throw
dup file-size throw <# #s #> type ." bytes long." cr
close-file throw ;
s" input.txt" .filesize
s" /input.txt" .filesize
Fortran
Since Fortran 95 the size of standard external files may be determined simply by using INQUIRE(SIZE=...). The following previous example pertains to FORTRAN 77 and is now superceded.
use :: iso_fortran_env, only : FILE_STORAGE_SIZE
implicit none
character(len=*),parameter :: filename(*)=[character(len=256) :: 'input.txt', '/input.txt']
integer :: file_size, i
do i=1,size(filename)
INQUIRE(FILE=filename(i), SIZE=file_size) ! return -1 if cannot determine file size
write(*,*)'size of file '//trim(filename(i))//' is ',file_size * FILE_STORAGE_SIZE /8,' bytes'
enddo
end
The original example, now obsolete ...
Alas, although there is a statement INQUIRE(FILE="Input.txt",EXIST = ISTHERE, RECL = RL, etc.)
whereby a logical variable ISTHERE has a value (output: assigned left-to-right) according to whether a named file (input: assignment right-to-left) exists or not, and the parameter RECL returns the maximum allowed record length for the file, there is no parameter that reports how many records there are in the file so that the file size remains unknowable. Further, the value returned by RECL is not necessarily related to the file itself, but is likely to be a standard value such as 132, a default used when deciding on the line wrap length with free-format output as in WRITE (6,*) stuff
but not necessarily being a limit on the length of a line written or read.
Further, in the ASCII world, text files are often implemented as variable-length records with special characters inline as record boundaries, usually one of CR, CRLF, LFCR, or LF. Without knowing which is in use, the storage taken up by them would be unknown. Other file systems may offer different types of disc files with fixed-size records or variable length records with a record length counter, but this is not standard across all computers.
In other words, Fortran does not specify a linkage to the filesystem whereby these details could be revealed, and not all filesystems maintain them anyway.
But if one wrote Fortran on a B6700 system, its F77 compiler offered additional attributes that could be returned via an INQUIRE statement: MAXRECSIZE really was the length of the longest record in the disc file (whether fixed record lengths or variable record lengths), BLOCKSIZE reported the number of records per block of disc space, AREASIZE the size of a disc space allocation area, and AREAS their number, while KIND reveals the code number of the type of file (not via a .txt suffix or whatever). Armed with these values, the file size could be determined in bits, bytes, words (six characters/word), records, blocks and areas.
These facilities were not carried forward into standardised Fortran 90, etc. So, one is stuck with devising a routine that reads all the records of a disc file, counting their length. This is straightforward, but tedious, as in the following fragment:
20 READ (INF,21, END = 30) L !R E A D A R E C O R D - but only its length.
21 FORMAT(Q) !This obviously indicates the record's length.
NRECS = NRECS + 1 !CALL LONGCOUNT(NRECS,1) !C O U N T A R E C O R D.
NNBYTES = NNBYTES + L !CALL LONGCOUNT(NNBYTES,L) !Not counting any CRLF (or whatever) gibberish.
IF (L.LT.RMIN) THEN !Righto, now for the record lengths.
RMIN = L !This one is shorter.
RMINR = NRECS !Where it's at.
ELSE IF (L.GT.RMAX) THEN !Perhaps instead it is longer?
RMAX = L !Longer.
RMAXR = NRECS !Where it's at.
END IF !So much for the lengths.
GO TO 20 !All I wanted to know...
The LONGCOUNT routine uses two 32-bit integers (the first parameter being a two-element array) to deliver a much larger capacity, given modern file size opportunities, but this is unnecessary if INTEGER*8 variables are available. The count will not include any contribution from record splitters such as CR, etc. A file more properly thought of as containing binary data (say, integer or floating-point values) will by chance have a CR or LF bit pattern here and there, and they will be taken as marking record splits when reading a file as being FORMATTED, which is the default setting.
FreeBASIC
' FB 1.05.0 Win64
#include "file.bi"
Print FileLen("input.txt"), FileLen(Environ("SystemRoot") + "\input.txt")
Sleep
Frink
println[newJava["java.io.File", "input.txt"].length[]]
println[newJava["java.io.File", "/input.txt"].length[]]
Gambas
Public Sub Main()
Dim stInfo As Stat = Stat(User.home &/ "input.txt")
Dim stInfo1 As Stat = Stat("/input.txt")
Print User.Home &/ "input.txt = " & stInfo.Size & " bytes"
Print "/input.txt = " & stInfo1.Size & " bytes"
End
Output:
/home/charlie/input.txt = 121 bytes /input.txt = 32 bytes
Go
package main
import "fmt"
import "os"
func printFileSize(f string) {
if stat, err := os.Stat(f); err != nil {
fmt.Println(err)
} else {
fmt.Println(stat.Size())
}
}
func main() {
printFileSize("input.txt")
printFileSize("/input.txt")
}
Groovy
println new File('index.txt').length();
println new File('/index.txt').length();
Haskell
import System.IO
printFileSize filename = withFile filename ReadMode hFileSize >>= print
main = mapM_ printFileSize ["input.txt", "/input.txt"]
or
import System.Posix.File
printFileSize filename = do stat <- getFileStatus filename
print (fileSize stat)
main = mapM_ printFileSize ["input.txt", "/input.txt"]
HicEst
READ(FILE="input.txt", LENgth=bytes) ! bytes = -1 if not existent
READ(FILE="C:\input.txt", LENgth=bytes) ! bytes = -1 if not existent
Icon and Unicon
Icon doesn't support 'stat'; however, information can be obtained by use of the system function to access command line.
every dir := !["./","/"] do {
write("Size of ",f := dir || "input.txt"," = ",stat(f).size) |stop("failure for to stat ",f)
}
Note: Icon and Unicon accept both / and \ for directory separators.
J
require 'files'
fsize 'input.txt';'/input.txt'
Java
import java.io.File;
public class FileSize
{
public static void main ( String[] args )
{
System.out.println("input.txt : " + new File("input.txt").length() + " bytes");
System.out.println("/input.txt : " + new File("/input.txt").length() + " bytes");
}
}
JavaScript
var fso = new ActiveXObject("Scripting.FileSystemObject");
fso.GetFile('input.txt').Size;
fso.GetFile('c:/input.txt').Size;
The following works in all browsers, including IE10.
var file = document.getElementById("fileInput").files.item(0); //a file input element
if (file) {
var reader = new FileReader();
reader.readAsText(file, "UTF-8");
reader.onload = loadedFile;
reader.onerror = errorHandler;
}
function loadedFile(event) {
var fileString = event.target.result;
alert(fileString.length);
}
function errorHandler(event) {
alert(event);
}
jq
jq -Rs length input.txt
jq -Rs length /input.txt
The -R option causes the file to be read as text, and the -s option causes it to be read as a single string.
Julia
println(filesize("input.txt"))
println(filesize("/input.txt"))
K
_size "input.txt"
_size "/input.txt"
Kotlin
// version 1.0.6
import java.io.File
fun main(args: Array<String>) {
val paths = arrayOf("input.txt", "c:\\input.txt")
for (path in paths)
println("Length of $path is ${File(path).length()} bytes")
}
Lasso
// local to current directory
local(f = file('input.txt'))
handle => { #f->close }
#f->size
// file at file system root
local(f = file('//input.txt'))
handle => { #f->close }
#f->size
Liberty BASIC
'input.txt in current directory
OPEN DefaultDir$ + "/input.txt" FOR input AS #m
PRINT "File size: "; lof(#m)
CLOSE #m
'input.txt in root
OPEN "c:/input.txt" FOR input AS #m
PRINT "File size: "; lof(#m)
CLOSE #m
Lingo
----------------------------------------
-- Returns file size
-- @param {string} filename
-- @return {integer}
----------------------------------------
on getFileSize (filename)
fp = xtra("fileIO").new()
fp.openFile(filename, 1)
if fp.status() then return 0
len = fp.getLength()
fp.closeFile()
return len
end
LiveCode
// root folder
set the defaultfolder to "/"
repeat for each line fline in (the detailed files)
if item 1 of fline is "input.txt" then
put item 2 of fline --bytes
exit repeat
end if
end repeat
// current working dir of stack
put the effective filename of this stack into tPath
set the itemDelimiter to slash
delete last item of tPath
set the defaultfolder to tPath
repeat for each line fline in (the detailed files)
if item 1 of fline is "input.txt" then
put item 2 of fline
exit repeat
end if
end repeat
Lua
function GetFileSize( filename )
local fp = io.open( filename )
if fp == nil then
return nil
end
local filesize = fp:seek( "end" )
fp:close()
return filesize
end
Maple
FileTools:-Size( "input.txt" )
FileTools:-Size( "/input.txt" )
Mathematica / Wolfram Language
FileByteCount["input.txt"]
FileByteCount[FileNameJoin[{$RootDirectory, "input.txt"}]]
MATLAB / Octave
d1 = dir('input.txt');
d2 = dir('/input.txt');
fprintf('Size of input.txt is %d bytes\n', d1.bytes)
fprintf('Size of /input.txt is %d bytes\n', d2.bytes)
MAXScript
-- Returns filesize in bytes or 0 if the file is missing
getFileSize "index.txt"
getFileSize "\index.txt"
Mirah
import java.io.File
puts File.new('file-size.mirah').length()
puts File.new("./#{File.separator}file-size.mirah").length()
mIRC Scripting Language
echo -ag $file(input.txt).size bytes
echo -ag $file(C:\input.txt).size bytes
Modula-3
MODULE FSize EXPORTS Main;
IMPORT IO, Fmt, FS, File, OSError;
VAR fstat: File.Status;
BEGIN
TRY
fstat := FS.Status("input.txt");
IO.Put("Size of input.txt: " & Fmt.LongInt(fstat.size) & "\n");
fstat := FS.Status("/input.txt");
IO.Put("Size of /input.txt: " & Fmt.LongInt(fstat.size) & "\n");
EXCEPT
| OSError.E => IO.Put("ERROR: Could not get file status.\n");
END;
END FSize.
Nanoquery
import Nanoquery.IO
println new(File, "input.txt").length()
println new(File, "/input.txt").length()
NetRexx
/* NetRexx */
options replace format comments java symbols binary
runSample(arg)
return
-- . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
method fileSize(fn) public static returns double
ff = File(fn)
fSize = ff.length()
return fSize
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method runSample(arg) private static
parse arg files
if files = '' then files = 'input.txt F docs D /input.txt F /docs D'
loop while files.length > 0
parse files fn ft files
select case(ft.upper())
when 'F' then do
ft = 'File'
end
when 'D' then do
ft = 'Directory'
end
otherwise do
ft = 'File'
end
end
sz = fileSize(fn)
say ft ''''fn'''' sz 'bytes.'
end
return
- Output:
J:\>nrc fsz java -cp "c:\netRexx\lib\NetRexxR.jar;c:\netRexx\lib\NetRexxC.jar;.;C:\Program Files\BSF4ooRexx\bsf4ooRexx-v452-20150825-bin.jar;;c:\netrexx\lib\NetRexxF.jar;." -Dnrx.compiler=ecj org.netrexx.process.NetRexxC fsz NetRexx portable processor 3.04 GA build 4-20150630-1657 Copyright (c) RexxLA, 2011,2015. All rights reserved. Parts Copyright (c) IBM Corporation, 1995,2008. Program fsz.nrx function fileSize(Rexx) function runSample(Rexx) Compilation of 'fsz.nrx' successful J:\>java fsz test.txt File 'test.txt' 8 bytes.
NewLISP
(println (first (file-info "input.txt")))
(println (first (file-info "/input.txt")))
Nim
import os
echo getFileSize "input.txt"
echo getFileSize "/input.txt"
Objeck
use IO;
...
File("input.txt")->Size()->PrintLine();
File("c:\input.txt")->Size()->PrintLine();
Objective-C
NSFileManager *fm = [NSFileManager defaultManager];
// Pre-OS X 10.5
NSLog(@"%llu", [[fm fileAttributesAtPath:@"input.txt" traverseLink:YES] fileSize]);
// OS X 10.5+
NSLog(@"%llu", [[fm attributesOfItemAtPath:@"input.txt" error:NULL] fileSize]);
OCaml
let printFileSize filename =
let ic = open_in filename in
Printf.printf "%d\n" (in_channel_length ic);
close_in ic ;;
printFileSize "input.txt" ;;
printFileSize "/input.txt" ;;
For files greater than Pervasives.max_int, one can use the module Pervasives.LargeFile:
let printLargeFileSize filename =
let ic = open_in filename in
Printf.printf "%Ld\n" (LargeFile.in_channel_length ic);
close_in ic ;;
Alternatively:
#load "unix.cma" ;;
open Unix ;;
Printf.printf "%d\n" (stat "input.txt").st_size ;;
Printf.printf "%d\n" (stat "/input.txt").st_size ;;
The module Unix has also a LargeFile sub-module.
Oforth
File new("input.txt") size println
File new("/input.txt") size println
ooRexx
Parse Version v
Say v
fid='test.txt'
x=sysfiletree(fid,a.)
Say a.0
Say a.1
Say left(copies('123456789.',10),length(a.1))
Parse Var a.1 20 size .
Say 'file size:' size
s=charin(fid,,1000)
Say length(s)
Say 'file' fid
'type' fid
- Output:
J:\>rexx sft REXX-ooRexx_4.2.0(MT)_64-bit 6.04 22 Feb 2014 1 7/26/16 3:28p 8 A---- J:\test.txt 123456789.123456789.123456789.123456789.12345678 file size: 8 8 file test.txt 12 34
Oz
declare
[Path] = {Module.link ['x-oz://system/os/Path.ozf']}
in
{Show {Path.size "input.txt"}}
{Show {Path.size "/input.txt"}}
Pascal
See Delphi
Perl
my $size1 = -s 'input.txt';
my $size2 = -s '/input.txt';
Or, to be 100% cross-platform:
use File::Spec::Functions qw(catfile rootdir);
my $size1 = -s 'input.txt';
my $size2 = -s catfile rootdir, 'input.txt';
Alternative way to get the size:
my $size1 = (stat 'input.txt')[7]; # builtin stat() returns an array with file size at index 7
my $size2 = (stat '/input.txt')[7];
Phix
function file_size(sequence file_name) object d = dir(file_name) if atom(d) or length(d)!=1 then return -1 end if return d[1][D_SIZE] end function procedure test(sequence file_name) integer size = file_size(file_name) if size<0 then printf(1,"%s file does not exist.\n",{file_name}) else printf(1,"%s size is %d.\n",{file_name,size}) end if end procedure test("input.txt") -- in the current working directory test("/input.txt") -- in the file system root
PHP
<?php
echo filesize('input.txt'), "\n";
echo filesize('/input.txt'), "\n";
?>
PicoLisp
(println (car (info "input.txt")))
(println (car (info "/input.txt")))
Pike
import Stdio;
int main(){
write(file_size("input.txt") + "\n");
write(file_size("/input.txt") + "\n");
}
PL/I
/* To obtain file size of files in root as well as from current directory. */
test: proc options (main);
declare ch character (1);
declare i fixed binary (31);
declare in1 file record;
/* Open a file in the root directory. */
open file (in1) title ('//asd.log,type(fixed),recsize(1)');
on endfile (in1) go to next1;
do i = 0 by 1;
read file (in1) into (ch);
end;
next1:
put skip list ('file size in root directory =' || trim(i));
close file (in1);
/* Open a file in the current dorectory. */
open file (in1) title ('/asd.txt,type(fixed),recsize(1)');
on endfile (in1) go to next2;
do i = 0 by 1;
read file (in1) into (ch);
end;
next2:
put skip list ('local file size=' || trim(i));
end test;
I used differently-named files to prove that local and root directory files were accessed. This program ran with Windows PL/I.
Pop11
;;; prints file size in bytes
sysfilesize('input.txt') =>
sysfilesize('/input.txt') =>
PostScript
status
returns status information about a file if given a file name. This includes the size in pages (implementation-dependent), the size in bytes, creation and modification time and a final true
. The values not needed here are simply pop
ed off the stack.
(input.txt ) print
(input.txt) status pop pop pop = pop
(/input.txt ) print
(/input.txt) status pop pop pop = pop
PowerShell
Get-ChildItem input.txt | Select-Object Name,Length
Get-ChildItem \input.txt | Select-Object Name,Length
PureBasic
Debug FileSize("input.txt")
Debug FileSize("/input.txt")
Python
import os
size = os.path.getsize('input.txt')
size = os.path.getsize('/input.txt')
R
R has a function file.info() in the base package that performs this function. Note that regardless of the OS, R uses forward slashes for the directories.
sizeinwd <- file.info('input.txt')[["size"]]
sizeinroot <- file.info('/input.txt')[["size"]]
Racket
#lang racket
(file-size "input.txt")
(file-size "/input.txt")
Raku
(formerly Perl 6)
say 'input.txt'.IO.s;
say '/input.txt'.IO.s;
Cross-platform version of the second one:
say $*SPEC.rootdir.IO.child("input.txt").s;
RapidQ
File I/O is one of the things where RapidQ differs from standard Basic. RapidQ uses file streams.
Method 1: display file size using file streams
$INCLUDE "rapidq.inc"
DIM file AS QFileStream
FUNCTION fileSize(name$) AS Integer
file.Open(name$, fmOpenRead)
Result = file.Size
file.Close
END FUNCTION
PRINT "Size of input.txt is "; fileSize("input.txt")
PRINT "Size of \input.txt is "; fileSize("\input.txt")
Method 2: using DIR$
FileName$ = DIR$("input.txt", 0)
PRINT "Size of input.txt is "; FileRec.Size
FileName$ = DIR$("\input.txt", 0)
PRINT "Size of \input.txt is "; FileRec.Size
Raven
'input.txt' status.size
'/input.txt' status.size
REBOL
size? %info.txt
size? %/info.txt
size? ftp://username:password@ftp.site.com/info.txt
size? http://rosettacode.org
Red
>> size? %input.txt
== 39244
>> size? %/c/input.txt
== 39244
Retro
The simple way is to open and read the size. This may crash if the file does not exist.
with files'
"input.txt" :R open &size sip close drop putn
"/input.txt" :R open &size sip close drop putn
For added stability, check that the returned file handle is not zero:
with files'
"input.txt" :R open over 0 <> [ &size sip close drop ] ifTrue
Or, if you need to do this more often, setup a function that'll also display an error message if the file does not exist:
with files'
: getFileSize ( $-n )
:R open 0 over =
[ "File does Not Exist\n" puts ]
[ &size sip close drop ] if ;
"input.txt" getFileSize putn
"/input.txt" getFileSize putn
REXX
MS DOS version 1
This REXX example was executed on a Windows/XP and also a Windows 7 system (in a DOS window), and
it reports the file's size (in bytes) for both of the required files.
Various REXXes were used for testing: Regina, PERSONAL REXX, PC/REXX, and R4.
Note that some operating systems don't have a concept of a current directory or a file system root.
/*REXX program determines a file's size (by reading all the data) in current dir & root.*/
parse arg iFID . /*allow the user specify the file ID. */
if iFID=='' | iFID=="," then iFID='input.txt' /*Not specified? Then use the default.*/
say 'size of 'iFID "=" fSize(iFID) 'bytes' /*the current directory.*/
say 'size of \..\'iFID "=" fSize('\..\'iFID) 'bytes' /* " root " */
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
fSize: parse arg f; $=0; do while chars(f)\==0; $ = $ + length( charin( f, , 1e4) )
end /*while*/; call lineout f /*close file.*/
return $
- output when using the default input:
size of input.txt = 40 bytes size of \..\input.txt = 40 bytes
MS DOS version 2
/*REXX pgm to verify a file's size */
parse arg iFID . /*let user specify the file ID. */
if iFID=='' then iFID="FILESIZ.DAT" /*Not specified? Then use default*/
say 'size of' iFID':'
Say chars(ifid) '(CR LF included)'
Call lineout ifid /* close the file */
say filesize(ifid) '(net data)'
Call lineout ifid
exit
filesize: parse arg f;
sz=0;
Do while lines(f)\==0
sz=sz+length(linein(f))
End
return sz
- Output:
size of FILESIZ.DAT: 4 (CR LF included) 2 (net data)
CMS version
Note that CMS hasn't a concept of a root.
Also note that the CMS system doesn't normally support the use of periods (.); it uses blanks instead.
/*REXX program determines a file's size (by reading all the data) on the default mDisk.*/
parse arg iFID /*allow the user specify the file ID. */
if iFID=='' | iFID=="," then iFID= 'INPUT TXT' /*Not specified? Then use the default.*/
say 'size of' iFID "=" fSize(iFID) 'bytes' /*on the default mDisk.*/
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
fSize: parse arg f; $= 0; do while lines(f)\==0; $= $ + length( linein(f) )
end /*while*/
return $
Ring
See len(read('input.txt')) + nl
see len(read('/input.txt')) + nl
Ruby
size = File.size('input.txt')
size = File.size('/input.txt')
Run BASIC
print fileSize(DefaultDir$,"input.txt") ' current default directory
print fileSize("","input.txt") ' root directory
function fileSize(dir$,file$)
open dir$;"\";file$ FOR input as #f
fileSize = lof(#f) ' Length Of File
close #f
end function
Rust
use std::{env, fs, process};
use std::io::{self, Write};
use std::fmt::Display;
fn main() {
let file_name = env::args().nth(1).unwrap_or_else(|| exit_err("No file name supplied", 1));
let metadata = fs::metadata(file_name).unwrap_or_else(|e| exit_err(e, 2));
println!("Size of file.txt is {} bytes", metadata.len());
}
#[inline]
fn exit_err<T: Display>(msg: T, code: i32) -> ! {
writeln!(&mut io::stderr(), "Error: {}", msg).expect("Could not write to stdout");
process::exit(code)
}
}
Scala
import java.io.File
object FileSize extends App {
val name = "pg1661.txt"
println(s"$name : ${new File(name).length()} bytes")
println(s"/$name : ${new File(s"${File.separator}$name").length()} bytes")
}
Scheme
(define (file-size filename)
(call-with-input-file filename (lambda (port)
(let loop ((c (read-char port))
(count 0))
(if (eof-object? c)
count
(loop (read-char port) (+ 1 count)))))))
(file-size "input.txt")
(file-size "/input.txt")
Seed7
$ include "seed7_05.s7i";
const proc: main is func
begin
writeln(fileSize("input.txt"));
writeln(fileSize("/input.txt"));
end func;
Sidef
say (Dir.cwd + %f'input.txt' -> size);
say (Dir.root + %f'input.txt' -> size);
Slate
(File newNamed: 'input.txt') fileInfo fileSize.
(File newNamed: '/input.txt') fileInfo fileSize.
Smalltalk
(File name: 'input.txt') size printNl.
(File name: '/input.txt') size printNl.
'input.txt' asFilename fileSize
'/input.txt' asFilename fileSize
Standard ML
val size = OS.FileSys.fileSize "input.txt" ;;
val size = OS.FileSys.fileSize "/input.txt" ;
Stata
To get the size in byte of an arbitrary file, use file seek. Just replace input.txt with \input.txt if the file resides in the root directory of the current disk.
file open f using input.txt, read binary
file seek f eof
file seek f query
display r(loc)
file close f
However, what is usually interesting is the size of a datatset. Use describe, either on the currently loaded dataset, or on a dataset on disk. The describe command will print the file size, but it's possible to use stored results as well.
describe using test.dta
display r(N)*r(width)
Tcl
file size input.txt
file size /input.txt
Toka
A trivial method follows:
" input.txt" "R" file.open dup file.size . file.close
" /input.txt" "R" file.open dup file.size . file.close
A better method would be to define a new function that actually checks whether the file exists:
[ "R" file.open
dup 0 <> [ dup file.size . file.close ] ifTrue
drop
] is display-size
" input.txt" display-size
" /input.txt" display-size
TorqueScript
--Ipquarx June 19th, 10:00 AM
Since TorqueScript cannot set the current working directory, the second part of the task cannot be completed.
TGE Version (Works with all versions containing the basic file i/o):
%File = new FileObject();
%File.openForRead("input.txt");
while(!%File.isEOF())
{
%Length += strLen(%File.readLine());
}
%File.close();
%File.delete();
T3D Version (Only works with T3D):
fileSize("input.txt");
TUSCRIPT
$$ MODE TUSCRIPT
-- size of file input.txt
file="input.txt"
ERROR/STOP OPEN (file,READ,-std-)
file_size=BYTES ("input.txt")
ERROR/STOP CLOSE (file)
-- size of file x:/input.txt
ERROR/STOP OPEN (file,READ,x)
file_size=BYTES (file)
ERROR/STOP CLOSE (file)
UNIX Shell
An interactive user would run ls -l input.txt /input.txt to see the file sizes. This task is more difficult for a shell script, that must extract each size from command output.
Using ls
ls most likely gets the length from the file's inode.
size1=$(ls -l input.txt | tr -s ' ' | cut -d ' ' -f 5)
size2=$(ls -l /input.txt | tr -s ' ' | cut -d ' ' -f 5)
ls -l reports the size in 5th field, with spaces between fields. tr squeezes spaces (because cut needs one single space between fields), and cut extracts 5th field.
echo "# ls:"
ls -la input.txt
echo "# stat:"
stat input.txt
echo "# Size:"
size1=$(ls -l input.txt | tr -s ' ' | cut -d ' ' -f 5)
size2=$(wc -c < input.txt | tr -d ' ')
echo $size1, $size2
- Output:
Test run at compileonline.com
# ls: -rw-r--r-- 1 apache apache 126 Nov 5 19:02 input.txt # stat: File: `input.txt' Size: 126 Blocks: 8 IO Block: 4096 regular file Device: 700h/1792d Inode: 2195776 Links: 1 Access: (0644/-rw-r--r--) Uid: ( 48/ apache) Gid: ( 48/ apache) Access: 2014-11-05 19:02:25.000000000 -0600 Modify: 2014-11-05 19:02:25.000000000 -0600 Change: 2014-11-05 19:02:25.000000000 -0600 # Size: 126, 126
Using wc
wc may actually read the whole file and count the bytes. Some implementations, like wc.c from GNU coreutils, can optimize wc -c by getting the length from the file's inode.
size1=$(wc -c < input.txt | tr -d ' ')
size2=$(wc -c < /input.txt | tr -d ' ')
The peculiar use of wc -c < file, not wc -c file, is to prevent printing the file's name. Then wc only reports the size. Some versions of wc print spaces before the number; tr deletes all these spaces.
Using BSD stat
BSD has stat(1), a nonstandard command. With stat, a shell script can easily get the file size.
size1=$(stat -f %z input.txt)
size2=$(stat -f %z /input.txt)
Z Shell
# from module 'zsh/stat', load builtin 'zstat'
zmodload -F zsh/stat b:zstat
size1=$(zstat +size input.txt)
size2=$(zstat +size /input.txt)
Ursa
decl file f
f.open "input.txt"
out (size f) endl console
f.close
f.open "/input.txt"
out (size f) endl console
f.close
VBScript
With CreateObject("Scripting.FileSystemObject")
WScript.Echo .GetFile("input.txt").Size
WScript.Echo .GetFile("\input.txt").Size
End With
Vedit macro language
Num_Type(File_Size("input.txt"))
Num_Type(File_Size("/input.txt"))
Visual Basic
Option Explicit
----
Sub DisplayFileSize(ByVal Path As String, ByVal Filename As String)
Dim i As Long
If InStr(Len(Path), Path, "\") = 0 Then
Path = Path & "\"
End If
On Error Resume Next 'otherwise runtime error if file does not exist
i = FileLen(Path & Filename)
If Err.Number = 0 Then
Debug.Print "file size: " & CStr(i) & " Bytes"
Else
Debug.Print "error: " & Err.Description
End If
End Sub
----
Sub Main()
DisplayFileSize CurDir(), "input.txt"
DisplayFileSize CurDir(), "innputt.txt"
DisplayFileSize Environ$("SystemRoot"), "input.txt"
End Sub
- Output:
file size: 37 Bytes error: file not found file size: 37 Bytes
Visual Basic .NET
Platform: .NET
Dim local As New IO.FileInfo("input.txt")
Console.WriteLine(local.Length)
Dim root As New IO.FileInfo("\input.txt")
Console.WriteLine(root.Length)
Wren
A file called "input.txt" has already been created which contains the string "abcdefghijklmnopqrstuvwxyz".
To check the size of a file in the root, just change "input.txt" to "/input.txt" in the following script.
import "io" for File
var name = "input.txt"
System.print("'%(name)' has a a size of %(File.size(name)) bytes")
- Output:
'input.txt' has a a size of 26 bytes
X86 Assembly
; x86_64 linux nasm
section .data
localFileName: db "input.txt", 0
rootFileName: db "/initrd.img", 0
section .text
global _start
_start:
; open file in current dir
mov rax, 2
mov rdi, localFileName
xor rsi, rsi
mov rdx, 0
syscall
push rax
mov rdi, rax ; file descriptior
mov rsi, 0 ; offset
mov rdx, 2 ; whence
mov rax, 8 ; sys_lseek
syscall
; compare result to actual size
cmp rax, 11
jne fail
; close the file
pop rdi
mov rax, 3
syscall
; open file in root dir
mov rax, 2
mov rdi, rootFileName
xor rsi, rsi
mov rdx, 0
syscall
push rax
mov rdi, rax ; file descriptior
mov rsi, 0 ; offset
mov rdx, 2 ; whence
mov rax, 8 ; sys_lseek
syscall
; compare result to actual size
cmp rax, 37722243
jne fail
; close the file
pop rdi
mov rax, 3
syscall
; test successful
mov rax, 60
mov rdi, 0
syscall
; test failed
fail:
mov rax, 60
mov rdi, 1
syscall
XPL0
proc ShowSize(FileName);
char FileName; int Size, C;
[Trap(false); \disable abort on error
FSet(FOpen(FileName, 0), ^i);
Size:= 0;
repeat C:= ChIn(3); \reads 2 EOFs before
Size:= Size+1; \ read beyond end-of-file
until GetErr; \ is detected
IntOut(0, Size-2);
CrLf(0);
];
[ShowSize("input.txt");
ShowSize("/input.txt"); \root under Linux
]
zkl
File.info("input.txt").println();
File.info("/input.txt").println();
-->T(size,creation time,last mod time,isDir,mode), from stat(2)
- Output:
L(391,1393658766,1393658766,False,33156) Exception thrown: NameError(File.info(/input.txt): Could not open)
- Programming Tasks
- File System Operations
- 11l
- 8086 Assembly
- Action!
- Action! Tool Kit
- Ada
- Aime
- ALGOL 68
- Arturo
- AutoHotkey
- AWK
- Axe
- BaCon
- Batch File
- BBC BASIC
- Bracmat
- C
- C sharp
- C++
- Clean
- Clojure
- COBOL
- ColdFusion
- Common Lisp
- D
- Delphi
- E
- Eiffel
- Elena
- Elixir
- Emacs Lisp
- Erlang
- Euphoria
- F Sharp
- Factor
- FBSL
- Forth
- Fortran
- FreeBASIC
- Frink
- Gambas
- Go
- Groovy
- Haskell
- HicEst
- Icon
- Unicon
- J
- Java
- JavaScript
- Jq
- Julia
- K
- Kotlin
- Lasso
- Liberty BASIC
- Lingo
- LiveCode
- Lua
- Maple
- Mathematica
- Wolfram Language
- MATLAB
- Octave
- MAXScript
- Mirah
- MIRC Scripting Language
- Modula-3
- Nanoquery
- NetRexx
- NewLISP
- Nim
- Objeck
- Objective-C
- OCaml
- Oforth
- OoRexx
- Oz
- Pascal
- Perl
- Phix
- Phix/basics
- PHP
- PicoLisp
- Pike
- PL/I
- Pop11
- PostScript
- PowerShell
- PureBasic
- Python
- R
- Racket
- Raku
- RapidQ
- Raven
- REBOL
- Red
- Retro
- REXX
- Ring
- Ruby
- Run BASIC
- Rust
- Scala
- Scheme
- Seed7
- Sidef
- Slate
- Smalltalk
- Standard ML
- Stata
- Tcl
- Toka
- TorqueScript
- TUSCRIPT
- UNIX Shell
- Ursa
- VBScript
- Vedit macro language
- Visual Basic
- Visual Basic .NET
- Wren
- X86 Assembly
- XPL0
- Zkl
- Befunge/Omit
- HTML/Omit
- PARI/GP/Omit
- TI-83 BASIC/Omit
- TI-89 BASIC/Omit