blocks|key|152026|text|(代码现在适用于Swift+2.2/Xcode+7.3。如果有人需要，可以在编辑历史记录中找到旧版本。最后提供了Swift+3的更新版本。)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|152027|下面的Swift代码很大程度上受到How+to+read+data+from+NSFileHandle+line+by+line?的各种答案的启发。它以块的形式从文件中读取，并将完整的行转换为字符串。|offset|length|152028|默认的行分隔符(\n)、字符串编码(UTF-8)和分块大小(4096)可以通过可选参数设置。|style|CODE|152029|class+StreamReader++{

++++let+encoding+:+UInt
++++let+chunkSize+:+Int

++++var+fileHandle+:+NSFileHandle!
++++let+buffer+:+NSMutableData!
++++let+delimData+:+NSData!
++++var+atEof+:+Bool+=+false

++++init?(path:+String,+delimiter:+String+=+"\n",+encoding+:+UInt+=+NSUTF8StringEncoding,+chunkSize+:+Int+=+4096)+{
++++++++self.chunkSize+=+chunkSize
++++++++self.encoding+=+encoding

++++++++if+let+fileHandle+=+NSFileHandle(forReadingAtPath:+path),
++++++++++++delimData+=+delimiter.dataUsingEncoding(encoding),
++++++++++++buffer+=+NSMutableData(capacity:+chunkSize)
++++++++{
++++++++++++self.fileHandle+=+fileHandle
++++++++++++self.delimData+=+delimData
++++++++++++self.buffer+=+buffer
++++++++}+else+{
++++++++++++self.fileHandle+=+nil
++++++++++++self.delimData+=+nil
++++++++++++self.buffer+=+nil
++++++++++++return+nil
++++++++}
++++}

++++deinit+{
++++++++self.close()
++++}

++++///+Return+next+line,+or+nil+on+EOF.
++++func+nextLine()+->+String?+{
++++++++precondition(fileHandle+!=+nil,+"Attempt+to+read+from+closed+file")

++++++++if+atEof+{
++++++++++++return+nil
++++++++}

++++++++//+Read+data+chunks+from+file+until+a+line+delimiter+is+found:
++++++++var+range+=+buffer.rangeOfData(delimData,+options:+[],+range:+NSMakeRange(0,+buffer.length))
++++++++while+range.location+==+NSNotFound+{
++++++++++++let+tmpData+=+fileHandle.readDataOfLength(chunkSize)
++++++++++++if+tmpData.length+==+0+{
++++++++++++++++//+EOF+or+read+error.
++++++++++++++++atEof+=+true
++++++++++++++++if+buffer.length+>+0+{
++++++++++++++++++++//+Buffer+contains+last+line+in+file+(not+terminated+by+delimiter).
++++++++++++++++++++let+line+=+NSString(data:+buffer,+encoding:+encoding)

++++++++++++++++++++buffer.length+=+0
++++++++++++++++++++return+line+as+String?
++++++++++++++++}
++++++++++++++++//+No+more+lines.
++++++++++++++++return+nil
++++++++++++}
++++++++++++buffer.appendData(tmpData)
++++++++++++range+=+buffer.rangeOfData(delimData,+options:+[],+range:+NSMakeRange(0,+buffer.length))
++++++++}

++++++++//+Convert+complete+line+(excluding+the+delimiter)+to+a+string:
++++++++let+line+=+NSString(data:+buffer.subdataWithRange(NSMakeRange(0,+range.location)),
++++++++++++encoding:+encoding)
++++++++//+Remove+line+(and+the+delimiter)+from+the+buffer:
++++++++buffer.replaceBytesInRange(NSMakeRange(0,+range.location+%2B+range.length),+withBytes:+nil,+length:+0)

++++++++return+line+as+String?
++++}

++++///+Start+reading+from+the+beginning+of+file.
++++func+rewind()+->+Void+{
++++++++fileHandle.seekToFileOffset(0)
++++++++buffer.length+=+0
++++++++atEof+=+false
++++}

++++///+Close+the+underlying+file.+No+reading+must+be+done+after+calling+this+method.
++++func+close()+->+Void+{
++++++++fileHandle?.closeFile()
++++++++fileHandle+=+nil
++++}
}|code-block|syntax|javascript|152030|用法：|152031|if+let+aStreamReader+=+StreamReader(path:+"/path/to/file")+{
++++defer+{
++++++++aStreamReader.close()
++++}
++++while+let+line+=+aStreamReader.nextLine()+{
++++++++print(line)
++++}
}|152032|您甚至可以使用带有for-in循环的阅读器|152033|for+line+in+aStreamReader+{
++++print(line)
}|152034|通过实现SequenceType协议(请比较http://robots.thoughtbot.com/swift-sequences)：|152035|extension+StreamReader+:+SequenceType+{
++++func+generate()+->+AnyGenerator<String>+{
++++++++return+AnyGenerator+{
++++++++++++return+self.nextLine()
++++++++}
++++}
}|152036|152037|Swift+3/Xcode8Beta+6的更新：还“现代化”了使用guard和新的Data值类型：|BOLD|152038|class+StreamReader++{

++++let+encoding+:+String.Encoding
++++let+chunkSize+:+Int
++++var+fileHandle+:+FileHandle!
++++let+delimData+:+Data
++++var+buffer+:+Data
++++var+atEof+:+Bool

++++init?(path:+String,+delimiter:+String+=+"\n",+encoding:+String.Encoding+=+.utf8,
++++++++++chunkSize:+Int+=+4096)+{

++++++++guard+let+fileHandle+=+FileHandle(forReadingAtPath:+path),
++++++++++++let+delimData+=+delimiter.data(using:+encoding)+else+{
++++++++++++++++return+nil
++++++++}
++++++++self.encoding+=+encoding
++++++++self.chunkSize+=+chunkSize
++++++++self.fileHandle+=+fileHandle
++++++++self.delimData+=+delimData
++++++++self.buffer+=+Data(capacity:+chunkSize)
++++++++self.atEof+=+false
++++}

++++deinit+{
++++++++self.close()
++++}

++++///+Return+next+line,+or+nil+on+EOF.
++++func+nextLine()+->+String?+{
++++++++precondition(fileHandle+!=+nil,+"Attempt+to+read+from+closed+file")

++++++++//+Read+data+chunks+from+file+until+a+line+delimiter+is+found:
++++++++while+!atEof+{
++++++++++++if+let+range+=+buffer.range(of:+delimData)+{
++++++++++++++++//+Convert+complete+line+(excluding+the+delimiter)+to+a+string:
++++++++++++++++let+line+=+String(data:+buffer.subdata(in:+0..<range.lowerBound),+encoding:+encoding)
++++++++++++++++//+Remove+line+(and+the+delimiter)+from+the+buffer:
++++++++++++++++buffer.removeSubrange(0..<range.upperBound)
++++++++++++++++return+line
++++++++++++}
++++++++++++let+tmpData+=+fileHandle.readData(ofLength:+chunkSize)
++++++++++++if+tmpData.count+>+0+{
++++++++++++++++buffer.append(tmpData)
++++++++++++}+else+{
++++++++++++++++//+EOF+or+read+error.
++++++++++++++++atEof+=+true
++++++++++++++++if+buffer.count+>+0+{
++++++++++++++++++++//+Buffer+contains+last+line+in+file+(not+terminated+by+delimiter).
++++++++++++++++++++let+line+=+String(data:+buffer+as+Data,+encoding:+encoding)
++++++++++++++++++++buffer.count+=+0
++++++++++++++++++++return+line
++++++++++++++++}
++++++++++++}
++++++++}
++++++++return+nil
++++}

++++///+Start+reading+from+the+beginning+of+file.
++++func+rewind()+->+Void+{
++++++++fileHandle.seek(toFileOffset:+0)
++++++++buffer.count+=+0
++++++++atEof+=+false
++++}

++++///+Close+the+underlying+file.+No+reading+must+be+done+after+calling+this+method.
++++func+close()+->+Void+{
++++++++fileHandle?.closeFile()
++++++++fileHandle+=+nil
++++}
}

