Cel-C: Czytanie pliku wiersz po wierszu

Jaki jest właściwy sposób postępowania z dużymi plikami tekstowymi w Objective-C? Powiedzmy, że muszę przeczytać każdą linię osobno i chcę traktować każdą linię jako NSString. Jaki jest najefektywniejszy sposób zrobienia tego?

Jednym z rozwiązań jest użycie metody NSString:

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

a następnie podziel linie za pomocą separatora nowej linii, a następnie wykonaj iterację po elementach tablicy. Wydaje się to jednak dość nieefektywne. Czy nie ma łatwego sposobu na traktowanie pliku jako strumienia, wyliczanie w każdym wierszu, zamiast po prostu wczytywać go od razu? Coś jak java.io.BufferedReader w Javie.

To świetne pytanie. Myślę, że @Diederik ma dobrą odpowiedź, chociaż szkoda, że ​​Cocoa nie ma mechanizmu dokładnie tego, co chcesz zrobić.

NSInputStreampozwala czytać fragmenty N bajtów (bardzo podobne do java.io.BufferedReader), ale musisz samodzielnie przekonwertować je na a NSString, a następnie zeskanować w poszukiwaniu nowych linii (lub jakiegokolwiek innego separatora) i zapisać wszelkie pozostałe znaki do następnego odczytu lub przeczytać więcej znaków jeśli nowa linia nie została jeszcze odczytana. ( NSFileHandlepozwala przeczytać plik, NSDataktóry można następnie przekonwertować na plik NSString, ale jest to zasadniczo ten sam proces).

Firma Apple ma przewodnik programowania strumieniowego, który może pomóc wypełnić szczegóły, a to pytanie SO może również pomóc, jeśli masz do czynienia z uint8_t*buforami.

Jeśli masz zamiar często czytać napisy takie jak ten (szczególnie w różnych częściach programu), dobrym pomysłem byłoby umieszczenie tego zachowania w klasie, która może obsługiwać szczegóły za Ciebie lub nawet podklasę NSInputStream(jest zaprojektowana tak, aby była podklasy ) i dodawanie metod, które pozwalają czytać dokładnie to, co chcesz.

Dla przypomnienia, myślę, że byłoby to fajna funkcja do dodania i złożę prośbę o ulepszenie czegoś, co to umożliwia. :-)

Edycja: okazuje się, że to żądanie już istnieje. Jest do tego Radar pochodzący z 2006 roku (rdar: // 4742914 dla pracowników Apple).

To zadziała dla ogólnego czytania Stringz Text. Jeśli chcesz przeczytać dłuższy tekst (duży rozmiar tekstu) , użyj metody, o której wspomniały inne osoby, np. Buforowana (zarezerwuj rozmiar tekstu w pamięci) .

Powiedzmy, że czytasz plik tekstowy.

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

Chcesz pozbyć się nowej linii.

// 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:@";"]];

Masz to.

To powinno załatwić sprawę:

#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;
}

Użyj w następujący sposób:

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

Ten kod odczytuje z pliku znaki inne niż znaki nowej linii, do 4095 na raz. Jeśli masz linię dłuższą niż 4095 znaków, odczytuje ona dalej, aż trafi w nową linię lub koniec pliku.

Uwaga : nie testowałem tego kodu. Przetestuj go przed użyciem.

Mac OS X to Unix, Objective-C to superset w C, więc możesz po prostu używać old-school fopeni fgetsfrom <stdio.h>. Gwarantujemy, że zadziała.

[NSString stringWithUTF8String:buf]przekonwertuje ciąg C na NSString. Istnieją również metody tworzenia łańcuchów w innych kodowaniach i tworzenia bez kopiowania.

Możesz użyć, NSInputStreamktóry ma podstawową implementację dla strumieni plików. Możesz wczytać bajty do bufora ( read:maxLength:metoda). Musisz samodzielnie przeskanować bufor w poszukiwaniu nowych linii.

Odpowiedni sposób czytania plików tekstowych w Cocoa / Objective-C jest udokumentowany w przewodniku programowania ciągów znaków firmy Apple. Sekcja dotycząca czytania i pisania plików powinna być właśnie tym, czego szukasz. PS: Co to jest „linia”? Dwie sekcje ciągu oddzielone znakiem „\ n”? Lub „\ r”? Lub „\ r \ n”? A może faktycznie po akapitach? Wspomniany przewodnik zawiera również sekcję dotyczącą dzielenia ciągu znaków na wiersze lub akapity. (Ta sekcja nazywa się „Akapity i podziały wierszy” i jest połączona linkiem w menu po lewej stronie wskazanej powyżej strony. Niestety ta witryna nie pozwala mi na umieszczenie więcej niż jednego adresu URL, ponieważ nie jest jeszcze godnym zaufania użytkownikiem).

