# Shortest code to dump a file into workable memory

This is a slightly different code golf from the usual problems. I'm forced to work with Java at my workplace and I'm increasingly annoyed at what I must do to read a file into memory to a String so I can operate on it in a normal way.

The golf is this: What is the shortest possible function to dump a file into your language's smallest data structure of characters?

Java would be char[], C++ would be char*, Haskell would be a [Char], etc. I don't care about complete programs or main() functions, but you do have to open and close the file.

inb4 Unix's >

• inb4 Unix's > ? – Prince John Wesley Jun 15 '12 at 14:28
• Why wouldn't be byte[] in java? – Prince John Wesley Jun 15 '12 at 14:39
• I guess it would, but I had string manipulation in my head when I wrote this. So just go with chars because that's what I'm really interested in. – eternalmatt Jun 15 '12 at 15:37
• You should specify that this is about text files and not any kind of data, since many high-level languages like Haskell or Java see chars as actual characters (or rather, Unicode codepoints) rather than bytes. Also, what do you mean by smallest structure? If you're talking about memory usage [Char] is definately not Haskell's smallest structure to store Strings. – AardvarkSoup Jun 16 '12 at 19:14
• Can't you just mmap the file? – gnibbler Jun 17 '12 at 11:04

# C#

var a = System.IO.File.ReadAllText("filename.txt");


a is a string that will contain the contents of filename.txt

# PHP

$a=file('foo.txt');  $a now contains an array of strings of the lines of foo.txt.

Similarly:

$a=file_get_contents('foo.txt');  $a now contains a single string of the contents of foo.txt.

• implode('',file('foo.txt')) is a bit shorter than file_get_contents('foo.txt'). Even shorter still if you use the alias join instead of implode. – Mr. Llama Jun 18 '12 at 15:46
• @GigaWatt How useful! Thanks! – TwoScoopsofPig Aug 9 '12 at 18:10

## Python

a=open('filename.txt').read()


The garbage collector will close the file.

## C (for unixoid systems)

#include <stdlib.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>

/* inside a function */
struct stat fd_stat;
int fd;
void *buffer;

int fd = open("my.file",O_RDONLY);
if (fd<0) exit(EXIT_FAILURE);
fstat(fd,fd_stat);
if (buffer==NULL) exit(EXIT_FAILURE);


This ridiculously long piece of code creates a buffer buffer of length fd_stat->st_size that contains the file. You probably won't use C for code-golfing anyway..

• Nothing wrong with using C for code-golfing in general. Maybe not with this particular problem, though. – breadbox Jun 16 '12 at 7:07

### Scala

In Scala, you can get a iterator easily:

scala> io.Source.fromFile("Cg6367.scala").getLines
res274: Iterator[String] = non-empty iterator


then you can iterate over a collection of lines with a for loop, or use one of the other 200 methods, usable on iterators, like map, forall, filter, first, head, last, drop, groupBy, sortBy, ... - you name it. Simply outputting the content would be:

val ls = io.Source.fromFile("Cg6367.scala").getLines
println (ls.mkString ("\n"))

