Điều này phải là một câu hỏi phổ biến mà tất cả các lập trình viên thỉnh thoảng có. Làm cách nào để đọc một dòng từ tệp văn bản? Sau đó, câu hỏi tiếp theo là làm thế nào để tôi viết lại.

Tất nhiên hầu hết các bạn sử dụng khung mức cao trong lập trình hàng ngày (rất tốt để sử dụng trong câu trả lời) nhưng đôi khi thật tuyệt khi biết cách làm điều đó ở mức độ thấp.

Bản thân tôi biết làm thế nào để làm điều đó trong C , C++và Objective-C, nhưng chắc chắn sẽ rất hữu ích khi xem cách nó được thực hiện trong tất cả các ngôn ngữ phổ biến, nếu chỉ để giúp chúng tôi đưa ra quyết định tốt hơn về ngôn ngữ nào để thực hiện tệp của chúng tôi. Tôi nghĩ sẽ rất thú vị khi xem cách nó được thực hiện trong các ngôn ngữ thao tác chuỗi, như : python, rubyvà tất nhiên perl.

Vì vậy, tôi hình ở đây chúng ta có thể tạo một tài nguyên cộng đồng mà tất cả chúng ta có thể gắn dấu sao vào hồ sơ của mình và tham khảo khi chúng ta cần thực hiện I / O bằng một số ngôn ngữ mới. Không đề cập đến việc tiếp xúc tất cả chúng ta sẽ có được các ngôn ngữ mà chúng ta không đối phó hàng ngày.

Đây là cách bạn cần trả lời:

1. Tạo một tệp văn bản mới gọi là " fileio.txt "
2. Viết dòng đầu tiên "xin chào" vào tệp văn bản.
3. Nối dòng "thế giới" thứ hai vào tệp văn bản.
4. Đọc dòng "thế giới" thứ hai thành một chuỗi đầu vào.
5. In chuỗi đầu vào vào bàn điều khiển.

Làm rõ:

• Bạn chỉ nên làm thế nào để làm điều này trong một ngôn ngữ lập trình cho mỗi câu trả lời.
• Giả sử rằng tệp văn bản không tồn tại trước
• Bạn không cần mở lại tệp văn bản sau khi viết dòng đầu tiên

Không có giới hạn cụ thể về ngôn ngữ. C, C++, C#, Java, Objective-CTất cả đều tuyệt vời.

Nếu bạn biết làm thế nào để làm điều đó trong Prolog, Haskell, Fortran, Lisp, hay Basicthì hãy đi ngay phía trước.

Con trăn 3

with open('fileio.txt', 'w') as f:
   f.write('hello')
with open('fileio.txt', 'a') as f:
   f.write('\nworld')
with open('fileio.txt') as f:
   s = f.readlines()[1]
print(s)

Làm rõ

• readlines () trả về một danh sách tất cả các dòng trong tệp. Do đó, việc gọi ra các đường dẫn () dẫn đến việc đọc từng dòng của tệp. Trong trường hợp cụ thể đó, sử dụng readlines () là tốt vì chúng tôi phải đọc toàn bộ tệp (chúng tôi muốn dòng cuối cùng của nó). Nhưng nếu tệp của chúng tôi chứa nhiều dòng và chúng tôi chỉ muốn in dòng thứ n của nó, thì không cần thiết phải đọc toàn bộ tệp. Dưới đây là một số cách tốt hơn để có được dòng thứ n của tệp trong Python: Điều gì thay thế xreadlines () trong Python 3? .

• Đây là gì với tuyên bố? Câu lệnh with bắt đầu một khối mã trong đó bạn có thể sử dụng biến f làm đối tượng luồng được trả về từ lệnh gọi để mở (). Khi khối kết thúc, python tự động gọi f.close (). Điều này đảm bảo tệp sẽ được đóng khi bạn thoát khỏi khối với bất kể bạn thoát khỏi khối như thế nào hoặc ngay cả khi bạn thoát khỏi nó thông qua một ngoại lệ chưa được xử lý). Bạn có thể gọi f.close () một cách rõ ràng, nhưng nếu mã của bạn phát sinh một ngoại lệ và bạn không nhận được cuộc gọi f.close () thì sao? Đó là lý do tại sao câu lệnh với hữu ích.

