Objective-C: Lire un fichier ligne par ligne

Quelle est la manière appropriée de traiter les fichiers texte volumineux dans Objective-C? Disons que j'ai besoin de lire chaque ligne séparément et que je veux traiter chaque ligne comme une NSString. Quelle est la manière la plus efficace de procéder?

Une solution consiste à utiliser la méthode NSString:

+ (id)stringWithContentsOfFile:(NSString *)path 
      encoding:(NSStringEncoding)enc 
      error:(NSError **)error 

puis divisez les lignes avec un séparateur de nouvelle ligne, puis parcourez les éléments du tableau. Cependant, cela semble assez inefficace. N'existe-t-il pas un moyen facile de traiter le fichier comme un flux, en énumérant chaque ligne, au lieu de simplement tout lire en même temps? Un peu comme java.io.BufferedReader de Java.

C'est une excellente question. Je pense que @Diederik a une bonne réponse, même s'il est regrettable que Cocoa n'ait pas de mécanisme pour exactement ce que vous voulez faire.

NSInputStreamvous permet de lire des morceaux de N octets (très similaire à java.io.BufferedReader), mais vous devez le convertir en un NSStringseul, puis rechercher les nouvelles lignes (ou tout autre délimiteur) et enregistrer les caractères restants pour la prochaine lecture, ou lire plus de caractères si une nouvelle ligne n'a pas encore été lue. ( NSFileHandlevous permet de lire un NSDataque vous pouvez ensuite convertir en un NSString, mais c'est essentiellement le même processus.)

Apple a un guide de programmation de flux qui peut aider à remplir les détails, et cette question SO peut également vous aider si vous avez affaire à des uint8_t*tampons.

Si vous lisez fréquemment des chaînes comme celle-ci (en particulier dans différentes parties de votre programme), ce serait une bonne idée d'encapsuler ce comportement dans une classe qui peut gérer les détails pour vous, ou même de sous-classer NSInputStream(il est conçu pour être sous-classées ) et en ajoutant des méthodes qui vous permettent de lire exactement ce que vous voulez.

Pour mémoire, je pense que ce serait une fonctionnalité intéressante à ajouter, et je vais déposer une demande d'amélioration pour quelque chose qui rend cela possible. :-)

Modifier: il s'avère que cette demande existe déjà. Il existe un radar datant de 2006 pour cela (rdar: // 4742914 pour les personnes internes à Apple).

Cela fonctionnera pour la lecture générale Stringde Text. Si vous souhaitez lire du texte plus long ( texte de grande taille) , utilisez la méthode mentionnée par d'autres personnes ici, par exemple en mémoire tampon (réservez la taille du texte dans l'espace mémoire) .

Disons que vous lisez un fichier texte.

NSString* filePath = @""//file path...
NSString* fileRoot = [[NSBundle mainBundle] 
               pathForResource:filePath ofType:@"txt"];

Vous voulez vous débarrasser de la nouvelle ligne.

// read everything from text
NSString* fileContents = 
      [NSString stringWithContentsOfFile:fileRoot 
       encoding:NSUTF8StringEncoding error:nil];

// first, separate by new line
NSArray* allLinedStrings = 
      [fileContents componentsSeparatedByCharactersInSet:
      [NSCharacterSet newlineCharacterSet]];

// then break down even further 
NSString* strsInOneLine = 
      [allLinedStrings objectAtIndex:0];

// choose whatever input identity you have decided. in this case ;
NSArray* singleStrs = 
      [currentPointString componentsSeparatedByCharactersInSet:
      [NSCharacterSet characterSetWithCharactersInString:@";"]];

Voilà.

Cela devrait faire l'affaire:

#include <stdio.h>

NSString *readLineAsNSString(FILE *file)
{
    char buffer[4096];

    // tune this capacity to your liking -- larger buffer sizes will be faster, but
    // use more memory
    NSMutableString *result = [NSMutableString stringWithCapacity:256];

    // Read up to 4095 non-newline characters, then read and discard the newline
    int charsRead;
    do
    {
        if(fscanf(file, "%4095[^\n]%n%*c", buffer, &charsRead) == 1)
            [result appendFormat:@"%s", buffer];
        else
            break;
    } while(charsRead == 4095);

    return result;
}

Utilisez comme suit:

FILE *file = fopen("myfile", "r");
// check for NULL
while(!feof(file))
{
    NSString *line = readLineAsNSString(file);
    // do stuff with line; line is autoreleased, so you should NOT release it (unless you also retain it beforehand)
}
fclose(file);

Ce code lit les caractères non-nouvelle ligne du fichier, jusqu'à 4095 à la fois. Si vous avez une ligne de plus de 4095 caractères, la lecture continue jusqu'à ce qu'elle atteigne une nouvelle ligne ou une fin de fichier.

Remarque : je n'ai pas testé ce code. Veuillez le tester avant de l'utiliser.

Mac OS X est Unix, Objective-C est un sur-ensemble C, vous pouvez donc simplement utiliser old-school fopenet fgetsfrom <stdio.h>. Il est garanti de fonctionner.

[NSString stringWithUTF8String:buf]convertira la chaîne C en NSString. Il existe également des méthodes pour créer des chaînes dans d'autres encodages et créer sans copier.

Vous pouvez utiliser NSInputStreamqui a une implémentation de base pour les flux de fichiers. Vous pouvez lire des octets dans un tampon ( read:maxLength:méthode). Vous devez scanner vous-même la mémoire tampon pour les nouvelles lignes.

La manière appropriée de lire les fichiers texte dans Cocoa / Objective-C est documentée dans le guide de programmation String d'Apple. La section pour lire et écrire des fichiers devrait être exactement ce que vous recherchez. PS: Qu'est-ce qu'une "ligne"? Deux sections d'une chaîne séparées par "\ n"? Ou "\ r"? Ou "\ r \ n"? Ou peut-être êtes-vous en fait après les paragraphes? Le guide mentionné précédemment comprend également une section sur la division d'une chaîne en lignes ou en paragraphes. (Cette section s'appelle "Paragraphes et sauts de ligne" et est liée dans le menu de gauche de la page que j'ai indiquée ci-dessus. Malheureusement, ce site ne me permet pas de publier plus d'une URL car je suis pas encore un utilisateur digne de confiance.)

