File size

In this task, the job is to 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.

Ada

<lang 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;</lang> Note that reference to the root directory, if there is any, is OS specific.

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 CHARS, 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.

AutoHotkey

<lang 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</lang>

C

<lang c>#include <stdio.h>

long getFileSize(const char *filename) {

 long result;
 FILE *fh = fopen(filename, "r");
 fseek(fh, 0, SEEK_END);
 result = ftell(fh);
 fclose(fh);
 return result;

}

int main() {

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

}</lang>

Works with: POSIX

<lang c>#include <stdio.h>

include <sys/stat.h>

int main() {

 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;

}</lang>

C++

<lang cpp>#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;

}</lang>

C#

<lang csharp>using System; using System.IO;

Console.WriteLine(new FileInfo("/file.txt").Length); Console.WriteLine(new FileInfo("file.txt").Length);</lang>

Clean

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

<lang clean>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</lang>

Clojure

<lang lisp>(import '[java.io File]) (defn show-size [filename]

 (println filename "size:" (.length (File. filename))))

(show-size "input.txt") (show-size "/input.txt")</lang>

Common Lisp

<lang 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)))</lang>

D

Alternative ways to get file size in D. <lang d>module fileio ; import std.stdio ; import std.path ; import std.file ; import std.mmfile ; // NB: mmfile can treat the file as an array in memory import std.stream ;

string[] genName(string name){

 string cwd  = curdir ~ sep ; // on current directory
 string root = sep ;          // on root 
 // remove path, left only basename
 name = std.path.getBaseName(name) ;  
 // NB:in D ver.2, getBaseName is alias of basename
 return [cwd ~ name, root ~ name] ;

}

void testsize(string fname) {

 foreach(fn ; genName(fname)){
   try {
     writefln("file %s has size:", fn) ;
     writefln("%10d bytes by std.file.getSize (function),", std.file.getSize(fn)) ;
     writefln("%10d bytes by std.stream (class),", (new std.stream.File(fn)).size) ;
     writefln("%10d bytes by std.mmfile (class).", (new std.mmfile.MmFile(fn)).length) ;
   } catch (Exception e) {
     writefln(e.msg) ;
   }
 }

}

void main(){

 writefln("== test : File Size ==") ;
 testsize(r".\input.txt") ;

}</lang>

E

<lang e>for file in [<file:input.txt>, <file:///input.txt>] {

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

}</lang>

Factor

<lang factor>"input.txt" file-info size>> .

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

"Unix system call ``stat failed:"...</lang>

Forth

<lang 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</lang>

Groovy

<lang groovy>println new File('index.txt').length(); println new File('/index.txt').length();</lang>

Haskell

<lang haskell>import System.IO

printFileSize filename = withFile filename ReadMode hFileSize >>= print

main = mapM_ printFileSize ["input.txt", "/input.txt"]</lang> or <lang haskell>import System.Posix.File

printFileSize filename = do stat <- getFileStatus filename

                           print (fileSize stat)

main = mapM_ printFileSize ["input.txt", "/input.txt"]</lang>

J

<lang J>require 'files' fsize 'input.txt';'/input.txt'</lang>

Java

<lang java>import java.util.File; public class FileSizeTest {

  public static long getFileSize(String filename) {
      return new File(filename).length();
  }
  public static void test(String type, String filename) {
      System.out.println("The following " + type + " called " + filename + 
          " has a file size of " + getFileSize(filename) + " bytes."
      );
  }
  public static void main(String args[]) {
       test("file", "input.txt");
       test("file", File.seperator + "input.txt");
  }

}</lang>

JavaScript

Works with: JScript

<lang javascript>var fso = new ActiveXObject("Scripting.FileSystemObject"); fso.GetFile('input.txt').Size; fso.GetFile('c:/input.txt').Size;</lang>

Mathematica

<lang Mathematica>SetDirectory[NotebookDirectory[]] FileByteCount["input.txt"] SetDirectory[$RootDirectory] FileByteCount["input.txt"]</lang>

MAXScript

<lang maxscript>-- Returns filesize in bytes or 0 if the file is missing getFileSize "index.txt" getFileSize "\index.txt"</lang>

Objective-C

<lang objc>NSFileManager *fm = [NSFileManager defaultManager];

NSLog(@"%llu", [[fm fileAttributesAtPath:@"input.txt" traverseLink:YES] fileSize]);</lang>

OCaml

<lang 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" ;;</lang>

For files greater than Pervasives.max_int, one can use the module Unix.LargeFile: <lang ocaml>let printLargeFileSize filename =

 let ic = open_in filename in
 Printf.printf "%Ld\n" (LargeFile.in_channel_length ic);
 close_in ic ;;</lang>

Alternatively: <lang ocaml>#load "unix.cma" ;; open Unix ;; Printf.printf "%d\n" (stat "input.txt").st_size ;; Printf.printf "%d\n" (stat "/input.txt").st_size ;;</lang>

Perl

<lang perl>use File::Spec::Functions qw(catfile rootdir); print -s 'input.txt'; print -s catfile rootdir, 'input.txt';</lang>

PHP

Pike

<lang pike>import Stdio;

int main(){

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

}</lang>

Pop11

<lang pop11>;;; prints file size in bytes sysfilesize('input.txt') => sysfilesize('/input.txt') =></lang>

PowerShell

<lang powershell>Get-ChildItem input.txt | Select-Object Name,Length Get-ChildItem \input.txt | Select-Object Name,Length</lang>

Python

<lang python>import os

size = os.path.getsize('input.txt') size = os.path.getsize('/input.txt')</lang>

R

Works with: R version 2.8.1

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.

<lang R>sizeinwd <- file.info('input.txt')"size" sizeinroot <- file.info('/input.txt')"size"</lang>

REBOL

<lang REBOL>size? %info.txt size? %/info.txt size? ftp://username:password@ftp.site.com/info.txt size? http://rosettacode.org</lang>

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

<lang rapidq>$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")</lang>

Method 2: using DIR$

<lang rapidq>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</lang>

A better method would be to define a new function that actually checks whether the file exists:

<lang toka>[ "R" file.open

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

] is display-size

" input.txt" display-size " /input.txt" display-size</lang>

UNIX Shell

<lang bash>for file in "input.txt" "/input.txt"; do

 if [ -b "$file" ]; then
   /sbin/blockdev --getsize64 "$file"
 else
   echo $(find "$file" -printf %s)  
   #echo $(stat --format %s "$file")
   #echo $(du -b "$file" | cut -f1)
 fi

done</lang>

Vedit macro language

<lang vedit>Num_Type(File_Size("input.txt")) Num_Type(File_Size("/input.txt"))</lang>

Visual Basic .NET

Platform: .NET

Works with: Visual Basic .NET version 9.0+

<lang vbnet>Dim local As New IO.FileInfo("input.txt") Console.WriteLine(local.Length)

Dim root As New IO.FileInfo("\input.txt") Console.WriteLine(root.Length)</lang>