• Bạn không cần mở lại tệp trước mỗi thao tác. Bạn có thể viết toàn bộ mã bên trong một với khối.

  with open('fileio.txt', 'w+') as f:
      f.write('hello')
      f.write('\nworld')
      s = f.readlines()[1]
  print(s)
  

  Tôi đã sử dụng ba khối để nhấn mạnh sự khác biệt giữa ba thao tác: write (chế độ 'w'), chắp thêm (chế độ 'a'), đọc (chế độ 'r', mặc định).

LOLCODE

Thông số kỹ thuật còn sơ sài để nói ít nhất, nhưng tôi đã làm tốt nhất có thể. Hãy bắt đầu xuống cấp! :) Tôi vẫn thấy nó là một bài tập thú vị.

HAI
CAN HAS STDIO?
PLZ OPEN FILE "FILEIO.TXT" ITZ "TehFilez"?
    AWSUM THX
        BTW #There is no standard way to output to files yet...
        VISIBLE "Hello" ON TehFilez
        BTW #There isn't a standard way to append to files either...
        MOAR VISIBLE "World" ON TehFilez
        GIMMEH LINES TehLinez OUTTA TehFilez
        I HAS A SecondLine ITZ 1 IN MAH TehLinez
        VISIBLE SecondLine
    O NOES
        VISIBLE "OH NOES!!!"
KTHXBYE

Não *** k