extension+StreamReader+:+Sequence+{
++++func+makeIterator()+->+AnyIterator<String>+{
++++++++return+AnyIterator+{
++++++++++++return+self.nextLine()
++++++++}
++++}
}|152039|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/3707427/how-to-read-data-from-nsfilehandle-line-by-line|1|http://robots.thoughtbot.com/swift-sequences^0|0|H|1C|0|0|8|2|0|0|0|0|0|0|4|C|M|18|1|0|0|0|L|3|X|5|15|4|0|0^^$0|@$1|2|3|4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1H|8|@]|9|@$D|1I|E|1J|1|1K]]|A|$]]|$1|F|3|G|5|6|7|1L|8|@$D|1M|E|1N|H|I]]|9|@]|A|$]]|$1|J|3|K|5|L|7|1O|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1P|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1Q|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|1R|8|@]|9|@]|A|$]]|$1|U|3|V|5|L|7|1S|8|@]|9|@]|A|$M|N]]|$1|W|3|X|5|6|7|1T|8|@$D|1U|E|1V|H|I]]|9|@$D|1W|E|1X|1|1Y]]|A|$]]|$1|Y|3|Z|5|L|7|1Z|8|@]|9|@]|A|$M|N]]|$1|10|3|-4|5|6|7|20|8|@]|9|@]|A|$]]|$1|11|3|12|5|6|7|21|8|@$D|22|E|23|H|13]|$D|24|E|25|H|I]|$D|26|E|27|H|I]]|9|@]|A|$]]|$1|14|3|15|5|L|7|28|8|@]|9|@]|A|$M|N]]|$1|16|3|-4|5|6|7|29|8|@]|9|@]|A|$]]]|17|$18|$5|19|1A|1B|A|$1C|1D]]|1E|$5|19|1A|1B|A|$1C|1F]]]]

(The code is for Swift 2.2/Xcode 7.3 now. Older versions can be found in the edit history if somebody needs it. An updated version for Swift 3 is provided at the end.)

The following Swift code is heavily inspired by the various answers to 
<a href="https://stackoverflow.com/questions/3707427/how-to-read-data-from-nsfilehandle-line-by-line">How to read data from NSFileHandle line by line?</a>. It reads from the file in chunks, and converts complete lines to strings.

The default line delimiter (<code>\n</code>), string encoding (UTF-8) and chunk size (4096)
can be set with optional parameters. 

<pre><code>class StreamReader {

 let encoding : UInt
 let chunkSize : Int

 var fileHandle : NSFileHandle!
 let buffer : NSMutableData!
 let delimData : NSData!
 var atEof : Bool = false

 init?(path: String, delimiter: String = "\n", encoding : UInt = NSUTF8StringEncoding, chunkSize : Int = 4096) {
 self.chunkSize = chunkSize
 self.encoding = encoding

 if let fileHandle = NSFileHandle(forReadingAtPath: path),
 delimData = delimiter.dataUsingEncoding(encoding),
 buffer = NSMutableData(capacity: chunkSize)
 {
 self.fileHandle = fileHandle
 self.delimData = delimData
 self.buffer = buffer
 } else {
 self.fileHandle = nil
 self.delimData = nil
 self.buffer = nil
 return nil
 }
 }

 deinit {
 self.close()
 }

 /// Return next line, or nil on EOF.
 func nextLine() -&gt; String? {
 precondition(fileHandle != nil, "Attempt to read from closed file")

 if atEof {
 return nil
 }

 // Read data chunks from file until a line delimiter is found:
 var range = buffer.rangeOfData(delimData, options: [], range: NSMakeRange(0, buffer.length))
 while range.location == NSNotFound {
 let tmpData = fileHandle.readDataOfLength(chunkSize)
 if tmpData.length == 0 {
 // EOF or read error.
 atEof = true
 if buffer.length &gt; 0 {
 // Buffer contains last line in file (not terminated by delimiter).
 let line = NSString(data: buffer, encoding: encoding)

 buffer.length = 0
 return line as String?
 }
 // No more lines.
 return nil
 }
 buffer.appendData(tmpData)
 range = buffer.rangeOfData(delimData, options: [], range: NSMakeRange(0, buffer.length))
 }

 // Convert complete line (excluding the delimiter) to a string:
 let line = NSString(data: buffer.subdataWithRange(NSMakeRange(0, range.location)),
 encoding: encoding)
 // Remove line (and the delimiter) from the buffer:
 buffer.replaceBytesInRange(NSMakeRange(0, range.location + range.length), withBytes: nil, length: 0)

 return line as String?
 }

 /// Start reading from the beginning of file.
 func rewind() -&gt; Void {
 fileHandle.seekToFileOffset(0)
 buffer.length = 0
 atEof = false
 }

 /// Close the underlying file. No reading must be done after calling this method.
 func close() -&gt; Void {
 fileHandle?.closeFile()
 fileHandle = nil
 }
}
</code></pre>

Usage:

<pre><code>if let aStreamReader = StreamReader(path: "/path/to/file") {
 defer {
 aStreamReader.close()
 }
 while let line = aStreamReader.nextLine() {
 print(line)
 }
}
</code></pre>

You can even use the reader with a for-in loop

<pre><code>for line in aStreamReader {
 print(line)
}
</code></pre>

