File size: Difference between revisions

 

=={{header|11l}}==

 

=={{header|8086 Assembly}}==

This program runs under MS-DOS.

 

puts: equ 9 ; Print $-terminated string

setdta: equ 1Ah ; Set DTA

colspc: db ': $' ; Colon and space

section .bss

 

{{out}}

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}}

 

PROC Dir(CHAR ARRAY filter)

size=FileSize(fname)

PrintF("Size of ""%S"" is %U bytes%E",fname,size)

{{out}}

<pre>

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}}

 

proc MAIN()

print("Size of REAL.ACT is ") printRD(DEVICE,FLEN) printe(" bytes")

return

{{out}}

<pre>

 

=={{header|Ada}}==

with Ada.Text_IO; use Ada.Text_IO;

 

Put_Line (File_Size'Image (Size ("input.txt")) & " bytes");

Put_Line (File_Size'Image (Size ("/input.txt")) & " bytes");

Note that reference to the root directory, if there is any, is [[OS]] specific.

 

=={{header|Aime}}==

 

=={{header|ALGOL 68}}==

special channel, e.g. a tape device.

 

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],

=={{header|Arturo}}==

 

 

=={{header|AutoHotkey}}==

MsgBox, Size of input.txt is %FileSize% bytes

FileGetSize, FileSize, \input.txt, K ; Retrieve the size in Kbytes.

 

=={{header|AWK}}==

{{works with|gawk}}

function filesize(name ,fd) {

if ( stat(name, fd) == -1)

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

 

 

# Windows

close(command)

return ship

 

 

 

=={{header|Axe}}==

Disp {I-2}ʳ▶Dec,i

Else

Disp "NOT FOUND",i

 

=={{header|BaCon}}==

' Return the entire message, FILELEN returns a NUMBER

FUNCTION printlen$(STRING name$)

 

PRINT printlen$("input.txt")

 

{{out}}

=={{header|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

 

=={{header|BBC BASIC}}==

IF file% THEN

PRINT "File size = " ; EXT#file%

PRINT "File size = " ; EXT#file%

CLOSE #file%

 

=={{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.

 

size

. fil$(!arg,rb) {read in binary mode}

getFileSize$"c:\\boot.ini"

211

 

=={{header|C}}==

#include <stdio.h>

 

printf("%ld\n", getFileSize("/input.txt"));

return 0;

 

{{works with|POSIX}}

#include <stdio.h>

#include <sys/stat.h>

printf("%ld\n", foo.st_size);

return 0;

 

=={{header|C sharp|C#}}==

 

using System.IO;

 

}

}

 

=={{header|C++}}==

#include <fstream>

 

std::cout << getFileSize("/input.txt") << std::endl;

return 0;

 

'''optimized '''

#include <fstream>

 

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 <iostream>

 

print_file_size("input.txt");

print_file_size("/input.txt");

 

{{out}}

There is not function to get the file size, therefore we seek to the end and query the file pointer position.

 

 

fileSize fileName world

= (size, world)

 

 

=={{header|Clojure}}==

(defn show-size [filename]

(println filename "size:" (.length (io/file filename))))

 

(show-size "input.txt")

 

=={{header|COBOL}}==

identification division.

program-id. FileInfo.

end-if

.

 

=={{header|ColdFusion}}==

localFile = getFileInfo(expandpath("input.txt"));

rootFile = getFileInfo("/input.txt");

Size of input.txt is #localFile.size# bytes.

Size of /input.txt is #rootFile.size# bytes.

 

=={{header|Common Lisp}}==

:direction :input

:if-does-not-exist nil)

:direction :input

:if-does-not-exist nil)

 

(osicat-posix:stat-size (osicat-posix:stat #P"input.txt"))

 

=={{header|D}}==

std.mmfile;

 

e.msg.writefln;

}

{{out}}

<pre>File 'file_size.exe' has size:

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

Writeln('input.txt ', CheckFileSize('input.txt'));

Writeln('\input.txt ', CheckFileSize('\input.txt'));

 

=={{header|E}}==

 

println(`The size of $file is ${file.length()} bytes.`)

 

=={{header|Eiffel}}==

 

class

APPLICATION

environment:EXECUTION_ENVIRONMENT

end

 

=={{header|Elena}}==

ELENA 4.x :

import extensions;

console.printLine(File.assign("\input.txt").Length)

 

=={{header|Elixir}}==

 

=={{header|Emacs Lisp}}==

<code>file-attributes</code> returns <code>nil</code> in that case.

 

(nth 7 (file-attributes "input.txt"))

 

=={{header|Erlang}}==

 

-export([file_size/0]).

 

io:format("~s could not be opened~n",[Filename])

end.

 

=={{header|Euphoria}}==

 

function file_size(sequence file_name)

 

test("input.txt") -- in the current working directory

 

=={{header|F_Sharp|F#}}==

 

open FsUnit

 

let local = System.IO.FileInfo(__SOURCE_DIRECTORY__ + "\input.txt")

let root = System.IO.FileInfo(System.IO.Directory.GetDirectoryRoot(__SOURCE_DIRECTORY__) + "input.txt")

 

=={{header|Factor}}==

1321

"file-does-not-exist.txt" file-info size>>

 

=={{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.

 

print FileLen("sync.log")

print FileLen("\sync.log")

PAUSE

 

=={{header|Forth}}==

 

r/o open-file throw

dup file-size throw <# #s #> type ." bytes long." cr

 

s" input.txt" .filesize

 

=={{header|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

enddo

end

 

The original example, now obsolete ...

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.

 

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.

RMAXR = NRECS !Where it's at.

END IF !So much for the lengths.

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}}==

 

#include "file.bi"

 

Print FileLen("input.txt"), FileLen(Environ("SystemRoot") + "\input.txt")

 

=={{header|Frink}}==

 

=={{header|Gambas}}==

Dim stInfo As Stat = Stat(User.home &/ "input.txt")

Dim stInfo1 As Stat = Stat("/input.txt")

Print "/input.txt = " & stInfo1.Size & " bytes"

 

Output:

<pre>

 

=={{header|Go}}==

 

import "fmt"

printFileSize("input.txt")

printFileSize("/input.txt")

 

=={{header|Groovy}}==

 

=={{header|Haskell}}==

 

 

printFileSize filename = withFile filename ReadMode hFileSize >>= print

 

or

 

printFileSize filename = do stat <- getFileStatus filename

print (fileSize stat)

 

 

=={{header|HicEst}}==

 

=={{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.

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.

 

=={{header|J}}==

 

=={{header|Java}}==

 

public class FileSize

}

}

 

=={{header|JavaScript}}==

{{works with|JScript}}

fso.GetFile('input.txt').Size;

 

The following works in all browsers, including IE10.

if (file) {

var reader = new FileReader();

function errorHandler(event) {

alert(event);

 

=={{header|jq}}==

 

 

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|K}}==

 

=={{header|Kotlin}}==

 

import java.io.File

for (path in paths)

println("Length of $path is ${File(path).length()} bytes")

 

=={{header|Lasso}}==

local(f = file('input.txt'))

handle => { #f->close }

handle => { #f->close }

#f->size

 

=={{header|Liberty BASIC}}==

OPEN DefaultDir$ + "/input.txt" FOR input AS #m

PRINT "File size: "; lof(#m)

OPEN "c:/input.txt" FOR input AS #m

PRINT "File size: "; lof(#m)

 

=={{header|Lingo}}==

-- Returns file size

-- @param {string} filename

fp.closeFile()

return len

 

=={{header|LiveCode}}==

set the defaultfolder to "/"

repeat for each line fline in (the detailed files)

exit repeat

end if

 

=={{header|Lua}}==

local fp = io.open( filename )

if fp == nil then

fp:close()

return filesize

 

=={{header|Maple}}==

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

FileByteCount["input.txt"]

 

=={{header|MATLAB}} / {{header|Octave}}==

d2 = dir('/input.txt');

fprintf('Size of input.txt is %d bytes\n', d1.bytes)

 

=={{header|MAXScript}}==

getFileSize "index.txt"

 

=={{header|Mirah}}==

 

puts File.new('file-size.mirah').length()

 

=={{header|mIRC Scripting Language}}==

 

=={{header|Modula-3}}==

 

IMPORT IO, Fmt, FS, File, OSError;

| OSError.E => IO.Put("ERROR: Could not get file status.\n");

END;

 

=={{header|Nanoquery}}==

println new(File, "input.txt").length()

 

=={{header|NetRexx}}==

options replace format comments java symbols binary

 

end

 

{{out}}

<pre>

 

=={{header|NewLISP}}==

 

=={{header|Nim}}==

echo getFileSize "input.txt"

 

=={{header|Objeck}}==

use IO;

...

File("input.txt")->Size()->PrintLine();

File("c:\input.txt")->Size()->PrintLine();

 

=={{header|Objective-C}}==

 

 

// Pre-OS X 10.5

 

// OS X 10.5+

 

=={{header|OCaml}}==

 

let ic = open_in filename in

Printf.printf "%d\n" (in_channel_length ic);

 

printFileSize "input.txt" ;;

 

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]:

let ic = open_in filename in

Printf.printf "%Ld\n" (LargeFile.in_channel_length ic);

 

Alternatively:

open Unix ;;

Printf.printf "%d\n" (stat "input.txt").st_size ;;

 

The module Unix has also a [http://caml.inria.fr/pub/docs/manual-ocaml/libref/Unix.LargeFile.html LargeFile sub-module].

=={{header|Oforth}}==

 

 

=={{header|ooRexx}}==

Say v

fid='test.txt'

Say length(s)

Say 'file' fid

{{out}}

<pre>J:\>rexx sft

 

=={{header|Oz}}==

[Path] = {Module.link ['x-oz://system/os/Path.ozf']}

in

{Show {Path.size "input.txt"}}

 

=={{header|Pascal}}==

=={{header|Perl}}==

 

 

Or, to be 100% cross-platform:

my $size1 = -s 'input.txt';

 

Alternative way to get the size:

 

=={{header|Phix}}==

{{libheader|Phix/basics}}

<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: #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

 

=={{header|PHP}}==

echo filesize('input.txt'), "\n";

echo filesize('/input.txt'), "\n";

 

=={{header|PicoLisp}}==

 

=={{header|Pike}}==

int main(){

write(file_size("input.txt") + "\n");

write(file_size("/input.txt") + "\n");

 

=={{header|PL/I}}==

/* To obtain file size of files in root as well as from current directory. */

 

put skip list ('local file size=' || trim(i));

end test;

<pre>

I used differently-named files to prove that local and root directory

=={{header|Pop11}}==

 

sysfilesize('input.txt') =>

 

=={{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.

(input.txt) status pop pop pop = pop

(/input.txt ) print

 

=={{header|PowerShell}}==

 

=={{header|PureBasic}}==

 

=={{header|Python}}==

 

 

size = os.path.getsize('input.txt')

 

=={{header|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.

 

 

=={{header|Racket}}==

(file-size "input.txt")

 

=={{header|Raku}}==

(formerly Perl 6)

{{works with|Rakudo|2015.12}}

 

Cross-platform version of the second one:

 

=={{header|RapidQ}}==

Method 1: display file size using file streams

 

 

DIM file AS QFileStream

 

PRINT "Size of input.txt is "; fileSize("input.txt")

 

Method 2: using DIR$

 

PRINT "Size of input.txt is "; FileRec.Size

FileName$ = DIR$("\input.txt", 0)

 

=={{header|Raven}}==

 

=={{header|REBOL}}==

size? %/info.txt

size? ftp://username:password@ftp.site.com/info.txt

 

=={{header|Red}}==

== 39244

>> size? %/c/input.txt

 

=={{header|Retro}}==

The simple way is to open and read the size. This may crash if the file does not exist.

 

"input.txt" :R open &size sip close drop putn

 

For added stability, check that the returned file handle is not zero:

 

 

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:

 

: getFileSize ( $-n )

:R open 0 over =

 

"input.txt" getFileSize putn

 

=={{header|REXX}}==

 

Note that some operating systems don't have a concept of a &nbsp; ''current directory'' &nbsp; or a &nbsp; ''file system root''.

parse arg iFID . /*allow the user specify the file ID. */

if iFID=='' | iFID=="," then iFID='input.txt' /*Not specified? Then use the default.*/

fSize: parse arg f; $=0; do while chars(f)\==0; $ = $ + length( charin( f, , 1e4) )

end /*while*/; call lineout f /*close file.*/

{{out|output|text=&nbsp; when using the default input:}}

<pre>

 

===MS DOS version 2===

parse arg iFID . /*let user specify the file ID. */

if iFID=='' then iFID="FILESIZ.DAT" /*Not specified? Then use default*/

sz=sz+length(linein(f))

End

{{out}}

<pre>size of FILESIZ.DAT:

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 ('''.'''); &nbsp; it uses blanks instead.

parse arg iFID /*allow the user specify the file ID. */

if iFID=='' | iFID=="," then iFID= 'INPUT TXT' /*Not specified? Then use the default.*/

fSize: parse arg f; $= 0; do while lines(f)\==0; $= $ + length( linein(f) )

end /*while*/

 

=={{header|Ring}}==

 

=={{header|Ruby}}==

 

=={{header|Run BASIC}}==

print fileSize("","input.txt") ' root directory

 

fileSize = lof(#f) ' Length Of File

close #f

 

=={{header|Rust}}==

use std::io::{self, Write};

use std::fmt::Display;

}

 

 

=={{header|Scala}}==

{{libheader|Scala}}

 

object FileSize extends App {

println(s"$name : ${new File(name).length()} bytes")

println(s"/$name : ${new File(s"${File.separator}$name").length()} bytes")

 

=={{header|Scheme}}==

(define (file-size filename)

(call-with-input-file filename (lambda (port)

(file-size "input.txt")

(file-size "/input.txt")

 

=={{header|Seed7}}==

 

const proc: main is func

writeln(fileSize("input.txt"));

writeln(fileSize("/input.txt"));

 

=={{header|Sidef}}==

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

{{works with|Smalltalk/X}}

{{works with|VisualWorks Smalltalk}}

 

=={{header|Standard ML}}==

 

 

=={{header|Stata}}==

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.

 

file seek f eof

file seek f query

display r(loc)

 

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.

 

 

=={{header|Tcl}}==

 

=={{header|Toka}}==

A trivial method follows:

 

 

A better method would be to define a new function that actually

checks whether the file exists:

 

dup 0 <> [ dup file.size . file.close ] ifTrue

drop

 

" input.txt" display-size

 

=={{header|TorqueScript}}==

TGE Version (Works with all versions containing the basic file i/o):

{{works with|TGE}}

%File.openForRead("input.txt");

 

 

%File.close();

<br />

T3D Version (Only works with T3D):

{{works with|T3D}}

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

-- size of file input.txt

file_size=BYTES (file)

ERROR/STOP CLOSE (file)

 

=={{header|UNIX Shell}}==

''ls'' most likely gets the length from the file's inode.

 

 

''ls -l'' reports the size in 5th field, with spaces between fields.

and ''cut'' extracts 5th field.

 

echo "# ls:"

ls -la input.txt

size2=$(wc -c < input.txt | tr -d ' ')

echo $size1, $size2

{{Out}} Test run at compileonline.com:

<pre>

''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.

 

 

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.

{{works with|OpenBSD|3.8}}

 

 

===Z Shell===

{{works with|zsh}}

 

zmodload -F zsh/stat b:zstat

 

size1=$(zstat +size input.txt)

 

=={{header|Ursa}}==

 

f.open "input.txt"

f.open "/input.txt"

out (size f) endl console

 

=={{header|VBScript}}==

{{works with|Windows Script Host|*}}

With CreateObject("Scripting.FileSystemObject")

WScript.Echo .GetFile("input.txt").Size

WScript.Echo .GetFile("\input.txt").Size

End With

 

=={{header|Vedit macro language}}==

 

=={{header|Visual Basic}}==

{{works with|Visual Basic|6}}

 

----

DisplayFileSize Environ$("SystemRoot"), "input.txt"

End Sub

{{out}}

<pre>file size: 37 Bytes

 

{{works with|Visual Basic .NET|9.0+}}

Console.WriteLine(local.Length)

 

Dim root As New IO.FileInfo("\input.txt")

 

=={{header|Wren}}==

 

To check the size of a file in the root, just change "input.txt" to "/input.txt" in the following script.

 

var name = "input.txt"

 

{{out}}

 

=={{header|X86 Assembly}}==

; x86_64 linux nasm

 

mov rdi, 1

syscall

 

=={{header|XPL0}}==

char FileName; int Size, C;

[Trap(false); \disable abort on error

[ShowSize("input.txt");

ShowSize("/input.txt"); \root under Linux

 

=={{header|zkl}}==

-->T(size,creation time,last mod time,isDir,mode), from stat(2)

{{out}}