Pour paraphraser Knuth: l'optimisation prématurée est la racine de tout mal. Ne supposez pas simplement que "lire le fichier entier en mémoire" est lent. L'avez-vous évalué? Savez-vous qu'il lit réellement le fichier entier en mémoire? Peut-être qu'il renvoie simplement un objet proxy et continue de lire dans les coulisses lorsque vous consommez la chaîne? ( Clause de non-responsabilité: je n'ai aucune idée si NSString fait réellement cela. Il pourrait le faire. ) Le point est: commencez par suivre la manière documentée de faire les choses. Ensuite, si les benchmarks montrent que cela n'a pas les performances que vous désirez, optimisez.

Un grand nombre de ces réponses sont de longs morceaux de code ou lisent le fichier entier. J'aime utiliser les méthodes c pour cette tâche même.

FILE* file = fopen("path to my file", "r");

size_t length;
char *cLine = fgetln(file,&length);

while (length>0) {
    char str[length+1];
    strncpy(str, cLine, length);
    str[length] = '\0';

    NSString *line = [NSString stringWithFormat:@"%s",str];        
    % Do what you want here.

    cLine = fgetln(file,&length);
}

Notez que fgetln ne conservera pas votre caractère de nouvelle ligne. En outre, nous +1 la longueur de la chaîne parce que nous voulons faire de la place pour la terminaison NULL.

La lecture d'un fichier ligne par ligne (également pour les fichiers extrêmement volumineux) peut être effectuée par les fonctions suivantes:

DDFileReader * reader = [[DDFileReader alloc] initWithFilePath:pathToMyFile];
NSString * line = nil;
while ((line = [reader readLine])) {
  NSLog(@"read line: %@", line);
}
[reader release];

Ou:

DDFileReader * reader = [[DDFileReader alloc] initWithFilePath:pathToMyFile];
[reader enumerateLinesUsingBlock:^(NSString * line, BOOL * stop) {
  NSLog(@"read line: %@", line);
}];
[reader release];

La classe DDFileReader qui permet cela est la suivante:

Fichier d'interface (.h):

@interface DDFileReader : NSObject {
    NSString * filePath;

    NSFileHandle * fileHandle;
    unsigned long long currentOffset;
    unsigned long long totalFileLength;

    NSString * lineDelimiter;
    NSUInteger chunkSize;
}

@property (nonatomic, copy) NSString * lineDelimiter;
@property (nonatomic) NSUInteger chunkSize;

- (id) initWithFilePath:(NSString *)aPath;

- (NSString *) readLine;
- (NSString *) readTrimmedLine;

#if NS_BLOCKS_AVAILABLE
- (void) enumerateLinesUsingBlock:(void(^)(NSString*, BOOL *))block;
#endif

@end

Implémentation (.m)

#import "DDFileReader.h"

@interface NSData (DDAdditions)

- (NSRange) rangeOfData_dd:(NSData *)dataToFind;

@end

@implementation NSData (DDAdditions)

- (NSRange) rangeOfData_dd:(NSData *)dataToFind {

    const void * bytes = [self bytes];
    NSUInteger length = [self length];

    const void * searchBytes = [dataToFind bytes];
    NSUInteger searchLength = [dataToFind length];
    NSUInteger searchIndex = 0;

    NSRange foundRange = {NSNotFound, searchLength};
    for (NSUInteger index = 0; index < length; index++) {
        if (((char *)bytes)[index] == ((char *)searchBytes)[searchIndex]) {
            //the current character matches
            if (foundRange.location == NSNotFound) {
                foundRange.location = index;
            }
            searchIndex++;
            if (searchIndex >= searchLength) { return foundRange; }
        } else {
            searchIndex = 0;
            foundRange.location = NSNotFound;
        }
    }
    return foundRange;
}

@end

@implementation DDFileReader
@synthesize lineDelimiter, chunkSize;

- (id) initWithFilePath:(NSString *)aPath {
    if (self = [super init]) {
        fileHandle = [NSFileHandle fileHandleForReadingAtPath:aPath];
        if (fileHandle == nil) {
            [self release]; return nil;
        }

        lineDelimiter = [[NSString alloc] initWithString:@"\n"];
        [fileHandle retain];
        filePath = [aPath retain];
        currentOffset = 0ULL;
        chunkSize = 10;
        [fileHandle seekToEndOfFile];
        totalFileLength = [fileHandle offsetInFile];
        //we don't need to seek back, since readLine will do that.
    }
    return self;
}

- (void) dealloc {
    [fileHandle closeFile];
    [fileHandle release], fileHandle = nil;
    [filePath release], filePath = nil;
    [lineDelimiter release], lineDelimiter = nil;
    currentOffset = 0ULL;
    [super dealloc];
}

- (NSString *) readLine {
    if (currentOffset >= totalFileLength) { return nil; }

    NSData * newLineData = [lineDelimiter dataUsingEncoding:NSUTF8StringEncoding];
    [fileHandle seekToFileOffset:currentOffset];
    NSMutableData * currentData = [[NSMutableData alloc] init];
    BOOL shouldReadMore = YES;

    NSAutoreleasePool * readPool = [[NSAutoreleasePool alloc] init];
    while (shouldReadMore) {
        if (currentOffset >= totalFileLength) { break; }
        NSData * chunk = [fileHandle readDataOfLength:chunkSize];
        NSRange newLineRange = [chunk rangeOfData_dd:newLineData];
        if (newLineRange.location != NSNotFound) {

            //include the length so we can include the delimiter in the string
            chunk = [chunk subdataWithRange:NSMakeRange(0, newLineRange.location+[newLineData length])];
            shouldReadMore = NO;
        }
        [currentData appendData:chunk];
        currentOffset += [chunk length];
    }
    [readPool release];

    NSString * line = [[NSString alloc] initWithData:currentData encoding:NSUTF8StringEncoding];
    [currentData release];
    return [line autorelease];
}

- (NSString *) readTrimmedLine {
    return [[self readLine] stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];
}

#if NS_BLOCKS_AVAILABLE
- (void) enumerateLinesUsingBlock:(void(^)(NSString*, BOOL*))block {
  NSString * line = nil;
  BOOL stop = NO;
  while (stop == NO && (line = [self readLine])) {
    block(line, &stop);
  }
}
#endif

@end

Le cours a été fait par Dave DeLong

Tout comme @porneL l'a dit, l'API C est très pratique.

NSString* fileRoot = [[NSBundle mainBundle] pathForResource:@"record" ofType:@"txt"];
FILE *file = fopen([fileRoot UTF8String], "r");
char buffer[256];
while (fgets(buffer, 256, file) != NULL){
    NSString* result = [NSString stringWithUTF8String:buffer];
    NSLog(@"%@",result);
}

Comme d'autres l'ont répondu, NSInputStream et NSFileHandle sont de bonnes options, mais cela peut également être fait de manière assez compacte avec NSData et le mappage de la mémoire:

BRLineReader.h

#import <Foundation/Foundation.h>

@interface BRLineReader : NSObject

@property (readonly, nonatomic) NSData *data;
@property (readonly, nonatomic) NSUInteger linesRead;
@property (strong, nonatomic) NSCharacterSet *lineTrimCharacters;
@property (readonly, nonatomic) NSStringEncoding stringEncoding;

- (instancetype)initWithFile:(NSString *)filePath encoding:(NSStringEncoding)encoding;
- (instancetype)initWithData:(NSData *)data encoding:(NSStringEncoding)encoding;
- (NSString *)readLine;
- (NSString *)readTrimmedLine;
- (void)setLineSearchPosition:(NSUInteger)position;

@end

BRLineReader.m

#import "BRLineReader.h"

static unsigned char const BRLineReaderDelimiter = '\n';

@implementation BRLineReader
{
    NSRange _lastRange;
}

- (instancetype)initWithFile:(NSString *)filePath encoding:(NSStringEncoding)encoding
{
    self = [super init];
    if (self) {
        NSError *error = nil;
        _data = [NSData dataWithContentsOfFile:filePath options:NSDataReadingMappedAlways error:&error];
        if (!_data) {
            NSLog(@"%@", [error localizedDescription]);
        }
        _stringEncoding = encoding;
        _lineTrimCharacters = [NSCharacterSet whitespaceAndNewlineCharacterSet];
    }

    return self;
}

- (instancetype)initWithData:(NSData *)data encoding:(NSStringEncoding)encoding
{
    self = [super init];
    if (self) {
        _data = data;
        _stringEncoding = encoding;
        _lineTrimCharacters = [NSCharacterSet whitespaceAndNewlineCharacterSet];
    }

    return self;
}

- (NSString *)readLine
{
    NSUInteger dataLength = [_data length];
    NSUInteger beginPos = _lastRange.location + _lastRange.length;
    NSUInteger endPos = 0;
    if (beginPos == dataLength) {
        // End of file
        return nil;
    }

    unsigned char *buffer = (unsigned char *)[_data bytes];
    for (NSUInteger i = beginPos; i < dataLength; i++) {
        endPos = i;
        if (buffer[i] == BRLineReaderDelimiter) break;
    }

    // End of line found
    _lastRange = NSMakeRange(beginPos, endPos - beginPos + 1);
    NSData *lineData = [_data subdataWithRange:_lastRange];
    NSString *line = [[NSString alloc] initWithData:lineData encoding:_stringEncoding];
    _linesRead++;

    return line;
}

- (NSString *)readTrimmedLine
{
    return [[self readLine] stringByTrimmingCharactersInSet:_lineTrimCharacters];
}

- (void)setLineSearchPosition:(NSUInteger)position
{
    _lastRange = NSMakeRange(position, 0);
    _linesRead = 0;
}

@end

Cette réponse n'est PAS ObjC mais C.

Puisque ObjC est basé sur «C», pourquoi ne pas utiliser des fgets?

Et oui, je suis sûr qu'ObjC a sa propre méthode - je ne suis tout simplement pas encore assez compétent pour savoir ce que c'est :)