by implementing the <code>SequenceType</code> protocol (compare <a href="http://robots.thoughtbot.com/swift-sequences" rel="noreferrer">http://robots.thoughtbot.com/swift-sequences</a>):

<pre><code>extension StreamReader : SequenceType {
 func generate() -&gt; AnyGenerator&lt;String&gt; {
 return AnyGenerator {
 return self.nextLine()
 }
 }
}
</code></pre>

<hr>

Update for Swift 3/Xcode 8 beta 6: Also "modernized" to 
use <code>guard</code> and the new <code>Data</code> value type:

<pre><code>class StreamReader {

 let encoding : String.Encoding
 let chunkSize : Int
 var fileHandle : FileHandle!
 let delimData : Data
 var buffer : Data
 var atEof : Bool

 init?(path: String, delimiter: String = "\n", encoding: String.Encoding = .utf8,
 chunkSize: Int = 4096) {

 guard let fileHandle = FileHandle(forReadingAtPath: path),
 let delimData = delimiter.data(using: encoding) else {
 return nil
 }
 self.encoding = encoding
 self.chunkSize = chunkSize
 self.fileHandle = fileHandle
 self.delimData = delimData
 self.buffer = Data(capacity: chunkSize)
 self.atEof = false
 }

 deinit {
 self.close()
 }

 /// Return next line, or nil on EOF.
 func nextLine() -&gt; String? {
 precondition(fileHandle != nil, "Attempt to read from closed file")

 // Read data chunks from file until a line delimiter is found:
 while !atEof {
 if let range = buffer.range(of: delimData) {
 // Convert complete line (excluding the delimiter) to a string:
 let line = String(data: buffer.subdata(in: 0..&lt;range.lowerBound), encoding: encoding)
 // Remove line (and the delimiter) from the buffer:
 buffer.removeSubrange(0..&lt;range.upperBound)
 return line
 }
 let tmpData = fileHandle.readData(ofLength: chunkSize)
 if tmpData.count &gt; 0 {
 buffer.append(tmpData)
 } else {
 // EOF or read error.
 atEof = true
 if buffer.count &gt; 0 {
 // Buffer contains last line in file (not terminated by delimiter).
 let line = String(data: buffer as Data, encoding: encoding)
 buffer.count = 0
 return line
 }
 }
 }
 return nil
 }

 /// Start reading from the beginning of file.
 func rewind() -&gt; Void {
 fileHandle.seek(toFileOffset: 0)
 buffer.count = 0
 atEof = false
 }

 /// Close the underlying file. No reading must be done after calling this method.
 func close() -&gt; Void {
 fileHandle?.closeFile()
 fileHandle = nil
 }
}

extension StreamReader : Sequence {
 func makeIterator() -&gt; AnyIterator&lt;String&gt; {
 return AnyIterator {
 return self.nextLine()
 }
 }
}
</code></pre>

blocks|key|2949207|text|一旦你摸索过UnsafePointer，你就会发现在Swift中，优秀的、老式的C是相当舒服的。下面是一个简单的cat，它逐行读取stdin并打印到stdout。你甚至不需要粉底液。达尔文就足够了：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2949208|import+Darwin
let+bufsize+=+4096
//+let+stdin+=+fdopen(STDIN_FILENO,+"r")+it+is+now+predefined+in+Darwin
var+buf+=+UnsafePointer<Int8>.alloc(bufsize)
while+fgets(buf,+Int32(bufsize-1),+stdin)+{
++++print(String.fromCString(CString(buf)))
}
buf.destroy()|code-block|syntax|javascript|2949209|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

It turns out good old-fasioned C API is pretty comfortable in Swift once you grok UnsafePointer. Here is a simple cat that reads from stdin and prints to stdout line-by-line. You don't even need Foundation. Darwin suffices:

<pre><code>import Darwin
let bufsize = 4096
// let stdin = fdopen(STDIN_FILENO, "r") it is now predefined in Darwin
var buf = UnsafePointer&lt;Int8&gt;.alloc(bufsize)
while fgets(buf, Int32(bufsize-1), stdin) {
 print(String.fromCString(CString(buf)))
}
buf.destroy()
</code></pre>

blocks|key|2736531|text|或者，您可以简单地使用Generator|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2736532|let+stdinByLine+=+GeneratorOf({+()+->+String?+in
++++var+input+=+UnsafeMutablePointer<Int8>(),+lim+=+0
++++return+getline(&input,+&lim,+stdin)+>+0+?+String.fromCString(input)+:+nil
})|code-block|syntax|javascript|2736533|让我们试试看|2736534|for+line+in+stdinByLine+{
++++println(">>>+\(line)")
}|2736535|它简单、懒惰，并且很容易与其他快捷的东西链接，比如枚举器和函数器，如映射、缩减、过滤器；使用lazy()包装器。|2736536|2736537|它将所有FILE概括为：|2736538|let+byLine+=+{+(file:UnsafeMutablePointer<FILE>)+in
++++GeneratorOf({+()+->+String?+in
++++++++var+input+=+UnsafeMutablePointer<Int8>(),+lim+=+0
++++++++return+getline(&input,+&lim,+file)+>+0+?+String.fromCString(input)+:+nil
++++})
}|2736539|叫like|2736540|for+line+in+byLine(stdin)+{+...+}|2736541|entityMap^0|B|9|0|0|0|0|1A|6|0|0|4|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|15|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|17|8|@$9|18|A|19|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|T|3|U|5|H|7|1E|8|@]|D|@]|E|$I|J]]|$1|V|3|W|5|6|7|1F|8|@]|D|@]|E|$]]|$1|X|3|Y|5|H|7|1G|8|@]|D|@]|E|$I|J]]|$1|Z|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]]|10|$]]

Or you could simply use a <code>Generator</code>:

<pre><code>let stdinByLine = GeneratorOf({ () -&gt; String? in
 var input = UnsafeMutablePointer&lt;Int8&gt;(), lim = 0
 return getline(&amp;input, &amp;lim, stdin) &gt; 0 ? String.fromCString(input) : nil
})
</code></pre>

Let's try it out

<pre><code>for line in stdinByLine {
 println("&gt;&gt;&gt; \(line)")
}
</code></pre>

It's simple, lazy, and easy to chain with other swift things like enumerators and functors such as map, reduce, filter; using the <code>lazy()</code> wrapper.

<hr>

It generalises to all <code>FILE</code> as:

<pre><code>let byLine = { (file:UnsafeMutablePointer&lt;FILE&gt;) in
 GeneratorOf({ () -&gt; String? in
 var input = UnsafeMutablePointer&lt;Int8&gt;(), lim = 0
 return getline(&amp;input, &amp;lim, file) &gt; 0 ? String.fromCString(input) : nil
 })
}
</code></pre>

called like

<pre><code>for line in byLine(stdin) { ... }
</code></pre>

blocks|key|2949262|text|我来晚了，但这是我为此编写的一个小类。经过几次不同的尝试(尝试将NSInputStream子类化)，我发现这是一种合理而简单的方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2949263|记住在桥接头中使用#import+<stdio.h>。|2949264|//+Use+is+like+this:
let+readLine+=+ReadLine(somePath)
while+let+line+=+readLine.readLine()+{
++++//+do+something...
}

class+ReadLine+{

++++private+var+buf+=+UnsafeMutablePointer<Int8>.alloc(1024)
++++private+var+n:+Int+=+1024

++++let+path:+String
++++let+mode:+String+=+"r"

++++private+lazy+var+filepointer:+UnsafeMutablePointer<FILE>+=+{
++++++++let+csmode+=+self.mode.withCString+{+cs+in+return+cs+}
++++++++let+cspath+=+self.path.withCString+{+cs+in+return+cs+}

++++++++return+fopen(cspath,+csmode)
++++}()

++++init(path:+String)+{
++++++++self.path+=+path
++++}

++++func+readline()+->+String?+{
++++++++//+unsafe+for+unknown+input
++++++++if+getline(&buf,+&n,+filepointer)+>+0+{
++++++++++++return+String.fromCString(UnsafePointer<CChar>(buf))
++++++++}

++++++++return+nil
++++}

++++deinit+{
++++++++buf.dealloc(n)
++++++++fclose(filepointer)
++++}
}|code-block|syntax|javascript|2949265|entityMap^0|W|D|0|9|H|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|U|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

I'm late to the game, but here's small class I wrote for that purpose. After some different attempts (try to subclass <code>NSInputStream</code>) I found this to be a reasonable and simple approach.

Remember to <code>#import &lt;stdio.h&gt;</code> in your bridging header.

<pre><code>// Use is like this:
let readLine = ReadLine(somePath)
while let line = readLine.readLine() {
 // do something...
}

class ReadLine {

 private var buf = UnsafeMutablePointer&lt;Int8&gt;.alloc(1024)
 private var n: Int = 1024

 let path: String
 let mode: String = "r"

 private lazy var filepointer: UnsafeMutablePointer&lt;FILE&gt; = {
 let csmode = self.mode.withCString { cs in return cs }
 let cspath = self.path.withCString { cs in return cs }

 return fopen(cspath, csmode)
 }()

 init(path: String) {
 self.path = path
 }

 func readline() -&gt; String? {
 // unsafe for unknown input
 if getline(&amp;buf, &amp;n, filepointer) &gt; 0 {
 return String.fromCString(UnsafePointer&lt;CChar&gt;(buf))
 }

 return nil
 }

 deinit {
 buf.dealloc(n)
 fclose(filepointer)
 }
}
</code></pre>

blocks|key|154942|text|此函数接受一个文件URL，并返回一个序列，该序列将返回文件的每一行，并懒惰地读取它们。它适用于Swift+5，它依赖于底层的getline|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|154943|typealias+LineState+=+(
++//+pointer+to+a+C+string+representing+a+line
++linePtr:UnsafeMutablePointer<CChar>?,
++linecap:Int,
++filePtr:UnsafeMutablePointer<FILE>?
)