Parafrazując Knutha: przedwczesna optymalizacja jest źródłem wszelkiego zła. Nie zakładaj po prostu, że „wczytywanie całego pliku do pamięci” jest powolne. Czy sprawdziłeś to? Czy wiesz, że faktycznie czyta cały plik do pamięci? Może po prostu zwraca obiekt proxy i czyta za kulisami, gdy konsumujesz ciąg? ( Zastrzeżenie: nie mam pojęcia, czy NSString faktycznie to robi. Możliwe, że mógłby. ) Chodzi o to: najpierw idź z udokumentowanym sposobem robienia rzeczy. Następnie, jeśli testy porównawcze pokazują, że nie zapewnia to oczekiwanej wydajności, zoptymalizuj.

Wiele z tych odpowiedzi to długie fragmenty kodu lub czytane są w całym pliku. Lubię używać metod c do tego właśnie zadania.

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);
}

Zauważ, że fgetln nie zachowa twojego znaku nowej linii. Ponadto dajemy +1 długości str, ponieważ chcemy zrobić miejsce na zakończenie NULL.

Aby odczytać plik wiersz po wierszu (również w przypadku bardzo dużych plików), można skorzystać z następujących funkcji:

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

Lub:

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

Klasa DDFileReader, która to umożliwia, jest następująca:

Plik interfejsu (.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

Wdrożenie (.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

Klasa została wykonana przez Dave DeLong

Tak jak powiedział @porneL, interfejs API C jest bardzo przydatny.

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);
}

Jak inni odpowiedzieli, zarówno NSInputStream, jak i NSFileHandle są dobrymi opcjami, ale można to również zrobić w dość zwarty sposób za pomocą NSData i mapowania pamięci:

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

Ta odpowiedź NIE JEST ObjC, ale C.

Skoro ObjC jest oparty na „C”, dlaczego nie użyć fgets?

I tak, jestem pewien, że ObjC ma swoją własną metodę - po prostu nie jestem jeszcze wystarczająco biegły, aby wiedzieć, co to jest :)

z odpowiedzi @Adama Rosenfielda, ciąg formatujący fscanfzostałby zmieniony jak poniżej:

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

będzie działać na końcówkach linii OSX, Linux, Windows.

Korzystanie z kategorii lub rozszerzenia, aby ułatwić sobie życie.

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
}

Odpowiedź od @lukaswelte i kod od Dave'a DeLonga okazały się bardzo pomocne. Szukałem rozwiązania tego problemu, ale musiałem analizować duże pliki \r\nnie tylko \n.

Napisany kod zawiera błąd w przypadku analizowania przez więcej niż jeden znak. Zmieniłem kod jak poniżej.

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

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

Dodam to, ponieważ wszystkie inne odpowiedzi, których próbowałem, były w ten czy inny sposób krótkie. Poniższa metoda może obsługiwać duże pliki, dowolne długie wiersze, a także puste wiersze. Został przetestowany z rzeczywistą zawartością i usunie znak nowej linii z wyniku.

- (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;
}

Podziękowania dla @Adam Rosenfield i @sooop

Widzę, że wiele z tych odpowiedzi polega na wczytywaniu całego pliku tekstowego do pamięci, zamiast brać go po jednym kawałku na raz. Oto moje rozwiązanie w ładnym, nowoczesnym języku Swift, przy użyciu FileHandle, aby utrzymać niski wpływ pamięci:

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
    }

}

Zauważ, że zachowuje to powrót karetki na końcu wiersza, więc w zależności od potrzeb możesz dostosować kod, aby go usunąć.

Sposób użycia: po prostu otwórz uchwyt pliku do docelowego pliku tekstowego i wywołaj readLinez odpowiednią maksymalną długością - 1024 jest standardem dla zwykłego tekstu, ale zostawiłem go otwartego na wypadek, gdybyś wiedział, że będzie krótszy. Zwróć uwagę, że polecenie nie spowoduje przepełnienia końca pliku, więc jeśli zamierzasz przeanalizować całość, może być konieczne ręczne sprawdzenie, czy go nie osiągnąłeś. Oto przykładowy kod, który pokazuje, jak otworzyć plik pod adresem myFileURLi czytać go wiersz po wierszu aż do końca.

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

Oto ładne, proste rozwiązanie, którego używam do mniejszych plików:

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);
    }
}

Użyj tego skryptu, działa świetnie:

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