File size: Difference between revisions

{{task|File System Operations}}

 

 

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

It is probably much easier to use some an operating system library. This library is not part of

the standard ALGOL 68 language definition.

 

=={{header|AutoHotkey}}==

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

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

 

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

#include <fstream>

 

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

return 0;

 

 

{

}

}

 

=={{header|Clean}}==

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]

 

(show-size "input.txt")

 

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

 

=={{header|D}}==

 

void main() {

 

 

 

 

}

 

=={{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|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|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")

 

=={{header|Forth}}==

 

r/o open-file throw

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

 

s" input.txt" .filesize

 

 

 

 

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

 

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

local fp = io.open( filename )

if fp == nil then

fp:close()

return filesize

 

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

use IO;

...

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

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

 

=={{header|OCaml}}==

 

let ic = open_in filename in

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

 

printFileSize "input.txt" ;;

 

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

 

=={{header|Oz}}==

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

in

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

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

 

 

 

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

 

</pre>

 

===CMS version===

Note that CMS hasn't a concept of a ''root''.

 

 

=={{header|Ruby}}==

 

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

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

 

fileSize = lof(#f) ' Length Of File

close #f

 

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

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

{{works with|Smalltalk/X}}

{{works with|VisualWorks Smalltalk}}

 

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

 

 

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

 

 

 

===Using wc===

''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|Vedit macro language}}==

 

=={{header|Visual Basic .NET}}==

 

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

Console.WriteLine(local.Length)

 

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

 

{{omit from|Befunge}} <!-- No filesystem support -->

{{omit from|HTML}}

{{omit from|PARI/GP}}