///+Returns+a+sequence+which+iterates+through+all+lines+of+the+the+file+at+the+URL.
///
///+-+Parameter+url:+file+URL+of+a+file+to+read
///+-+Returns:+a+Sequence+which+lazily+iterates+through+lines+of+the+file
///
///+-+warning:+the+caller+of+this+function+**must**+iterate+through+all+lines+of+the+file,+since+aborting+iteration+midway+will+leak+memory+and+a+file+pointer
///+-+precondition:+the+file+must+be+UTF8-encoded+(which+includes,+ASCII-encoded)
func+lines(ofFile+url:URL)+->+UnfoldSequence<String,LineState>
{
++let+initialState:LineState+=+(linePtr:nil,+linecap:0,+filePtr:fopen(url.path,"r"))
++return+sequence(state:+initialState,+next:+{+(state)+->+String?+in
++++if+getline(&state.linePtr,+&state.linecap,+state.filePtr)+>+0,
++++++let+theLine+=+state.linePtr++{
++++++return+String.init(cString:theLine)
++++}
++++else+{
++++++if+let+actualLine+=+state.linePtr++{+free(actualLine)+}
++++++fclose(state.filePtr)
++++++return+nil
++++}
++})
}|code-block|syntax|javascript|154944|例如，下面是如何使用它打印应用程序包中名为"foo“的文件的每一行：|154945|let+url+=+NSBundle.mainBundle().urlForResource("foo",+ofType:+nil)!
for+line+in+lines(ofFile:url)+{
++//+suppress+print's+automatically+inserted+line+ending,+since
++//+lineGenerator+captures+each+line's+own+new+line+character.
++print(line,+separator:+"",+terminator:+"")
}|154946|我通过修改Alex+Brown的答案来删除Martin+R的评论中提到的内存泄漏，并将其更新为Swift+5，从而开发了这个答案。|154947|entityMap^0|1Q|7|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|Y|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|R|$]]

This function takes a file URL and returns a sequence which will return every line of the file, reading them lazily. It works with Swift 5. It relies on the underlying <code>getline</code>:

<pre><code>typealias LineState = (
 // pointer to a C string representing a line
 linePtr:UnsafeMutablePointer&lt;CChar&gt;?,
 linecap:Int,
 filePtr:UnsafeMutablePointer&lt;FILE&gt;?
)

/// Returns a sequence which iterates through all lines of the the file at the URL.
///
/// - Parameter url: file URL of a file to read
/// - Returns: a Sequence which lazily iterates through lines of the file
///
/// - warning: the caller of this function **must** iterate through all lines of the file, since aborting iteration midway will leak memory and a file pointer
/// - precondition: the file must be UTF8-encoded (which includes, ASCII-encoded)
func lines(ofFile url:URL) -&gt; UnfoldSequence&lt;String,LineState&gt;
{
 let initialState:LineState = (linePtr:nil, linecap:0, filePtr:fopen(url.path,"r"))
 return sequence(state: initialState, next: { (state) -&gt; String? in
 if getline(&amp;state.linePtr, &amp;state.linecap, state.filePtr) &gt; 0,
 let theLine = state.linePtr {
 return String.init(cString:theLine)
 }
 else {
 if let actualLine = state.linePtr { free(actualLine) }
 fclose(state.filePtr)
 return nil
 }
 })
}
</code></pre>

So for instance, here's how you would use it to print every line of a file named "foo" in your app bundle:

<pre><code>let url = NSBundle.mainBundle().urlForResource("foo", ofType: nil)!
for line in lines(ofFile:url) {
 // suppress print's automatically inserted line ending, since
 // lineGenerator captures each line's own new line character.
 print(line, separator: "", terminator: "")
}
</code></pre>

I developed this answer by modifying Alex Brown's answer to remove a memory leak mentioned by Martin R's comment, and by updating it to for Swift 5.

blocks|key|2736620|text|我想要一个不连续修改缓冲区或重复代码的版本，因为这两个都是低效的，并且允许任何大小的缓冲区(包括1个字节)和任何分隔符。它有一个公共方法：readline()。调用此方法将返回下一行的字符串值或EOF处的nil。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2736621|import+Foundation

//+LineStream():+path:+String,+[buffSize:+Int],+[delim:+String]+->+nil+%7C+String
//+=============+--------------------------------------------------------------
//+path:+++++the+path+to+a+text+file+to+be+parsed
//+buffSize:+an+optional+buffer+size,+(1...);+default+is+4096
//+delim:++++an+optional+delimiter+String;+default+is+"\n"
//+***************************************************************************
class+LineStream+{
++++let+path:+String
++++let+handle:+NSFileHandle!

++++let+delim:+NSData!
++++let+encoding:+NSStringEncoding

++++var+buffer+=+NSData()
++++var+buffSize:+Int

++++var+buffIndex+=+0
++++var+buffEndIndex+=+0

++++init?(path:+String,
++++++buffSize:+Int+=+4096,
++++++delim:+String+=+"\n",
++++++encoding:+NSStringEncoding+=+NSUTF8StringEncoding)
++++{
++++++self.handle+=+NSFileHandle(forReadingAtPath:+path)
++++++self.path+=+path
++++++self.buffSize+=+buffSize+<+1+?+1+:+buffSize
++++++self.encoding+=+encoding
++++++self.delim+=+delim.dataUsingEncoding(encoding)
++++++if+handle+==+nil+%7C%7C+self.delim+==+nil+{
++++++++print("ERROR+initializing+LineStream")+/*+TODO+use+STDERR+*/
++++++++return+nil
++++++}
++++}

++//+PRIVATE
++//+fillBuffer():+_+->+Int+[0...buffSize]
++//+=============+--------+..............
++//+Fill+the+buffer+with+new+data;+return+with+the+buffer+size,+or+zero
++//+upon+reaching+end-of-file
++//+*********************************************************************
++private+func+fillBuffer()+->+Int+{
++++buffer+=+handle.readDataOfLength(buffSize)
++++buffIndex+=+0
++++buffEndIndex+=+buffer.length

++++return+buffEndIndex
++}

++//+PRIVATE
++//+delimLocation():+_+->+Int?+nil+%7C+[1...buffSize]
++//+================+---------+....................
++//+Search+the+remaining+buffer+for+a+delimiter;+return+with+the+location
++//+of+a+delimiter+in+the+buffer,+or+nil+if+one+is+not+found.
++//+***********************************************************************
++private+func+delimLocation()+->+Int?+{
++++let+searchRange+=+NSMakeRange(buffIndex,+buffEndIndex+-+buffIndex)
++++let+rangeToDelim+=+buffer.rangeOfData(delim,
++++++++++++++++++++++++++++++++++++++++++options:+[],+range:+searchRange)
++++return+rangeToDelim.location+==+NSNotFound
++++++++?+nil
++++++++:+rangeToDelim.location
++}

++//+PRIVATE
++//+dataStrValue():+NSData+->+String+(""+%7C+String)
++//+===============+----------------+.............
++//+Attempt+to+convert+data+into+a+String+value+using+the+supplied+encoding;+
++//+return+the+String+value+or+empty+string+if+the+conversion+fails.
++//+***********************************************************************
++++private+func+dataStrValue(data:+NSData)+->+String?+{
++++++if+let+strVal+=+NSString(data:+data,+encoding:+encoding)+as?+String+{
++++++++++return+strVal
++++++}+else+{+return+""+}
}

++//+PUBLIC
++//+readLine():+_+->+String?+nil+%7C+String
++//+===========+____________+............
++//+Read+the+next+line+of+the+file,+i.e.,+up+to+the+next+delimiter+or+end-of-
++//+file,+whichever+occurs+first;+return+the+String+value+of+the+data+found,+
++//+or+nil+upon+reaching+end-of-file.
++//+*************************************************************************
++func+readLine()+->+String?+{
++++guard+let+line+=+NSMutableData(capacity:+buffSize)+else+{
++++++++print("ERROR+setting+line")
++++++++exit(EXIT_FAILURE)
++++}

++++//+Loop+until+a+delimiter+is+found,+or+end-of-file+is+reached
++++var+delimFound+=+false
++++while+!delimFound+{
++++++++//+buffIndex+will+equal+buffEndIndex+in+three+situations,+resulting
++++++++//+in+a+(re)filling+of+the+buffer:
++++++++//+++1.+Upon+the+initial+call;
++++++++//+++2.+If+a+search+for+a+delimiter+has+failed
++++++++//+++3.+If+a+delimiter+is+found+at+the+end+of+the+buffer
++++++++if+buffIndex+==+buffEndIndex+{
++++++++++++if+fillBuffer()+==+0+{
++++++++++++++++return+nil
++++++++++++}
++++++++}

++++++++var+lengthToDelim:+Int
++++++++let+startIndex+=+buffIndex

++++++++//+Find+a+length+of+data+to+place+into+the+line+buffer+to+be
++++++++//+returned;+reset+buffIndex
++++++++if+let+delim+=+delimLocation()+{
++++++++++++//+SOME+VALUE+when+a+delimiter+is+found;+append+that+amount+of
++++++++++++//+data+onto+the+line+buffer,and+then+return+the+line+buffer
++++++++++++delimFound+=+true
++++++++++++lengthToDelim+=+delim+-+buffIndex
++++++++++++buffIndex+=+delim+%2B+1+++//+will+trigger+a+refill+if+at+the+end
++++++++++++++++++++++++++++++++++++//+of+the+buffer+on+the+next+call,+but
++++++++++++++++++++++++++++++++++++//+first+the+line+will+be+returned
++++++++}+else+{
++++++++++++//+NIL+if+no+delimiter+left+in+the+buffer;+append+the+rest+of
++++++++++++//+the+buffer+onto+the+line+buffer,+refill+the+buffer,+and
++++++++++++//+continue+looking
++++++++++++lengthToDelim+=+buffEndIndex+-+buffIndex
++++++++++++buffIndex+=+buffEndIndex++++//+will+trigger+a+refill+of+buffer
++++++++++++++++++++++++++++++++++++++++//+on+the+next+loop
++++++++}

++++++++line.appendData(buffer.subdataWithRange(
++++++++++++NSMakeRange(startIndex,+lengthToDelim)))
++++}

++++return+dataStrValue(line)
++}
}|code-block|syntax|javascript|2736622|调用方式如下：|2736623|guard+let+myStream+=+LineStream(path:+"/path/to/file.txt")
else+{+exit(EXIT_FAILURE)+}