• +1. Use iter to get Iterator[Char]. so is io.Source.fromFile("Cg6367.scala")iter – Prince John Wesley Jun 16 '12 at 3:43
• @PrinceJohnWesley: More interesting: How to use it in concise way from Java. I tried, but implicits don't work on Java, so I have to pass an Encoding as second parameter to the ctor, then I can't call getLines/iter for some reason ('iter has private access), transforming with JavaConversions isn't trivial too - I fear the scala-java-conversion will be as much Code, as nesting the Buffers/Streams and new File calls in pure Java. – user unknown Jun 16 '12 at 17:54
• The workaround is to construct interface in Java that define all the types that will be passed between Java and Scala. If we ignore the checked exception, java.nio.file.Files.readAllLines(new java.io.File(".").toPath(), java.nio.charset.Charset.defaultCharset()) is what i come up with in java 7. – Prince John Wesley Jun 17 '12 at 6:45

## J

a=.1!:1<'filename.txt'


a now contains a string representing the contents of filename.txt.

## C, 135 chars

Though 40 of those 135 chars are just because there are some #includes that you just can't skip:

#include<sys/mman.h>
#include<sys/stat.h>


(Add fcntl.h and unistd.h for non-golfing completeness.) Then in the place where the file contents are desired, it's as simple as:

struct stat s;char*p;int f=open("filename.txt",0);fstat(f,&s);
p=mmap(0,s.st_size,1,2,f,0);close(f);


The file is closed and p contains a pointer to the file contents. (Don't forget to call munmap() when you're done.)

• Actually, you shouldn't really need the includes. C code compiles just fine if the function you call is not prototyped. – FUZxxl Jun 18 '12 at 7:14
• Which is why I was able to omit fcntl.h and unistd.h. But you can't omit the definition of struct stat, thus sys/stat.h. You might think that you can omit sys/mman.h, but on my tests I was unable to avoid getting a segfault without it. – breadbox Jun 18 '12 at 7:24
• The problem is that there is some casting going on. If you manually cast the st_size and suffix the integer literals, it should work... – FUZxxl Jun 18 '12 at 7:26
• Yes, that's what I guessed too. But then I tested it and learned that I was wrong. – breadbox Jun 18 '12 at 7:28
• that is interesting... I have to investigate that. – FUZxxl Jun 18 '12 at 12:33

# C

There's already a C answer, but this one uses nothing more than the absolute basics. It's also rather odd, and doesn't handle errors, because if users are going to give bad inputs really they deserve to have the program crash on them.

#include <stdlib.h>
#include <stdio.h>

**b,**m;main(l){
FILE*f=fopen("foo.txt","r");
for(m=b=malloc(64);~(l=fgetc(f));){
*b++=&l;
b=malloc(64);
}
return fclose(f);
}


Dumps the file into a linked list of chars, which if it's good enough for Haskell, it's good enough for C. Assumes a pointer is 32 bits and EOF is -1. Clearly a linked list of ints is the most

# Ruby

• a=File.open('foo.txt', 'r') { |f| f.read }
• a=IO.read('foo.txt')

Clojure's slurp overload that doesn't take the encoding is deprecated (for good reason):

(slurp "a.txt")


Here's the way to specify the encoding

(slurp "a.txt" :encoding "UTF-8")


# Tcl

set t [read [open file.txt]]


# Groovy, 9 bytes, or 19

Closure expecting a File object:

{it.text}


Closure expecting a String filepath:

{new File(it).text}


# F#

let a = System.IO.File.ReadAllText("filename.txt")


a is a System.String that will contain the contents of filename.txt

.NET family <3

# Java 7, 108 bytes (Method, Byte[])

public byte[] r(String p)throws Exception{return java.nio.file.Files.readAllBytes(new java.io.File(p).toPath());}


# Java 7, 125 Bytes (Method, String)

public String r(String p)throws Exception{return new String(java.nio.file.Files.readAllBytes(new java.io.File(p).toPath()));}


# Java, 193 bytes (Method, Lines)

Here's a java method that reads an entire file as a List of strings, one line means 1 string. Linebreaks are detected as defined here.

Boiler-plate:

public class A {
public static void main(String[] args) throws Exception {
List<String> lines = readLines(args[0]);
}
}


Method:

import java.util.*;public List readLines(String path)throws Exception{List l=new ArrayList();Scanner s=new Scanner(new java.io.File(path));while(l.add(s.nextLine())&&s.hasNextLine());return l;}


Ungolfed:

public List readLines(String path)throws Exception{
List l = new ArrayList();
Scanner s = new Scanner(new java.io.File(path));
return l;
}


Ungolfed (With Best-Practices):

public static List<String> readLines(String path) throws FileNotFoundException {
List<String> l = new ArrayList<String>();
Scanner s = new Scanner(new java.io.File(path));
s.close();
return l;
}


## Swift

import Foundation

let contents = try! String(contentsOfFile: "filename.txt")


# C, 110 bytes without filename

Another C answer. This one is very inefficient, but at least it is short. First is the header:

#import<stdio.h>


And then the code (N is the filename):

char*r,c;FILE*F=fopen(N,"r");for(int i=r=0;~(c=fgetc(F));r[i-1]=c)r=realloc(r,++i);fclose(F);


Assumes EOF is -1. r will be a pointer to the result block. (If N is empty file, then it will be a null pointer)

# q/kdb+, 9 bytes + filename

Solution:

a:read0:filename.txt


a is now a list of lists; a list of chars for each line in filename.txt.

Explanation:

a:read0:filename.txt / solution
:filename.txt / path to the file, in this case filename.txt
a:                    / assign to variable a


Or we could drop to the k prompt we can do if we wanted to conserve some bytes:

\
a:0::filename.txt


# Perl 5, 26 bytes

sub{local(@ARGV,\$/)=@_;<>}


Try it online!

# AutoHotkey

FileRead,a,foo.txt


a is a variable that now contains all the contents of the file foo.txt so long as that file is less than 1 GB. If file size or available memory is a problem, then you can loop through each line of a file instead using Loop,Read,foo.txt.

It has some options available such as limiting the read to the first n bytes or reading the file using a different file encoding so long as it's from a standard list.