,------------------------------------------------>,------------------------------------------------>,------------------------------------------------>[-]+++++++++>[-]+++++++++>[-]+++++++++<<<<<[>>>>>>+>>>+<<<<<<<<<-]>>>>>>>>>[<<<<<<<<<+>>>>>>>>>-]<<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]<<<<<<<[>>>>>>+>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]>>[-]<<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]<<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<<<->>>->>>>>[-]<<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]<<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>][-]<<<<<<<[>>>>>+>>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]<<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<<->>>->>>>[-]<<<<<<<[>>>>>+>>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]<<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>][-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<->>>->>>[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>]<[-]+<[-]+<<<<<<[>>>>>>[-]<<<<<<[-]]>>>>>>[[-]+<<<<<[>>>>>[-]<<<<<[-]]>>>>>[[-]+<<<<[>>>>[-]<<<<[-]]>>>>[[-]+<<<[>>>[-]<<<[-]]>>>[[-]+<<[>>[-]<<[-]]>>[[-]+<[>[-]<[-]]>[[-]+++++++++++++++++++++++++++++++++++++++++++++++++.-...>[-]<[-]]<>[-]]<<>>[-]]<<<>>>[-]]<<<<>>>>[-],------------------------------------------------>,------------------------------------------------>,------------------------------------------------>[-]+++++++++>[-]+++++++++>[-]+++++++++<<<<<[>>>>>>+>>>+<<<<<<<<<-]>>>>>>>>>[<<<<<<<<<+>>>>>>>>>-]<<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]<<<<<<<[>>>>>>+>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]>>[-]<<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]<<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<<<->>>->>>>>[-]<<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]<<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>][-]<<<<<<<[>>>>>+>>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]<<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<<->>>->>>>[-]<<<<<<<[>>>>>+>>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]<<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>][-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<->>>->>>[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>]<[-]+<[-]+<<<<<<[>>>>>>[-]<<<<<<[-]]>>>>>>[[-]+<<<<<[>>>>>[-]<<<<<[-]]>>>>>[[-]+<<<<[>>>>[-]<<<<[-]]>>>>[[-]+<<<[>>>[-]<<<[-]]>>>[[-]+<<[>>[-]<<[-]]>>[[-]+<[>[-]<[-]]>[[-]+++++++++++++++++++++++++++++++++++++++++++++++++.-...>[-]<[-]]<>[-]]<<>>[-]]<<<>>>[-]]<<<<>>>>[-]]<<<<<>>>>>[-]]<<<<<<>>>>>>>[<<<<<<<<[>>>>>>+>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]>[-]++++++++++<<+<<<<<<+>>>>>>>>>>>[-]<<<<<[>>>+>>+<<<<<-]>>>>>[<<<<<+>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<->>->>>[-]<<<<<[>>>+>>+<<<<<-]>>>>>[<<<<<+>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>]<<<<[-]+<[>[-]<[-]]>[[-]+>[<[-]>[-]]<[<<<<<<<[-]<+>>>>>>>>[-]]><[-]]<<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]>[-]++++++++++>>>[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<->>>->>>[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>]<<<<[-]+<<[>>[-]<<[-]]>>[[-]+>[<[-]>[-]]<[<<<<<<<<[-]<+>>>>>>>>>[-]]><[-]]<<<<<<<<<++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++.>>>>>>>>[-]]]<<<<<>>>>>[-]]<<<<<<>>>>>>>[<<<<<<<<[>>>>>>+>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]>[-]++++++++++<<+<<<<<<+>>>>>>>>>>>[-]<<<<<[>>>+>>+<<<<<-]>>>>>[<<<<<+>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<->>->>>[-]<<<<<[>>>+>>+<<<<<-]>>>>>[<<<<<+>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>]<<<<[-]+<[>[-]<[-]]>[[-]+>[<[-]>[-]]<[<<<<<<<[-]<+>>>>>>>>[-]]><[-]]<<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]>[-]++++++++++>>>[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<->>>->>>[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>]<<<<[-]+<<[>>[-]<<[-]]>>[[-]+>[<[-]>[-]]<[<<<<<<<<[-]<+>>>>>>>>>[-]]><[-]]<<<<<<<<<++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++.>>>>>>>>[-]]

Bạc hà

Vì không ai khác làm ......

IDENTIFICATION DIVISION.
PROGRAM-ID.  WriteDemo.
AUTHOR.  Mark Mullin.
* Hey, I don't even have a cobol compiler

ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
    SELECT StudentFile ASSIGN TO "STUDENTS.DAT"
        ORGANIZATION IS LINE SEQUENTIAL.

DATA DIVISION.
FILE SECTION.
FD TestFile.
01 TestData.
   02  LineNum        PIC X.
   02  LineText       PIC X(72).

PROCEDURE DIVISION.
Begin.
    OPEN OUTPUT TestFile
    DISPLAY "This language is still around."

    PERFORM GetFileDetails
    PERFORM UNTIL TestData = SPACES
       WRITE TestData 
       PERFORM GetStudentDetails
    END-PERFORM
    CLOSE TestFile
    STOP RUN.

GetFileDetails.
    DISPLAY "Enter - Line number, some text"
    DISPLAY "NXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
    ACCEPT  TestData.

Haskell

main :: IO ()
main = let filePath = "fileio.txt" in
       do writeFile filePath "hello"
          appendFile filePath "\nworld"
          fileLines <- readFile filePath
          let secondLine = (lines fileLines) !! 1
          putStrLn secondLine

Nếu bạn chỉ muốn đọc / ghi một tập tin:

main :: IO ()
main = readFile "somefile.txt" >>= writeFile "someotherfile.txt" 

D

module d_io;

import std.stdio;


void main()
{
    auto f = File("fileio.txt", "w");
    f.writeln("hello");
    f.writeln("world");

    f.open("fileio.txt", "r");
    f.readln;
    auto s = f.readln;
    writeln(s);
}

Hồng ngọc

PATH = 'fileio.txt'
File.open(PATH, 'w') { |file| file.puts "hello" }
File.open(PATH, 'a') { |file| file.puts "world" }
puts line = File.readlines(PATH).last

C #

string path = "fileio.txt";
File.WriteAllLines(path, new[] { "hello"}); //Will end it with Environment.NewLine
File.AppendAllText(path, "world");

string secondLine = File.ReadLines(path).ElementAt(1);
Console.WriteLine(secondLine);

File.ReadLines(path).ElementAt(1)chỉ là .Net 4.0, thay thế là File.ReadAllLines(path)[1]phân tích toàn bộ tệp thành một mảng.

AN C

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

int /*ARGSUSED*/
main(char *argv[0], int argc) {
   FILE *file;
   char buf[128];

   if (!(file = fopen("fileio.txt", "w")) {
      perror("couldn't open for writing fileio.txt");
      exit(1);
   }

   fprintf(file, "hello");
   fclose(file);

   if (!(file = fopen("fileio.txt", "a")) {
      perror("couldn't opened for appening fileio.txt");
      exit(1);
   }

   fprintf(file, "\nworld");
   fclose(file);

   if (!(file = fopen("fileio.txt", "r")) {
      perror("couldn't open for reading fileio.txt");
      exit(1);
   }

   fgets(buf, sizeof(buf), file);
   fgets(buf, sizeof(buf), file);

   fclose(file);

   puts(buf);

   return 0;
}

Shell Script (UNIX)

#!/bin/sh
echo "hello" > fileio.txt
echo "world" >> fileio.txt
LINE=`sed -ne2p fileio.txt`
echo $LINE

Trên thực tế, sed -n "2p"phần này in dòng thứ hai, nhưng câu hỏi yêu cầu dòng thứ hai được lưu trữ trong một biến và sau đó được in, vì vậy ... :)

Trình biên dịch x86 (NASM) trên Linux

Tôi đã không chạm vào asm trong 7 năm, vì vậy tôi đã phải sử dụng google một chút để hack cái này cùng nhau, nhưng nó vẫn hoạt động;) Tôi biết nó không đúng 100%, nhưng hey: D

OK, nó không hoạt động. xin lỗi vì điều này trong khi worldcuối cùng nó in, nó không in nó từ tệp, mà từ ecxđó được đặt trên dòng 27.

section .data
hello db 'hello',10
helloLen equ $-hello
world db 'world',10
worldLen equ $-world
helloFile db 'hello.txt'

section .text
global _start

_start:
mov eax,8
mov ebx,helloFile
mov ecx,00644Q
int 80h

mov ebx,eax

mov eax,4
mov ecx, hello
mov edx, helloLen
int 80h

mov eax,4
mov ecx, world
mov edx, worldLen
int 80h

mov eax,6
int 80h

mov eax,5
mov ebx,helloFile
int 80h

mov eax,3
int 80h

mov eax,4
mov ebx,1
int 80h

xor ebx,ebx
mov eax,1
int 80h

Tài liệu tham khảo được sử dụng: http://www.cin.ufpe.br/~if817/arquivos/asmtut/quickstart.html

http://bluemaster.iu.hio.no/edu/dark/lin-asm/syscalls.html

http://www.digilife.be/quickreferences/QRC/LINEUX%20System%20Call%20Quick%20Reference.pdf

JavaScript - node.js

Đầu tiên, rất nhiều cuộc gọi lại lồng nhau.

var fs   = require("fs");
var sys  = require("sys");
var path = "fileio.txt";

fs.writeFile(path, "hello", function (error) {
    fs.open(path, "a", 0666, function (error, file) {
        fs.write(file, "\nworld", null, "utf-8", function () {
            fs.close(file, function (error) {
                fs.readFile(path, "utf-8", function (error, data) {
                    var lines = data.split("\n");
                    sys.puts(lines[1]);
                });
            });
        });
    });
});

Dọn dẹp hơn một chút:

var writeString = function (string, nextAction) {
    fs.writeFile(path, string, nextAction);
};

var appendString = function (string, nextAction) {
    return function (error, file) {
        fs.open(path, "a", 0666, function (error, file) {
            fs.write(file, string, null, "utf-8", function () {
                fs.close(file, nextAction);
            });
        });
    };
};

var readLine = function (index, nextAction) {
    return function (error) {
        fs.readFile(path, "utf-8", function (error, data) {
            var lines = data.split("\n");
            nextAction(lines[index]);
        });
    };
};

var writeToConsole = function (line) {
    sys.puts(line);
};

writeString("hello", appendString("\nworld", readLine(1, writeToConsole)));

Lisp thường gặp

(defun main ()
  (with-open-file (s "fileio.txt" :direction :output :if-exists :supersede)
    (format s "hello"))
  (with-open-file (s "fileio.txt" :direction :io :if-exists :append)
    (format s "~%world")
    (file-position s 0)
    (loop repeat 2 for line = (read-line s nil nil) finally (print line))))

PowerShell

sc fileio.txt 'hello'
ac fileio.txt 'world'
$line = (gc fileio.txt)[1]
$line

Shell Script

Đây là một tập lệnh shell chỉ sử dụng các lệnh dựng sẵn, thay vì gọi các lệnh bên ngoài như sedhoặc tailnhư các phản hồi trước đó đã thực hiện.

#!/bin/sh

echo hello > fileio.txt             # Print "hello" to fileio.txt
echo world >> fileio.txt            # Print "world" to fileio.txt, appending
                                    # to what is already there
{ read input; read input; } < fileio.txt  
                                    # Read the first two lines of fileio.txt,
                                    # storing the second in $input
echo $input                         # Print the contents of $input

Khi viết các kịch bản shell quan trọng, nên sử dụng các nội dung càng nhiều càng tốt, vì sinh ra một quy trình riêng biệt có thể bị chậm; từ một thử nghiệm nhanh trên máy của tôi, sedgiải pháp chậm hơn khoảng 20 lần so với sử dụng read. Nếu bạn sẽ gọi sedmột lần, như trong trường hợp này, điều đó thực sự không quan trọng lắm, vì nó sẽ thực thi nhanh hơn bạn có thể nhận thấy, nhưng nếu bạn sẽ thực hiện nó hàng trăm hoặc hàng nghìn lần, thì có thể thêm vào.

Đối với những người không quen với cú pháp {và } thực hiện một danh sách các lệnh trong môi trường shell hiện tại (trái ngược với (và )tạo ra một lớp con; chúng ta cần phải hoạt động trong môi trường shell hiện tại, vì vậy chúng ta có thể sử dụng giá trị của biến sau) . Chúng ta cần nhóm các lệnh lại với nhau để cả hai cùng hoạt động trên cùng một luồng đầu vào, được tạo bằng cách chuyển hướng từ fileio.txt; Nếu chúng ta chỉ đơn giản chạy read < fileio.txt; read input < fileio.txt, chúng ta sẽ chỉ nhận được dòng đầu tiên, vì tệp sẽ được đóng và mở lại giữa hai lệnh. Do một cú pháp riêng của cú pháp shell ( {và }là các từ dành riêng, trái ngược với siêu ký tự), chúng ta cần tách {và}từ phần còn lại của các lệnh có khoảng trắng và chấm dứt danh sách các lệnh bằng a ;.

Các readBUILTIN mất như một cuộc tranh cãi những cái tên của các biến để đọc vào. Nó tiêu thụ một dòng đầu vào, phá vỡ đầu vào bằng khoảng trắng (về mặt kỹ thuật, nó phá vỡ nó theo nội dung $IFS, mặc định cho một ký tự khoảng trắng , trong đó một ký tự khoảng trắng có nghĩa là phân chia nó trên bất kỳ khoảng trắng , tab hoặc dòng mới nào), gán mỗi từ cho các tên biến được đưa ra theo thứ tự và gán phần còn lại của dòng cho biến cuối cùng. Vì chúng tôi chỉ cung cấp một biến, nên nó chỉ đặt toàn bộ dòng trong biến đó. Chúng tôi sử dụng lại $inputbiến, vì chúng tôi không quan tâm đến dòng đầu tiên (nếu chúng tôi sử dụng Bash, chúng tôi không thể cung cấp tên biến, nhưng để có thể mang theo, bạn phải luôn cung cấp ít nhất một tên).

Lưu ý rằng trong khi bạn có thể đọc từng dòng một, như tôi làm ở đây, một mẫu phổ biến hơn nhiều sẽ là bọc nó trong một vòng lặp while:

while read foo bar baz
do
  process $foo $bar $baz
done < input.txt

Clojure

(use '[clojure.java.io :only (reader)])

(let [file-name "fileio.txt"]
  (spit file-name "hello")
  (spit file-name "\nworld" :append true)
  (println (second (line-seq (reader file-name)))))

Hoặc tương tự, sử dụng macro phân luồng ->(còn được gọi là loại bỏ paren):

(use '[clojure.java.io :only (reader)])

(let [file-name "fileio.txt"] 
  (spit file-name "hello") 
  (spit file-name "\nworld" :append true) 
  (-> file-name reader line-seq second println))

F #

let path = "fileio.txt"
File.WriteAllText(path, "hello")
File.AppendAllText(path, "\nworld")

let secondLine = File.ReadLines path |> Seq.nth 1
printfn "%s" secondLine

CĂN BẢN

Tôi đã không sử dụng BASIC trong gần 10 năm, nhưng câu hỏi này đã cho tôi một lý do để nhanh chóng nắm bắt kiến ​​thức của mình. :)

OPEN "fileio.txt" FOR OUTPUT AS 1
PRINT #1, "hello"
PRINT #1, "world"
CLOSE 1

OPEN "fileio.txt" FOR INPUT AS 1
LINE INPUT #1, A$
LINE INPUT #1, A$
CLOSE 1

PRINT A$

Mục tiêu-C

NSFileHandle *fh = [NSFileHandle fileHandleForUpdatingAtPath:@"fileio.txt"];

[[NSFileManager defaultManager] createFileAtPath:@"fileio.txt" contents:nil attributes:nil];

[fh writeData:[@"hello" dataUsingEncoding:NSUTF8StringEncoding]];
[fh writeData:[@"\nworld" dataUsingEncoding:NSUTF8StringEncoding]];

NSArray *linesInFile = [[[NSString stringWithContentsOfFile:@"fileio.txt" 
                                             encoding:NSUTF8StringEncoding 
                                                error:nil] stringByStandardizingPath] 
                          componentsSeparatedByString:@"\n"];

NSLog(@"%@", [linesInFile objectAtIndex:1]);

Perl

#!/usr/bin/env perl

use 5.10.0;
use utf8;
use strict;
use autodie;
use warnings qw<  FATAL all     >;
use open     qw< :std  :utf8    >;

use English  qw< -no_match_vars >;

# and the last shall be first
END { close(STDOUT) }

my $filename = "fileio.txt";
my($handle, @lines);

$INPUT_RECORD_SEPARATOR = $OUTPUT_RECORD_SEPARATOR = "\n";

open($handle, ">",  $filename);
print $handle "hello";
close($handle);

open($handle, ">>", $filename);
print $handle "world";
close($handle);

open($handle, "<",  $filename);
chomp(@lines = <$handle>);
close($handle);

print STDOUT $lines[1];

R:

mèo ("xin chào \ n", file = "fileio.txt")
con mèo ("world \ n", file = "fileio.txt", append = TRUE)
dòng2 = readLines ("fileio.txt", n = 2) [2]
mèo (dòng2)

PHP

<?php

$filePath = "fileio.txt";

file_put_contents($filePath, "hello");
file_put_contents($filePath, "\nworld", FILE_APPEND);

$lines = file($filePath);

echo $lines[1];

// closing PHP tags are bad practice in PHP-only files, don't use them

Java

import java.io.*;
import java.util.*;

class Test {
  public static void  main(String[] args) throws IOException {
    String path = "fileio.txt";
    File file = new File(path);

    //Creates New File...
    try (FileOutputStream fout = new FileOutputStream(file)) {
      fout.write("hello\n".getBytes());
    }

    //Appends To New File...
    try (FileOutputStream fout2 = new FileOutputStream(file,true)) {
      fout2.write("world\n".getBytes());
    }

    //Reading the File...
    try (BufferedReader fin = new BufferedReader(new FileReader(file))) {
      fin.readLine();
      System.out.println(fin.readLine());
    }       
  }
}

C ++

#include <limits>
#include <string>
#include <fstream>
#include <iostream>

int main() {
    std::fstream file( "fileio.txt",
        std::ios::in | std::ios::out | std::ios::trunc  );
    file.exceptions( std::ios::failbit );   

    file << "hello\n" // << std::endl, not \n, if writing includes flushing
         << "world\n";

    file.seekg( 0 )
        .ignore( std::numeric_limits< std::streamsize >::max(), '\n' );
    std::string input_string;
    std::getline( file, input_string );

    std::cout << input_string << '\n';
}

hoặc hơi ít về mặt giáo dục,

#include <string>
#include <fstream>
#include <iostream>
using namespace std;

int main() {
    fstream file( "fileio.txt", ios::in | ios::out | ios::trunc  );
    file.exceptions( ios::failbit );   

    file << "hello" << endl
         << "world" << endl;

    file.seekg( 0 ).ignore( 10000, '\n' );
    string input_string;
    getline( file, input_string );

    cout << input_string << endl;
}

Đi

package main

import (
  "os"
  "bufio"
  "log"
)

func main() {
  file, err := os.Open("fileio.txt", os.O_RDWR | os.O_CREATE, 0666)
  if err != nil {
    log.Exit(err)
  }
  defer file.Close()

  _, err = file.Write([]byte("hello\n"))
  if err != nil {
    log.Exit(err)
  }

  _, err = file.Write([]byte("world\n"))
  if err != nil {
    log.Exit(err)
  }

  // seek to the beginning 
  _, err = file.Seek(0,0)
  if err != nil {
    log.Exit(err)
  }

  bfile := bufio.NewReader(file)
  _, err = bfile.ReadBytes('\n')
  if err != nil {
    log.Exit(err)
  }

  line, err := bfile.ReadBytes('\n')
  if err != nil {
    log.Exit(err)
  }

  os.Stdout.Write(line)
}

Erlang

Có lẽ không phải là Erlang thành ngữ nhất, nhưng:

#!/usr/bin/env escript

main(_Args) ->
  Filename = "fileio.txt",
  ok = file:write_file(Filename, "hello\n", [write]),
  ok = file:write_file(Filename, "world\n", [append]),
  {ok, File} = file:open(Filename, [read]),
  {ok, _FirstLine} = file:read_line(File),
  {ok, SecondLine} = file:read_line(File),
  ok = file:close(File),
  io:format(SecondLine).

Emacs Lisp

Mặc dù một số người nói Emacs chủ yếu là một trình soạn thảo văn bản [1]. Vì vậy, trong khi Emacs Lisp có thể được sử dụng để giải quyết tất cả các loại vấn đề, nó được tối ưu hóa theo nhu cầu của trình soạn thảo văn bản. Vì các trình soạn thảo văn bản (rõ ràng) có các nhu cầu khá cụ thể khi nói đến cách các tệp được xử lý, điều này ảnh hưởng đến chức năng liên quan đến tệp mà Emacs Lisp cung cấp.

Về cơ bản, điều này có nghĩa là Emacs Lisp không cung cấp các chức năng để mở tệp dưới dạng luồng và đọc từng phần một. Tương tự như vậy, bạn không thể thêm vào một tệp mà không tải toàn bộ tệp trước. Thay vào đó, tập tin hoàn toàn [2] đọc vào bộ đệm [3], chỉnh sửa và sau đó lưu lại vào tập tin.

Đối với các tác vụ bắt buộc, bạn sẽ sử dụng Emacs Lisp cho việc này là phù hợp và nếu bạn muốn làm điều gì đó không liên quan đến việc chỉnh sửa các chức năng tương tự có thể được sử dụng.

Nếu bạn muốn nối thêm một tập tin nhiều lần thì điều này đi kèm với một chi phí rất lớn, nhưng có thể như đã trình bày ở đây. Trong thực tế, bạn thường hoàn thành các thay đổi đối với bộ đệm cho dù bằng tay hoặc lập trình trước khi ghi vào tệp (chỉ cần kết hợp hai biểu thức s đầu tiên trong ví dụ bên dưới).

(with-temp-file "file"
  (insert "hello\n"))

(with-temp-file "file"
  (insert-file-contents "file")
  (goto-char (point-max))
  (insert "world\n"))

(with-temp-buffer
  (insert-file-contents "file")
  (next-line)
  (message "%s" (buffer-substring (point) (line-end-position))))

[1] Ít nhất tôi sẽ không đi xa đến mức gọi nó là HĐH; một giao diện người dùng thay thế có, một hệ điều hành không.

[2] Bạn chỉ có thể tải các phần của tệp, nhưng điều này chỉ có thể được chỉ định theo byte.

[3] Bộ đệm vừa là kiểu dữ liệu trong một số trường hợp tương tự như chuỗi cũng như "điều bạn thấy trong khi chỉnh sửa tệp". Trong khi chỉnh sửa bộ đệm được hiển thị trong cửa sổ nhưng bộ đệm không nhất thiết phải hiển thị cho người dùng.

Chỉnh sửa: Nếu bạn muốn xem văn bản được chèn vào bộ đệm, rõ ràng bạn phải làm cho nó hiển thị và ngủ giữa các hành động. Bởi vì Emacs thường chỉ hiển thị lại màn hình khi chờ nhập liệu của người dùng (và ngủ không giống như chờ nhập), bạn cũng phải buộc hiển thị lại. Điều này là cần thiết trong ví dụ này (sử dụng nó thay cho sexp thứ hai); trong thực tế, tôi chưa bao giờ phải sử dụng 'redisplay' dù chỉ một lần - vì vậy, điều này thật xấu xí nhưng ...

(with-current-buffer (generate-new-buffer "*demo*")
  (pop-to-buffer (current-buffer))
  (redisplay)
  (sleep-for 1)
  (insert-file-contents "file")
  (redisplay)
  (sleep-for 1)
  (goto-char (point-max))
  (redisplay)
  (sleep-for 1)
  (insert "world\n")
  (redisplay)
  (sleep-for 1)
  (write-file "file"))

Tập tin Windows Batch - Phiên bản # 2

@echo off
echo hello > fileio.txt
echo world  >> fileio.txt
set /P answer=Insert: 
echo %answer%  >> fileio.txt
for /f "skip=1 tokens=*" %%A in (fileio.txt) do echo %%A

Để giải thích rằng vòng lặp tìm kiếm khủng khiếp cuối cùng, nó giả định rằng chỉ có thế giới hello (newline) trong tệp. Vì vậy, nó chỉ bỏ qua dòng đầu tiên và tiếng vang chỉ thứ hai.

Thay đổi

• 2 - Opps, phải đọc sai các yêu cầu hoặc họ đã thay đổi tôi. Bây giờ đọc dòng cuối cùng từ tập tin

Scala:

Sử dụng thư viện chuẩn:

val path = "fileio.txt"
val fout = new FileWriter(path)
fout write "hello\n"
fout.close()
val fout0 = new FileWriter(path, true)
fout0 write "world\n"
fout0.close() 
val str = Source.fromFile(path).getLines.toSeq(1)
println(str)

Sử dụng Thư viện Scala-ARM của Josh Suereth :

val path = "fileio.txt"
for(fout <- managed(new FileWriter(path))) 
  fout write "hello\n"
for(fout <- managed(new FileWriter(path, true))) 
  fout write "world\n"
val str = Source.fromFile(path).getLines.toSeq(1)
println(str)      

Vì nhiều người đã sử dụng cùng một bộ mô tả tệp để viết hai chuỗi, tôi cũng bao gồm cách đó trong câu trả lời của mình.

Sử dụng thư viện chuẩn:

val path = "fileio.txt"
val fout = new FileWriter(path)
fout write "hello\n"
fout write "world\n"
fout.close()
val str = Source.fromFile(path).getLines.toSeq(1)
println(str)

Sử dụng Thư viện Scala-ARM của Josh Suereth :

val path = "fileio.txt"
for(fout <- managed(new FileWriter(path))){
  fout write "hello\n"
  fout write "world\n"
}
val str = Source.fromFile(path).getLines.toSeq(1)
println(str)

Groovy

new File("fileio.txt").with { 
    write  "hello\n"
    append "world\n"   
    println secondLine = readLines()[1]
}