while+let+s+=+myStream.readLine()+{
++print(s)
}|2736624|entityMap^0|1X|A|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

I wanted a version that did not continually modify the buffer or duplicate code, as both are inefficient, and would allow for any size buffer (including 1 byte) and any delimiter. It has one public method: <code>readline()</code>. Calling this method will return the String value of the next line or nil at EOF.

<pre><code>import Foundation

// LineStream(): path: String, [buffSize: Int], [delim: String] -&gt; nil | String
// ============= --------------------------------------------------------------
// path: the path to a text file to be parsed
// buffSize: an optional buffer size, (1...); default is 4096
// delim: an optional delimiter String; default is "\n"
// ***************************************************************************
class LineStream {
 let path: String
 let handle: NSFileHandle!

 let delim: NSData!
 let encoding: NSStringEncoding

 var buffer = NSData()
 var buffSize: Int

 var buffIndex = 0
 var buffEndIndex = 0

 init?(path: String,
 buffSize: Int = 4096,
 delim: String = "\n",
 encoding: NSStringEncoding = NSUTF8StringEncoding)
 {
 self.handle = NSFileHandle(forReadingAtPath: path)
 self.path = path
 self.buffSize = buffSize &lt; 1 ? 1 : buffSize
 self.encoding = encoding
 self.delim = delim.dataUsingEncoding(encoding)
 if handle == nil || self.delim == nil {
 print("ERROR initializing LineStream") /* TODO use STDERR */
 return nil
 }
 }

 // PRIVATE
 // fillBuffer(): _ -&gt; Int [0...buffSize]
 // ============= -------- ..............
 // Fill the buffer with new data; return with the buffer size, or zero
 // upon reaching end-of-file
 // *********************************************************************
 private func fillBuffer() -&gt; Int {
 buffer = handle.readDataOfLength(buffSize)
 buffIndex = 0
 buffEndIndex = buffer.length

 return buffEndIndex
 }

 // PRIVATE
 // delimLocation(): _ -&gt; Int? nil | [1...buffSize]
 // ================ --------- ....................
 // Search the remaining buffer for a delimiter; return with the location
 // of a delimiter in the buffer, or nil if one is not found.
 // ***********************************************************************
 private func delimLocation() -&gt; Int? {
 let searchRange = NSMakeRange(buffIndex, buffEndIndex - buffIndex)
 let rangeToDelim = buffer.rangeOfData(delim,
 options: [], range: searchRange)
 return rangeToDelim.location == NSNotFound
 ? nil
 : rangeToDelim.location
 }

 // PRIVATE
 // dataStrValue(): NSData -&gt; String ("" | String)
 // =============== ---------------- .............
 // Attempt to convert data into a String value using the supplied encoding; 
 // return the String value or empty string if the conversion fails.
 // ***********************************************************************
 private func dataStrValue(data: NSData) -&gt; String? {
 if let strVal = NSString(data: data, encoding: encoding) as? String {
 return strVal
 } else { return "" }
}

 // PUBLIC
 // readLine(): _ -&gt; String? nil | String
 // =========== ____________ ............
 // Read the next line of the file, i.e., up to the next delimiter or end-of-
 // file, whichever occurs first; return the String value of the data found, 
 // or nil upon reaching end-of-file.
 // *************************************************************************
 func readLine() -&gt; String? {
 guard let line = NSMutableData(capacity: buffSize) else {
 print("ERROR setting line")
 exit(EXIT_FAILURE)
 }

 // Loop until a delimiter is found, or end-of-file is reached
 var delimFound = false
 while !delimFound {
 // buffIndex will equal buffEndIndex in three situations, resulting
 // in a (re)filling of the buffer:
 // 1. Upon the initial call;
 // 2. If a search for a delimiter has failed
 // 3. If a delimiter is found at the end of the buffer
 if buffIndex == buffEndIndex {
 if fillBuffer() == 0 {
 return nil
 }
 }

 var lengthToDelim: Int
 let startIndex = buffIndex

 // Find a length of data to place into the line buffer to be
 // returned; reset buffIndex
 if let delim = delimLocation() {
 // SOME VALUE when a delimiter is found; append that amount of
 // data onto the line buffer,and then return the line buffer
 delimFound = true
 lengthToDelim = delim - buffIndex
 buffIndex = delim + 1 // will trigger a refill if at the end
 // of the buffer on the next call, but
 // first the line will be returned
 } else {
 // NIL if no delimiter left in the buffer; append the rest of
 // the buffer onto the line buffer, refill the buffer, and
 // continue looking
 lengthToDelim = buffEndIndex - buffIndex
 buffIndex = buffEndIndex // will trigger a refill of buffer
 // on the next loop
 }

 line.appendData(buffer.subdataWithRange(
 NSMakeRange(startIndex, lengthToDelim)))
 }

 return dataStrValue(line)
 }
}
</code></pre>

It is called as follows:

<pre><code>guard let myStream = LineStream(path: "/path/to/file.txt")
else { exit(EXIT_FAILURE) }

while let s = myStream.readLine() {
 print(s)
}
</code></pre>

blocks|key|2736639|text|用于逐行读取文本文件的高效且方便的类(Swift+4、Swift+5)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2736640|注意:这段代码是独立于平台的(macOS，iOS，ubuntu)|2736641|import+Foundation

///+Read+text+file+line+by+line+in+efficient+way
public+class+LineReader+{
+++public+let+path:+String

+++fileprivate+let+file:+UnsafeMutablePointer<FILE>!

+++init?(path:+String)+{
++++++self.path+=+path
++++++file+=+fopen(path,+"r")
++++++guard+file+!=+nil+else+{+return+nil+}
+++}

+++public+var+nextLine:+String?+{
++++++var+line:UnsafeMutablePointer<CChar>?+=+nil
++++++var+linecap:Int+=+0
++++++defer+{+free(line)+}
++++++return+getline(&line,+&linecap,+file)+>+0+?+String(cString:+line!)+:+nil
+++}

+++deinit+{
++++++fclose(file)
+++}
}

extension+LineReader:+Sequence+{
+++public+func++makeIterator()+->+AnyIterator<String>+{
++++++return+AnyIterator<String>+{
+++++++++return+self.nextLine
++++++}
+++}
}|code-block|syntax|javascript|2736642|用法：|2736643|guard+let+reader+=+LineReader(path:+"/Path/to/file.txt")+else+{
++++return;+//+cannot+open+file
}

