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.

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); buffer = mmap(NULL,fd_stat->st_size,PROT_READ,MAP_SHARED,fd,0); 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..

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

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

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)); while(l.add(s.nextLine())&&s.hasNextLine()); 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)); while(l.add(s.nextLine())&&s.hasNextLine()); 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 read0 / read file as characters 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.