File size: Difference between revisions
mNo edit summary |
No edit summary |
||
Line 4: | Line 4: | ||
=={{header|Ada}}== |
=={{header|Ada}}== |
||
<ada>with Ada.Directories; use Ada.Directories; |
<lang ada>with Ada.Directories; use Ada.Directories; |
||
with Ada.Text_IO; use Ada.Text_IO; |
with Ada.Text_IO; use Ada.Text_IO; |
||
Line 11: | Line 11: | ||
Put_Line (File_Size'Image (Size ("input.txt")) & " bytes"); |
Put_Line (File_Size'Image (Size ("input.txt")) & " bytes"); |
||
Put_Line (File_Size'Image (Size ("/input.txt")) & " bytes"); |
Put_Line (File_Size'Image (Size ("/input.txt")) & " bytes"); |
||
end Test_File_Size;</ |
end Test_File_Size;</lang> |
||
Note that reference to the root directory, if there is any, is [[OS]] specific. |
Note that reference to the root directory, if there is any, is [[OS]] specific. |
||
Line 18: | Line 18: | ||
special channel, e.g. a tape device. |
special channel, e.g. a tape device. |
||
Conceptually the procedure "< |
Conceptually the procedure "<tt>PROC set = (REF FILE file, INT page, line, character)VOID: ~ </tt>" |
||
could be used to do a binary search find the last page's page number. And if it is known |
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 < |
that every page has the same number of lines, and every line has the same number of <tt>CHARS</tt>, |
||
and the character set is not < |
and the character set is not <tt>compressible</tt>, then the size could be quickly calculated. |
||
Otherwise every page, and every line would have to be tallied. |
Otherwise every page, and every line would have to be tallied. |
||
Line 28: | Line 28: | ||
=={{header|C}}== |
=={{header|C}}== |
||
<c>#include <stdio.h> |
<lang c>#include <stdio.h> |
||
long getFileSize(const char *filename) { |
long getFileSize(const char *filename) { |
||
Line 43: | Line 43: | ||
printf("%ld\n", getFileSize("/input.txt")); |
printf("%ld\n", getFileSize("/input.txt")); |
||
return 0; |
return 0; |
||
}</ |
}</lang> |
||
{{works with|POSIX}} |
{{works with|POSIX}} |
||
<c>#include <stdio.h> |
<lang c>#include <stdio.h> |
||
#include <sys/stat.h> |
#include <sys/stat.h> |
||
Line 56: | Line 56: | ||
printf("%ld\n", foo.st_size); |
printf("%ld\n", foo.st_size); |
||
return 0; |
return 0; |
||
}</ |
}</lang> |
||
=={{header|C++}}== |
=={{header|C++}}== |
||
<cpp>#include <iostream> |
<lang cpp>#include <iostream> |
||
#include <fstream> |
#include <fstream> |
||
Line 74: | Line 74: | ||
std::cout << getFileSize("/input.txt") << std::endl; |
std::cout << getFileSize("/input.txt") << std::endl; |
||
return 0; |
return 0; |
||
}</ |
}</lang> |
||
=={{header|Clean}}== |
=={{header|Clean}}== |
||
Line 93: | Line 93: | ||
=={{header|D}}== |
=={{header|D}}== |
||
Alternative ways to get file size in D. |
Alternative ways to get file size in D. |
||
<d>module fileio ; |
<lang d>module fileio ; |
||
import std.stdio ; |
import std.stdio ; |
||
import std.path ; |
import std.path ; |
||
Line 125: | Line 125: | ||
writefln("== test : File Size ==") ; |
writefln("== test : File Size ==") ; |
||
testsize(r".\input.txt") ; |
testsize(r".\input.txt") ; |
||
}</ |
}</lang> |
||
=={{header|Factor}}== |
=={{header|Factor}}== |
||
"input.txt" file-info size>> . |
"input.txt" file-info size>> . |
||
Line 166: | Line 166: | ||
=={{header|Java}}== |
=={{header|Java}}== |
||
<java>import java.util.File; |
<lang java>import java.util.File; |
||
public class FileSizeTest { |
public class FileSizeTest { |
||
public static long getFileSize(String filename) { |
public static long getFileSize(String filename) { |
||
Line 180: | Line 180: | ||
test("file", File.seperator + "input.txt"); |
test("file", File.seperator + "input.txt"); |
||
} |
} |
||
}</ |
}</lang> |
||
=={{header|MAXScript}}== |
=={{header|MAXScript}}== |
||
Line 189: | Line 189: | ||
=={{header|OCaml}}== |
=={{header|OCaml}}== |
||
<ocaml>let printFileSize filename = |
<lang ocaml>let printFileSize filename = |
||
let ic = open_in filename in |
let ic = open_in filename in |
||
Printf.printf "%d\n" (in_channel_length ic); |
Printf.printf "%d\n" (in_channel_length ic); |
||
Line 195: | Line 195: | ||
printFileSize "input.txt" ;; |
printFileSize "input.txt" ;; |
||
printFileSize "input.txt" ;;</ |
printFileSize "input.txt" ;;</lang> |
||
For files greater than Pervasives.max_int, one can use the module [http://caml.inria.fr/pub/docs/manual-ocaml/libref/Unix.LargeFile.html Unix.LargeFile]: |
For files greater than Pervasives.max_int, one can use the module [http://caml.inria.fr/pub/docs/manual-ocaml/libref/Unix.LargeFile.html Unix.LargeFile]: |
||
<ocaml>let printLargeFileSize filename = |
<lang ocaml>let printLargeFileSize filename = |
||
let ic = open_in filename in |
let ic = open_in filename in |
||
Printf.printf "%Ld\n" (LargeFile.in_channel_length ic); |
Printf.printf "%Ld\n" (LargeFile.in_channel_length ic); |
||
close_in ic ;;</ |
close_in ic ;;</lang> |
||
Alternatively: |
Alternatively: |
||
<ocaml>#load "unix.cma" ;; |
<lang ocaml>#load "unix.cma" ;; |
||
open Unix ;; |
open Unix ;; |
||
Printf.printf "%d\n" (stat "input.txt").st_size ;; |
Printf.printf "%d\n" (stat "input.txt").st_size ;; |
||
Printf.printf "%d\n" (stat "/input.txt").st_size ;;</ |
Printf.printf "%d\n" (stat "/input.txt").st_size ;;</lang> |
||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
<perl>use File::Spec::Functions qw(catfile rootdir); |
<lang perl>use File::Spec::Functions qw(catfile rootdir); |
||
print -s 'input.txt'; |
print -s 'input.txt'; |
||
print -s catfile rootdir, 'input.txt';</ |
print -s catfile rootdir, 'input.txt';</lang> |
||
=={{header|Pop11}}== |
=={{header|Pop11}}== |
||
Line 222: | Line 222: | ||
=={{header|Python}}== |
=={{header|Python}}== |
||
<python>import os |
<lang python>import os |
||
size = os.path.getsize('input.txt') |
size = os.path.getsize('input.txt') |
||
size = os.path.getsize('/input.txt')</ |
size = os.path.getsize('/input.txt')</lang> |
||
=={{header|RapidQ}}== |
=={{header|RapidQ}}== |
||
Line 257: | Line 257: | ||
=={{header|Ruby}}== |
=={{header|Ruby}}== |
||
<python>size = File.size('input.txt') |
<lang python>size = File.size('input.txt') |
||
size = File.size('/input.txt')</ |
size = File.size('/input.txt')</lang> |
||
=={{header|Toka}}== |
=={{header|Toka}}== |
Revision as of 15:32, 3 February 2009
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.
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.
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>
<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>
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
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>
Factor
"input.txt" file-info size>> . 1321 "file-does-not-exist.txt" file-info size>> "Unix system call ``stat failed:"...
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
Groovy
println new File('index.txt').length(); println new File('/index.txt').length();
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"]
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>
MAXScript
-- Returns filesize in bytes or 0 if the file is missing getFileSize "index.txt" getFileSize "\index.txt"
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>
Pop11
;;; prints file size in bytes sysfilesize('input.txt') => sysfilesize('/input.txt') =>
Python
<lang python>import os
size = os.path.getsize('input.txt') size = os.path.getsize('/input.txt')</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
$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
Raven
'input.txt' status.size '/input.txt' status.size
Ruby
<lang python>size = File.size('input.txt') size = File.size('/input.txt')</lang>
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
UNIX Shell
du input.txt du /input.txt
Visual Basic .NET
Platform: .NET
Dim local As New IO.FileInfo("input.txt") Console.WriteLine(local.Length) Dim root As New IO.FileInfo("\input.txt") Console.WriteLine(root.Length)