for+line+in+reader+{
++++print(">"+%2B+line.trimmingCharacters(in:+.whitespacesAndNewlines))++++++
}|2736644|Repository+on+github|offset|length|2736645|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/andrewwoz/LineReader^0|0|0|0|0|0|0|K|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|13|8|@]|9|@$O|14|P|15|1|16]]|A|$]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

Efficient and convenient class for reading text file line by line (Swift 4, Swift 5)

Note: This code is platform independent (macOS, iOS, ubuntu)


<pre><code>import Foundation

/// Read text file line by line in efficient way
public class LineReader {
 public let path: String

 fileprivate let file: UnsafeMutablePointer&lt;FILE&gt;!

 init?(path: String) {
 self.path = path
 file = fopen(path, "r")
 guard file != nil else { return nil }
 }

 public var nextLine: String? {
 var line:UnsafeMutablePointer&lt;CChar&gt;? = nil
 var linecap:Int = 0
 defer { free(line) }
 return getline(&amp;line, &amp;linecap, file) &gt; 0 ? String(cString: line!) : nil
 }

 deinit {
 fclose(file)
 }
}

extension LineReader: Sequence {
 public func makeIterator() -&gt; AnyIterator&lt;String&gt; {
 return AnyIterator&lt;String&gt; {
 return self.nextLine
 }
 }
}
</code></pre>

Usage:

<pre class="lang-swift prettyprint-override"><code>guard let reader = LineReader(path: "/Path/to/file.txt") else {
 return; // cannot open file
}

for line in reader {
 print("&gt;" + line.trimmingCharacters(in: .whitespacesAndNewlines)) 
}
</code></pre>

<a href="https://github.com/andrewwoz/LineReader" rel="noreferrer">Repository on github</a>

blocks|key|2736670|text|(注意:我在Xcode+8.2.1和macOS+sera10.12.3上使用Swift+3.0.1+)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2736671|我在这里看到的所有答案都遗漏了他可能在寻找LF或CRLF。如果一切顺利，他/她就可以在LF上匹配，并在最后检查返回的字符串中是否有额外的CR。但是一般查询涉及多个搜索字符串。换句话说，分隔符需要是一个Set<String>，其中集合既不是空的，也不包含空字符串，而不是单个字符串。|offset|length|style|CODE|2736672|在我去年的第一次尝试中，我试图做“正确的事情”，并搜索一组通用的字符串。这太难了；你需要一个完全成熟的解析器和状态机等等。我放弃了它，放弃了它是项目的一部分。|2736673|现在我又在做这个项目，并再次面临同样的挑战。现在我将在CR和LF上进行硬编码搜索。我不认为任何人需要在CR/LF解析之外搜索像这样的两个半独立和半依赖的字符。|2736674|我使用的是Data提供的搜索方法，所以这里不做字符串编码之类的工作。只是原始的二进制处理。假设我这里有一个ASCII超集，比如ISO拉丁语-1或UTF-8。您可以在下一个更高层处理字符串编码，并且您可以押注附加了辅助代码点的CR/LF是否仍算作CR或LF。|2736675|算法:只需从当前字节偏移量继续搜索下一个CR和下一个LF。|2736676|2736677|如果两者都没有找到，则认为下一个数据字符串是从当前偏移量到数据结尾。请注意，终止符长度为0。|unordered-list-item|2736678|如果先找到LF，或者只找到LF，则认为下一个数据字符串是从当前偏移量到LF的。注意，终止符的长度是1。将偏移量移到LF之后。|2736679|如果只找到CR，就像LF的情况一样(只是使用不同的字节value).|2736680|Otherwise，，我们得到一个CR，后面跟着一个LF。|2736681|如果两者相邻，则处理方式类似于LF情况，除了终止符长度将为2。|2736682|如果它们之间有一个字节，并且所说的字节也是CR，则我们得到"Windows+developer+wrote+a+binary+\r\n+then+in+text+mode，给出\r\r\n“问题。也可以像处理LF情况一样处理它，除了终止符长度将是3.|2736683|否则CR和LF不连接，并像-CR+case.|2736684|2736685|一样处理|2736686|​|2736687|下面是一些代码：|2736688|struct+DataInternetLineIterator:+IteratorProtocol+{

++++///+Descriptor+of+the+location+of+a+line
++++typealias+LineLocation+=+(offset:+Int,+length:+Int,+terminatorLength:+Int)

++++///+Carriage+return.
++++static+let+cr:+UInt8+=+13
++++///+Carriage+return+as+data.
++++static+let+crData+=+Data(repeating:+cr,+count:+1)
++++///+Line+feed.
++++static+let+lf:+UInt8+=+10
++++///+Line+feed+as+data.
++++static+let+lfData+=+Data(repeating:+lf,+count:+1)

++++///+The+data+to+traverse.
++++let+data:+Data
++++///+The+byte+offset+to+search+from+for+the+next+line.
++++private+var+lineStartOffset:+Int+=+0

++++///+Initialize+with+the+data+to+read+over.
++++init(data:+Data)+{
++++++++self.data+=+data
++++}