à partir de la réponse de @Adam Rosenfield, la chaîne de formatage de fscanfserait modifiée comme ci-dessous:

"%4095[^\r\n]%n%*[\n\r]"

il fonctionnera dans les fins de ligne osx, linux, windows.

Utiliser une catégorie ou une extension pour nous rendre la vie un peu plus facile.

extension String {

    func lines() -> [String] {
        var lines = [String]()
        self.enumerateLines { (line, stop) -> () in
            lines.append(line)
        }
        return lines
    }

}

// then
for line in string.lines() {
    // do the right thing
}

J'ai trouvé la réponse de @lukaswelte et le code de Dave DeLong très utiles. Je cherchais une solution à ce problème, mais j'avais besoin d'analyser de gros fichiers \r\nnon seulement \n.

Le code tel qu'il est écrit contient un bogue s'il est analysé par plus d'un caractère. J'ai changé le code comme ci-dessous.

fichier .h:

#import <Foundation/Foundation.h>

@interface FileChunkReader : NSObject {
    NSString * filePath;

    NSFileHandle * fileHandle;
    unsigned long long currentOffset;
    unsigned long long totalFileLength;

    NSString * lineDelimiter;
    NSUInteger chunkSize;
}

@property (nonatomic, copy) NSString * lineDelimiter;
@property (nonatomic) NSUInteger chunkSize;

