File size

From Rosetta Code
Jump to: navigation, search
Task
File size
You are encouraged to solve this task according to the task description, using any language you may know.

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.

Contents

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

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

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

[edit] 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;
}
Works with: POSIX
#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;
}

[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("/input.txt").Length);
Console.WriteLine(new FileInfo("input.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] 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>

[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

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)

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

[edit] E

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

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

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

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

[edit] Factor

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

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

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

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

[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

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.

[edit] J

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

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

[edit] JavaScript

Works with: JScript
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);
}

[edit] Julia

println(filesize("input.txt"))
println(filesize("/input.txt"))

[edit] K

_size "input.txt"
_size "/input.txt"


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

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

[edit] Lua

FileTools:-Size( "input.txt" )
FileTools:-Size( "/input.txt" )

[edit] Mathematica

 
FileByteCount["input.txt"]
FileByteCount[FileNameJoin[{$RootDirectory, "input.txt"}]]

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

[edit] MAXScript

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

[edit] Mirah

import java.io.File
 
puts File.new('file-size.mirah').length()
puts File.new("./#{File.separator}file-size.mirah").length()

[edit] mIRC Scripting Language

echo -ag $file(input.txt).size bytes
echo -ag $file(C:\input.txt).size bytes

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

[edit] NetRexx

/* NetRexx */
options replace format comments java crossref 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
 

[edit] NewLISP

(println (first (file-info "input.txt")))
(println (first (file-info "/input.txt")))

[edit] Nimrod

import os
echo getFileSize "input.txt"
echo getFileSize "/input.txt"

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

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

See Delphi

[edit] Perl

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

[edit] Perl 6

say 'input.txt'.IO.s;
say '/input.txt'.IO.s;

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

[edit] Pop11

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

[edit] 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 poped off the stack.

(input.txt  ) print
(input.txt) status pop pop pop = pop
(/input.txt ) print
(/input.txt) status pop pop pop = pop

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

#lang racket
(file-size "input.txt")
(file-size "/input.txt")

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

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

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

[edit] REXX

[edit] MS DOS version

This REXX example was executed on a Windows/XP system (in a DOS window).

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

/*REXX pgm to verify a file's size (by reading the lines) in CD & root. */
parse arg iFID . /*let user specify the file ID. */
if iFID=='' then iFID="FILESIZ.DAT" /*Not specified? Then use default*/
say 'size of' iFID "=" filesize(iFID) 'bytes' /*current dir.*/
say 'size of \..\'iFID "=" filesize('\..\'iFID) 'bytes' /* root dir.*/
exit /*stick a fork in it, we're done.*/
 
/*──────────────────────────────────FILESIZE subroutine─────────────────*/
filesize: parse arg f; $=0; do while lines(f)\==0
$=$+length(charin(f,,1e6))
end /*while*/
return $

output when using the default input:

size of FILESIZ.DAT = 2 bytes
size of \..\FILESIZ.DAT = 5 bytes

[edit] 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 pgm to verify a file's size (by reading the lines) on default MD.*/
parse arg iFID /*let user specify the file ID. */
if iFID='' then iFID="FILESIZ DAT A" /*Not specified? Then use default*/
say 'size of' iFID "=" filesize(iFID) 'bytes' /*on the default MD.*/
exit /*stick a fork in it, we're done.*/
 
/*──────────────────────────────────FILESIZE subroutine─────────────────*/
filesize: parse arg f; $=0; do while lines(f)\==0
$=$+length(linein(f))
end /*while*/
return $

[edit] Ruby

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

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

[edit] Rust

fn main() {
let path_wd = Path::new("input.txt");
println!("{}", path_wd.stat().size);
 
let path_root = Path::new("/input.txt");
println!("{}", path_root.stat().size);
}

[edit] Scala

Library: 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")
}

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

say (Dir.cwd  + %f'input.txt' -> size);
say (Dir.root + %f'input.txt' -> size);

[edit] Slate

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

[edit] Smalltalk

Works with: GNU Smalltalk
(File name: 'input.txt') size printNl.
(File name: '/input.txt') size printNl.
Works with: Smalltalk/X
'input.txt' asFilename fileSize
'/input.txt' asFilename fileSize

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

Works with: TGE
%File = new FileObject();
%File.openForRead("input.txt");
 
while(!%File.isEOF())
{
%Length += strLen(%File.readLine());
}
 
%File.close();
%File.delete();


T3D Version (Only works with T3D):

Works with: T3D
fileSize("input.txt");

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

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

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

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

[edit] Using BSD stat

BSD has stat(1), a nonstandard command. With stat, a shell script can easily get the file size.

Works with: NetBSD version 1.6
Works with: FreeBSD version 4.10
Works with: OpenBSD version 3.8
size1=$(stat -f %z input.txt)
size2=$(stat -f %z /input.txt)

[edit] Z Shell

Works with: zsh
# from module 'zsh/stat', load builtin 'zstat'
zmodload -F zsh/stat b:zstat
 
size1=$(zstat +size input.txt)
size2=$(zstat +size /input.txt)

[edit] VBScript

Works with: Windows Script Host version *
 
With CreateObject("Scripting.FileSystemObject")
WScript.Echo .GetFile("input.txt").Size
WScript.Echo .GetFile("\input.txt").Size
End With
 

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


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

Variants
Actions
Community
Explore
Misc
Toolbox