++++mutating+func+next()+->+LineLocation?+{
++++++++guard+self.data.count+-+self.lineStartOffset+>+0+else+{+return+nil+}

++++++++let+nextCR+=+self.data.range(of:+DataInternetLineIterator.crData,+options:+[],+in:+lineStartOffset..<self.data.count)?.lowerBound
++++++++let+nextLF+=+self.data.range(of:+DataInternetLineIterator.lfData,+options:+[],+in:+lineStartOffset..<self.data.count)?.lowerBound
++++++++var+location:+LineLocation+=+(self.lineStartOffset,+-self.lineStartOffset,+0)
++++++++let+lineEndOffset:+Int
++++++++switch+(nextCR,+nextLF)+{
++++++++case+(nil,+nil):
++++++++++++lineEndOffset+=+self.data.count
++++++++case+(nil,+let+offsetLf):
++++++++++++lineEndOffset+=+offsetLf!
++++++++++++location.terminatorLength+=+1
++++++++case+(let+offsetCr,+nil):
++++++++++++lineEndOffset+=+offsetCr!
++++++++++++location.terminatorLength+=+1
++++++++default:
++++++++++++lineEndOffset+=+min(nextLF!,+nextCR!)
++++++++++++if+nextLF!+<+nextCR!+{
++++++++++++++++location.terminatorLength+=+1
++++++++++++}+else+{
++++++++++++++++switch+nextLF!+-+nextCR!+{
++++++++++++++++case+2+where+self.data[nextCR!+%2B+1]+==+DataInternetLineIterator.cr:
++++++++++++++++++++location.terminatorLength+%2B=+1++//+CR-CRLF
++++++++++++++++++++fallthrough
++++++++++++++++case+1:
++++++++++++++++++++location.terminatorLength+%2B=+1++//+CRLF
++++++++++++++++++++fallthrough
++++++++++++++++default:
++++++++++++++++++++location.terminatorLength+%2B=+1++//+CR-only
++++++++++++++++}
++++++++++++}
++++++++}
++++++++self.lineStartOffset+=+lineEndOffset+%2B+location.terminatorLength
++++++++location.length+%2B=+self.lineStartOffset
++++++++return+location
++++}

}|code-block|syntax|javascript|2736689|当然，如果您的Data块的长度至少是千兆字节的重要部分，那么每当从当前字节偏移量开始不再存在CR或LF时，您就会受到影响；在每次迭代期间，总是徒劳无功地搜索到最后。以块的形式读取数据会有所帮助：|2736690|struct+DataBlockIterator:+IteratorProtocol+{

++++///+The+data+to+traverse.
++++let+data:+Data
++++///+The+offset+into+the+data+to+read+the+next+block+from.
++++private(set)+var+blockOffset+=+0
++++///+The+number+of+bytes+remaining.++Kept+so+the+last+block+is+the+right+size+if+it's+short.
++++private(set)+var+bytesRemaining:+Int
++++///+The+size+of+each+block+(except+possibly+the+last).
++++let+blockSize:+Int

++++///+Initialize+with+the+data+to+read+over+and+the+chunk+size.
++++init(data:+Data,+blockSize:+Int)+{
++++++++precondition(blockSize+>+0)

++++++++self.data+=+data
++++++++self.bytesRemaining+=+data.count
++++++++self.blockSize+=+blockSize
++++}

++++mutating+func+next()+->+Data?+{
++++++++guard+bytesRemaining+>+0+else+{+return+nil+}
++++++++defer+{+blockOffset+%2B=+blockSize+;+bytesRemaining+-=+blockSize+}

++++++++return+data.subdata(in:+blockOffset..<(blockOffset+%2B+min(bytesRemaining,+blockSize)))
++++}

}|2736691|你必须自己把这些想法混合在一起，因为我还没有这样做。考虑一下：|2736692|当然，你必须考虑完全包含在块中的行。|2736693|，但当一行的末端在相邻块中时，你必须处理。|2736694|
|2736695|或者当端点之间至少有一个块时，|2736696|2736697|当行以多字节序列结束时，最大的复杂是当行以多字节序列结束时，而所说的序列跨越两个块！(同样以CR结尾的行也是块中的最后一个字节，因为您需要读取下一个块来查看您的just-CR实际上是CRLF还是CR-CRLF。当数据块以CR-CR结束时，也会出现类似的恶作剧。)|2736698|2736699|，当当前偏移量没有更多的终止符，但数据的结尾在后面的块中时，您需要处理。|2736700|2736701|祝好运!|2736702|entityMap^0|0|2S|B|0|0|0|5|4|0|0|0|0|0|0|1|1|1|1|0|0|0|0|0|7|4|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|26|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|27|8|@$D|28|E|29|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|2A|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|2B|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|2C|8|@$D|2D|E|2E|F|G]]|9|@]|A|$]]|$1|N|3|O|5|6|7|2F|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|2G|8|@]|9|@]|A|$]]|$1|Q|3|R|5|S|7|2H|8|@]|9|@]|A|$]]|$1|T|3|U|5|S|7|2I|8|@]|9|@]|A|$]]|$1|V|3|W|5|S|7|2J|8|@]|9|@]|A|$]]|$1|X|3|Y|5|S|7|2K|8|@]|9|@]|A|$]]|$1|Z|3|10|5|S|7|2L|8|@]|9|@]|A|$]]|$1|11|3|12|5|S|7|2M|8|@]|9|@]|A|$]]|$1|13|3|14|5|S|7|2N|8|@]|9|@]|A|$]]|$1|15|3|-4|5|6|7|2O|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|2P|8|@]|9|@]|A|$]]|$1|18|3|19|5|6|7|2Q|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|6|7|2R|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|1E|7|2S|8|@]|9|@]|A|$1F|1G]]|$1|1H|3|1I|5|6|7|2T|8|@$D|2U|E|2V|F|G]]|9|@]|A|$]]|$1|1J|3|1K|5|1E|7|2W|8|@]|9|@]|A|$1F|1G]]|$1|1L|3|1M|5|6|7|2X|8|@]|9|@]|A|$]]|$1|1N|3|1O|5|6|7|2Y|8|@]|9|@]|A|$]]|$1|1P|3|1Q|5|S|7|2Z|8|@]|9|@]|A|$]]|$1|1R|3|1S|5|6|7|30|8|@]|9|@]|A|$]]|$1|1T|3|1U|5|S|7|31|8|@]|9|@]|A|$]]|$1|1V|3|1S|5|6|7|32|8|@]|9|@]|A|$]]|$1|1W|3|1X|5|S|7|33|8|@]|9|@]|A|$]]|$1|1Y|3|1S|5|6|7|34|8|@]|9|@]|A|$]]|$1|1Z|3|20|5|S|7|35|8|@]|9|@]|A|$]]|$1|21|3|-4|5|6|7|36|8|@]|9|@]|A|$]]|$1|22|3|23|5|6|7|37|8|@]|9|@]|A|$]]|$1|24|3|-4|5|6|7|38|8|@]|9|@]|A|$]]]|25|$]]