- (id) initWithFilePath:(NSString *)aPath;

- (NSString *) readLine;
- (NSString *) readTrimmedLine;

#if NS_BLOCKS_AVAILABLE
- (void) enumerateLinesUsingBlock:(void(^)(NSString*, BOOL *))block;
#endif

@end

Fichier .m:

#import "FileChunkReader.h"

@interface NSData (DDAdditions)

- (NSRange) rangeOfData_dd:(NSData *)dataToFind;

@end

@implementation NSData (DDAdditions)

- (NSRange) rangeOfData_dd:(NSData *)dataToFind {

    const void * bytes = [self bytes];
    NSUInteger length = [self length];

    const void * searchBytes = [dataToFind bytes];
    NSUInteger searchLength = [dataToFind length];
    NSUInteger searchIndex = 0;

    NSRange foundRange = {NSNotFound, searchLength};
    for (NSUInteger index = 0; index < length; index++) {
        if (((char *)bytes)[index] == ((char *)searchBytes)[searchIndex]) {
            //the current character matches
            if (foundRange.location == NSNotFound) {
                foundRange.location = index;
            }
            searchIndex++;
            if (searchIndex >= searchLength)
            {
                return foundRange;
            }
        } else {
            searchIndex = 0;
            foundRange.location = NSNotFound;
        }
    }

    if (foundRange.location != NSNotFound
        && length < foundRange.location + foundRange.length )
    {
        // if the dataToFind is partially found at the end of [self bytes],
        // then the loop above would end, and indicate the dataToFind is found
        // when it only partially was.
        foundRange.location = NSNotFound;
    }

    return foundRange;
}

@end

@implementation FileChunkReader

@synthesize lineDelimiter, chunkSize;

- (id) initWithFilePath:(NSString *)aPath {
    if (self = [super init]) {
        fileHandle = [NSFileHandle fileHandleForReadingAtPath:aPath];
        if (fileHandle == nil) {
            return nil;
        }

        lineDelimiter = @"\n";
        currentOffset = 0ULL; // ???
        chunkSize = 128;
        [fileHandle seekToEndOfFile];
        totalFileLength = [fileHandle offsetInFile];
        //we don't need to seek back, since readLine will do that.
    }
    return self;
}

- (void) dealloc {
    [fileHandle closeFile];
    currentOffset = 0ULL;

}

- (NSString *) readLine {
    if (currentOffset >= totalFileLength)
    {
        return nil;
    }

    @autoreleasepool {

        NSData * newLineData = [lineDelimiter dataUsingEncoding:NSUTF8StringEncoding];
        [fileHandle seekToFileOffset:currentOffset];
        unsigned long long originalOffset = currentOffset;
        NSMutableData *currentData = [[NSMutableData alloc] init];
        NSData *currentLine = [[NSData alloc] init];
        BOOL shouldReadMore = YES;


        while (shouldReadMore) {
            if (currentOffset >= totalFileLength)
            {
                break;
            }

            NSData * chunk = [fileHandle readDataOfLength:chunkSize];
            [currentData appendData:chunk];

            NSRange newLineRange = [currentData rangeOfData_dd:newLineData];

            if (newLineRange.location != NSNotFound) {

                currentOffset = originalOffset + newLineRange.location + newLineData.length;
                currentLine = [currentData subdataWithRange:NSMakeRange(0, newLineRange.location)];

                shouldReadMore = NO;
            }else{
                currentOffset += [chunk length];
            }
        }

        if (currentLine.length == 0 && currentData.length > 0)
        {
            currentLine = currentData;
        }

        return [[NSString alloc] initWithData:currentLine encoding:NSUTF8StringEncoding];
    }
}

- (NSString *) readTrimmedLine {
    return [[self readLine] stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];
}

#if NS_BLOCKS_AVAILABLE
- (void) enumerateLinesUsingBlock:(void(^)(NSString*, BOOL*))block {
    NSString * line = nil;
    BOOL stop = NO;
    while (stop == NO && (line = [self readLine])) {
        block(line, &stop);
    }
}
#endif

