File size

From Rosetta Code

(Redirected from 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.

[edit] 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.

[edit] 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.

[edit] 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

[edit] 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;
}

Works with: POSIX

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

[edit] 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;
}

[edit] C#

using System;
using System.IO;
 
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine(new FileInfo("/file.txt").Length);
        Console.WriteLine(new FileInfo("file.txt").Length);
    }
}

[edit] 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

[edit] Clojure

(import '[java.io File])
(defn show-size [filename]
  (println filename "size:" (.length (File. filename))))
 
(show-size "input.txt")
(show-size "/input.txt")

[edit] 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)))

[edit] D

Alternative ways to get file size in 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") ;
}

The normal way to get get file size in D version 2:

import std.file: getSize;
 
void main() {
    auto len = getSize("data.txt");
}

[edit] E

for file in [<file:input.txt>, <file:///input.txt>] {
  println(`The size of $file is ${file.length()} bytes.`)
}

[edit] 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.

[edit] Factor

"input.txt" file-info size>> .
    1321
"file-does-not-exist.txt" file-info size>>
 "Unix system call ``stat'' failed:"...

[edit] 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

[edit] Go

package main
import "fmt"
import "os"
 
func main() {
  stat, _ := os.Stat("input.txt")
  fmt.Println(stat.Size);
  stat, _ = os.Stat("/input.txt")
  fmt.Println(stat.Size);
}

[edit] Groovy

println new File('index.txt').length();
println new File('/index.txt').length();

[edit] 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"]

[edit] HicEst

READ(FILE="input.txt", LENgth=bytes) ! bytes = -1 if not existent
READ(FILE="C:\input.txt", LENgth=bytes) ! bytes = -1 if not existent

[edit] Icon and Unicon

[edit] Icon

Icon doesn't support 'stat'; however, information can be obtained by use of the system function to access command line.

[edit] Unicon

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.

[edit] J

require 'files'
fsize 'input.txt';'/input.txt'

[edit] 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");
   }
}

[edit] JavaScript

Works with: JScript

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

[edit] 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

[edit] Mathematica

SetDirectory[NotebookDirectory[]]
FileByteCount["input.txt"]
SetDirectory[$RootDirectory]
FileByteCount["input.txt"]

[edit] MAXScript

-- Returns filesize in bytes or 0 if the file is missing
getFileSize "index.txt"
getFileSize "\index.txt"

[edit] Objective-C

NSFileManager *fm = [NSFileManager defaultManager];
 
NSLog(@"%llu", [[fm fileAttributesAtPath:@"input.txt" traverseLink:YES] fileSize]);

[edit] Objeck

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

[edit] 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 Unix.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 ;;

[edit] Oz

declare
  [Path] = {Module.link ['x-oz://system/os/Path.ozf']}
in
  {Show {Path.size "input.txt"}}
  {Show {Path.size "/input.txt"}}

[edit] Perl

use File::Spec::Functions qw(catfile rootdir);
print -s 'input.txt';
print -s catfile rootdir, 'input.txt';

[edit] PHP

<?php
echo filesize('input.txt'), "\n";
echo filesize('/input.txt'), "\n";
?>

[edit] PicoLisp

(println (car (info "input.txt")))
(println (car (info "/input.txt")))

[edit] Pike

import Stdio;
 
int main(){
   write(file_size("input.txt") + "\n");
   write(file_size("/input.txt") + "\n");
}

[edit] Pop11

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

[edit] PowerShell

Get-ChildItem input.txt | Select-Object Name,Length
Get-ChildItem \input.txt | Select-Object Name,Length

[edit] PureBasic

Debug FileSize("input.txt")
Debug FileSize("/input.txt")

[edit] Python

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

[edit] 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.

sizeinwd <- file.info('input.txt')[["size"]]
sizeinroot <- file.info('/input.txt')[["size"]]

[edit] REBOL

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

[edit] 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

[edit] Raven

'input.txt'  status.size
'/input.txt' status.size

[edit] Ruby

size = File.size('input.txt')
size = File.size('/input.txt')

[edit] 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")

[edit] Seed7

$ include "seed7_05.s7i";
 
const proc: main is func
  begin
    writeln(fileSize("input.txt"));
    writeln(fileSize("/input.txt"));
  end func;

[edit] Slate

(File newNamed: 'input.txt') fileInfo fileSize.
(File newNamed: '/input.txt') fileInfo fileSize.

[edit] Smalltalk

(File name: 'input.txt') size printNl.
(File name: '/input.txt') size printNl.

[edit] Standard ML

val size = OS.FileSys.fileSize "input.txt" ;;
val size = OS.FileSys.fileSize "/input.txt" ;

[edit] Tcl

file size input.txt
file size /input.txt

[edit] 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

[edit] UNIX Shell

for file in "input.txt" "/input.txt"; do
  if [ -b "$file" ]; then
    /sbin/blockdev --getsize64 "$file"
  else
    wc -c < "$file"
    #echo $(find "$file" -printf %s)  
    #echo $(stat --format %s "$file")
    #echo $(du -b "$file" | cut -f1)
  fi
done

[edit] Vedit macro language

Num_Type(File_Size("input.txt"))
Num_Type(File_Size("/input.txt"))

[edit] Visual Basic .NET

Platform: .NET

Works with: Visual Basic .NET version 9.0+

Dim local As New IO.FileInfo("input.txt")
Console.WriteLine(local.Length)
 
Dim root As New IO.FileInfo("\input.txt")
Console.WriteLine(root.Length)