(Note: I'm using Swift 3.0.1 on Xcode 8.2.1 with macOS Sierra 10.12.3)

All of the answers I've seen here missed that he could be looking for LF or CRLF. If everything goes well, s/he could just match on LF and check the returned string for an extra CR at the end. But the general query involves multiple search strings. In other words, the delimiter needs to be a <code>Set&lt;String&gt;</code>, where the set is neither empty nor contains the empty string, instead of a single string.

On my first try at this last year, I tried to do the "right thing" and search for a general set of strings. It was too hard; you need a full blown parser and state machines and such. I gave up on it and the project it was part of.

Now I'm doing the project again, and facing the same challenge again. Now I'm going to hard-code searching on CR and LF. I don't think anyone would need to search on two semi-independent and semi-dependent characters like this outside of CR/LF parsing.

I'm using the search methods provided by <code>Data</code>, so I'm not doing string encodings and stuff here. Just raw binary processing. Just assume I got an ASCII superset, like ISO Latin-1 or UTF-8, here. You can handle string encoding at the next-higher layer, and you punt on whether a CR/LF with secondary code-points attached still counts as a CR or LF.

The algorithm: just keep searching for the next CR and the next LF from your current byte offset.

<ul>
<li>If neither is found, then consider the next data string to be from the current offset to the end-of-data. Note that the terminator length is 0. Mark this as the end of your reading loop.</li>
<li>If a LF is found first, or only a LF is found, consider the next data string to be from the current offset to the LF. Note that the terminator length is 1. Move the offset to after the LF.</li>
<li>If only a CR is found, do like the LF case (just with a different byte value).</li>
<li>Otherwise, we got a CR followed by a LF.

<ul>
<li>If the two are adjacent, then handle like the LF case, except the terminator length will be 2.</li>
<li>If there is one byte between them, and said byte is also CR, then we got the "Windows developer wrote a binary \r\n while in text mode, giving a \r\r\n" problem. Also handle it like the LF case, except the terminator length will be 3.</li>
<li>Otherwise the CR and LF aren't connected, and handle like the just-CR case.</li>
</ul></li>
</ul>

Here's some code for that:

<pre><code>struct DataInternetLineIterator: IteratorProtocol {

 /// Descriptor of the location of a line
 typealias LineLocation = (offset: Int, length: Int, terminatorLength: Int)

 /// Carriage return.
 static let cr: UInt8 = 13
 /// Carriage return as data.
 static let crData = Data(repeating: cr, count: 1)
 /// Line feed.
 static let lf: UInt8 = 10
 /// Line feed as data.
 static let lfData = Data(repeating: lf, count: 1)

 /// The data to traverse.
 let data: Data
 /// The byte offset to search from for the next line.
 private var lineStartOffset: Int = 0

 /// Initialize with the data to read over.
 init(data: Data) {
 self.data = data
 }

 mutating func next() -&gt; LineLocation? {
 guard self.data.count - self.lineStartOffset &gt; 0 else { return nil }

 let nextCR = self.data.range(of: DataInternetLineIterator.crData, options: [], in: lineStartOffset..&lt;self.data.count)?.lowerBound
 let nextLF = self.data.range(of: DataInternetLineIterator.lfData, options: [], in: lineStartOffset..&lt;self.data.count)?.lowerBound
 var location: LineLocation = (self.lineStartOffset, -self.lineStartOffset, 0)
 let lineEndOffset: Int
 switch (nextCR, nextLF) {
 case (nil, nil):
 lineEndOffset = self.data.count
 case (nil, let offsetLf):
 lineEndOffset = offsetLf!
 location.terminatorLength = 1
 case (let offsetCr, nil):
 lineEndOffset = offsetCr!
 location.terminatorLength = 1
 default:
 lineEndOffset = min(nextLF!, nextCR!)
 if nextLF! &lt; nextCR! {
 location.terminatorLength = 1
 } else {
 switch nextLF! - nextCR! {
 case 2 where self.data[nextCR! + 1] == DataInternetLineIterator.cr:
 location.terminatorLength += 1 // CR-CRLF
 fallthrough
 case 1:
 location.terminatorLength += 1 // CRLF
 fallthrough
 default:
 location.terminatorLength += 1 // CR-only
 }
 }
 }
 self.lineStartOffset = lineEndOffset + location.terminatorLength
 location.length += self.lineStartOffset
 return location
 }

}
</code></pre>

Of course, if you have a <code>Data</code> block of a length that's at least a significant fraction of a gigabyte, you'll take a hit whenever no more CR or LF exist from the current byte offset; always fruitlessly searching until the end during every iteration. Reading the data in chunks would help:

<pre><code>struct DataBlockIterator: IteratorProtocol {

 /// The data to traverse.
 let data: Data
 /// The offset into the data to read the next block from.
 private(set) var blockOffset = 0
 /// The number of bytes remaining. Kept so the last block is the right size if it's short.
 private(set) var bytesRemaining: Int
 /// The size of each block (except possibly the last).
 let blockSize: Int

 /// Initialize with the data to read over and the chunk size.
 init(data: Data, blockSize: Int) {
 precondition(blockSize &gt; 0)

 self.data = data
 self.bytesRemaining = data.count
 self.blockSize = blockSize
 }

 mutating func next() -&gt; Data? {
 guard bytesRemaining &gt; 0 else { return nil }
 defer { blockOffset += blockSize ; bytesRemaining -= blockSize }

 return data.subdata(in: blockOffset..&lt;(blockOffset + min(bytesRemaining, blockSize)))
 }

}
</code></pre>

You have to mix these ideas together yourself, since I haven't done it yet. Consider:

<ul>
<li>Of course, you have to consider lines completely contained in a chunk.</li>
<li>But you have to handle when the ends of a line are in adjacent chunks.</li>
<li>Or when the endpoints have at least one chunk between them</li>
<li>The big complication is when the line ends with a multi-byte sequence, but said sequence straddles two chunks! (A line ending in just CR that's also the last byte in the chunk is an equivalent case, since you need to read the next chunk to see if your just-CR is actually a CRLF or CR-CRLF. There are similar shenanigans when the chunk ends with CR-CR.)</li>
<li>And you need to handle when there are no more terminators from your current offset, but the end-of-data is in a later chunk.</li>
</ul>

Good luck!

blocks|key|2736704|text|Swift+4.2安全语法|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2736705|class+LineReader+{

++++let+path:+String

++++init?(path:+String)+{
++++++++self.path+=+path
++++++++guard+let+file+=+fopen(path,+"r")+else+{
++++++++++++return+nil
++++++++}
++++++++self.file+=+file
++++}
++++deinit+{
++++++++fclose(file)
++++}

++++var+nextLine:+String?+{
++++++++var+line:+UnsafeMutablePointer<CChar>?
++++++++var+linecap+=+0
++++++++defer+{
++++++++++++free(line)
++++++++}
++++++++let+status+=+getline(&line,+&linecap,+file)
++++++++guard+status+>+0,+let+unwrappedLine+=+line+else+{
++++++++++++return+nil
++++++++}
++++++++return+String(cString:+unwrappedLine)
++++}

++++private+let+file:+UnsafeMutablePointer<FILE>
}

extension+LineReader:+Sequence+{
++++func+makeIterator()+->+AnyIterator<String>+{
++++++++return+AnyIterator<String>+{
++++++++++++return+self.nextLine
++++++++}
++++}
}|code-block|syntax|javascript|2736706|用法：|2736707|guard+let+reader+=+LineReader(path:+"/Path/to/file.txt")+else+{
++++return
}
reader.forEach+{+line+in
++++print(line.trimmingCharacters(in:+.whitespacesAndNewlines))++++++
}|2736708|entityMap^0|0|9|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

Swift 4.2 Safe syntax

<pre><code>class LineReader {

 let path: String

 init?(path: String) {
 self.path = path
 guard let file = fopen(path, "r") else {
 return nil
 }
 self.file = file
 }
 deinit {
 fclose(file)
 }

 var nextLine: String? {
 var line: UnsafeMutablePointer&lt;CChar&gt;?
 var linecap = 0
 defer {
 free(line)
 }
 let status = getline(&amp;line, &amp;linecap, file)
 guard status &gt; 0, let unwrappedLine = line else {
 return nil
 }
 return String(cString: unwrappedLine)
 }

 private let file: UnsafeMutablePointer&lt;FILE&gt;
}

extension LineReader: Sequence {
 func makeIterator() -&gt; AnyIterator&lt;String&gt; {
 return AnyIterator&lt;String&gt; {
 return self.nextLine
 }
 }
}
</code></pre>

Usage:

<pre><code>guard let reader = LineReader(path: "/Path/to/file.txt") else {
 return
}
reader.forEach { line in
 print(line.trimmingCharacters(in: .whitespacesAndNewlines)) 
}
</code></pre>

blocks|key|2949409|text|在@dankogai的answer之后，我对Swift+4%2B做了一些修改，|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2949410|++++let+bufsize+=+4096
++++let+fp+=+fopen(jsonURL.path,+"r");
++++var+buf+=+UnsafeMutablePointer<Int8>.allocate(capacity:+bufsize)

++++while+(fgets(buf,+Int32(bufsize-1),+fp)+!=+nil)+{
++++++++print(+String(cString:+buf)+)
+++++}
++++buf.deallocate()|code-block|syntax|javascript|2949411|这对我很有效。|2949412|谢谢|2949413|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/24669956/1845404^0|B|6|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Following up on @dankogai's <a href="https://stackoverflow.com/a/24669956/1845404">answer</a>, I made a few modifications for Swift 4+,

<pre><code> let bufsize = 4096
 let fp = fopen(jsonURL.path, "r");
 var buf = UnsafeMutablePointer&lt;Int8&gt;.allocate(capacity: bufsize)

 while (fgets(buf, Int32(bufsize-1), fp) != nil) {
 print( String(cString: buf) )
 }
 buf.deallocate()
</code></pre>

This worked for me.

Thanks

I am trying to read a file given in an <code>NSURL</code> and load it into an array, with items separated by a newline character <code>\n</code>. 

Here is the way I've done it so far:

<pre><code>var possList: NSString? = NSString.stringWithContentsOfURL(filePath.URL) as? NSString
if var list = possList {
 list = list.componentsSeparatedByString("\n") as NSString[]
 return list
}
else {
 //return empty list
}
</code></pre>

I'm not very happy with this for a couple of reasons. One, I'm working with files that range from a few kilobytes to hundreds of MB in size. As you can imagine, working with strings this large is slow and unwieldy. Secondly, this freezes up the UI when it's executing--again, not good.

I've looked into running this code in a separate thread, but I've been having trouble with that, and besides, it still doesn't solve the problem of dealing with huge strings.

What I'd like to do is something along the lines of the following pseudocode:

<pre><code>var aStreamReader = new StreamReader(from_file_or_url)
while aStreamReader.hasNextLine == true {
 currentline = aStreamReader.nextLine()
 list.addItem(currentline)
}
</code></pre>

How would I accomplish this in Swift?

A few notes about the files I'm reading from: All files consist of short (&lt;255 chars) strings separated by either <code>\n</code> or <code>\r\n</code>. The length of the files range from ~100 lines to over 50 million lines. They may contain European characters, and/or characters with accents.

Read a file/URL line-by-line in Swift

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

我正在尝试读取NSURL中给定的文件，并将其加载到一个数组中，其中的项由换行符\n分隔。到目前为止，我是这样做的：var possList: NSString? = NSString.stringWithContentsOfURL(filePath.URL) as? NSStringif var list = poss...

问在Swift中逐行读取文件/URL
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Swift中逐行读取文件/URLEN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Swift中逐行读取文件/URL
EN