@end

J'ajoute cela parce que toutes les autres réponses que j'ai essayées ont échoué d'une manière ou d'une autre. La méthode suivante peut gérer des fichiers volumineux, de longues lignes arbitraires ainsi que des lignes vides. Il a été testé avec du contenu réel et supprimera le caractère de nouvelle ligne de la sortie.

- (NSString*)readLineFromFile:(FILE *)file
{
    char buffer[4096];
    NSMutableString *result = [NSMutableString stringWithCapacity:1000];

    int charsRead;
    do {
        if(fscanf(file, "%4095[^\r\n]%n%*[\n\r]", buffer, &charsRead) == 1) {
            [result appendFormat:@"%s", buffer];
        }
        else {
            break;
        }
    } while(charsRead == 4095);

    return result.length ? result : nil;
}

Le crédit va à @Adam Rosenfield et @sooop

Je vois que beaucoup de ces réponses reposent sur la lecture du fichier texte entier en mémoire au lieu de le prendre un morceau à la fois. Voici ma solution dans Swift moderne et agréable, en utilisant FileHandle pour réduire l'impact de la mémoire:

enum MyError {
    case invalidTextFormat
}

extension FileHandle {

    func readLine(maxLength: Int) throws -> String {

        // Read in a string of up to the maximum length
        let offset = offsetInFile
        let data = readData(ofLength: maxLength)
        guard let string = String(data: data, encoding: .utf8) else {
            throw MyError.invalidTextFormat
        }

        // Check for carriage returns; if none, this is the whole string
        let substring: String
        if let subindex = string.firstIndex(of: "\n") {
            substring = String(string[string.startIndex ... subindex])
        } else {
            substring = string
        }

        // Wind back to the correct offset so that we don't miss any lines
        guard let dataCount = substring.data(using: .utf8, allowLossyConversion: false)?.count else {
            throw MyError.invalidTextFormat
        }
        try seek(toOffset: offset + UInt64(dataCount))
        return substring
    }

}

Notez que cela préserve le retour chariot à la fin de la ligne, donc en fonction de vos besoins, vous souhaiterez peut-être ajuster le code pour le supprimer.

Utilisation: ouvrez simplement un descripteur de fichier vers votre fichier texte cible et appelez readLineavec une longueur maximale appropriée - 1024 est la norme pour le texte brut, mais je l'ai laissé ouvert au cas où vous sauriez qu'il sera plus court. Notez que la commande ne débordera pas la fin du fichier, vous devrez donc peut-être vérifier manuellement que vous ne l'avez pas atteint si vous avez l'intention d'analyser le tout. Voici un exemple de code qui montre comment ouvrir un fichier à myFileURLet le lire ligne par ligne jusqu'à la fin.

do {
    let handle = try FileHandle(forReadingFrom: myFileURL)
    try handle.seekToEndOfFile()
    let eof = handle.offsetInFile
    try handle.seek(toFileOffset: 0)

    while handle.offsetInFile < eof {
        let line = try handle.readLine(maxLength: 1024)
        // Do something with the string here
    }
    try handle.close()
catch let error {
    print("Error reading file: \(error.localizedDescription)"
}

Voici une belle solution simple que j'utilise pour les petits fichiers:

NSString *path = [[NSBundle mainBundle] pathForResource:@"Terrain1" ofType:@"txt"];
NSString *contents = [NSString stringWithContentsOfFile:path encoding:NSASCIIStringEncoding error:nil];
NSArray *lines = [contents componentsSeparatedByCharactersInSet:[NSCharacterSet characterSetWithCharactersInString:@"\r\n"]];
for (NSString* line in lines) {
    if (line.length) {
        NSLog(@"line: %@", line);
    }
}

Utilisez ce script, cela fonctionne très bien:

NSString *path = @"/Users/xxx/Desktop/names.txt";
NSError *error;
NSString *stringFromFileAtPath = [NSString stringWithContentsOfFile: path
                                                           encoding: NSUTF8StringEncoding
                                                              error: &error];
if (stringFromFileAtPath == nil) {
    NSLog(@"Error reading file at %@\n%@", path, [error localizedFailureReason]);
}
NSLog(@"Contents:%@", stringFromFileAtPath);