To musi być powszechne pytanie, które od czasu do czasu mają wszyscy programiści. Jak odczytać wiersz z pliku tekstowego? Wtedy następne pytanie zawsze brzmi: jak to odpisać.

Oczywiście większość z was korzysta z wysokiego poziomu frameworka w codziennym programowaniu (które są dobre w odpowiedziach), ale czasami miło jest wiedzieć, jak to zrobić na niskim poziomie.

Ja wiem, jak to zrobić w C, C++a Objective-C, ale na pewno będzie przydatna, aby zobaczyć jak to się robi we wszystkich popularnych językach, jeśli tylko pomoże nam uczynić lepszą decyzję o tym, co język robić nasz plik IO w. W szczególności Myślę, że to będzie interesujące zobaczyć, jak jej dokonać w ciągu językach manipulacyjnych, takich jak: python, rubyi oczywiście perl.

Więc myślę, że możemy tutaj stworzyć zasób społeczności , do którego wszyscy możemy oznaczyć nasze profile jako gwiazdkę i odwołać się, gdy musimy wykonać operacje we / wy pliku w jakimś nowym języku. Nie wspominając już o znajomości języków, z którymi nie mamy do czynienia na co dzień.

Oto, jak musisz odpowiedzieć:

1. Utwórz nowy plik tekstowy o nazwie „ fileio.txt ”
2. Wpisz pierwszą linię „hello” do pliku tekstowego.
3. Dołącz drugą linię „world” do pliku tekstowego.
4. Wczytaj drugą linię „world” do ciągu wejściowego.
5. Wydrukuj ciąg wejściowy do konsoli.

Wyjaśnienie:

• Powinieneś pokazać, jak to zrobić, tylko w jednym języku programowania na odpowiedź.
• Załóżmy, że plik tekstowy nie istnieje wcześniej
• Nie musisz ponownie otwierać pliku tekstowego po wpisaniu pierwszego wiersza

Brak ograniczeń dotyczących języka. C, C++, C#, Java, Objective-CSą świetne.

Jeśli wiesz, jak to zrobić w Prolog, Haskell, Fortran, Lisp, czy Basicto proszę śmiało.

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

Wyjaśnienia

• readlines () zwraca listę wszystkich wierszy w pliku. Dlatego wywołanie readlines () powoduje wczytanie każdego wiersza pliku. W tym konkretnym przypadku dobrze jest użyć readlines (), ponieważ i tak musimy przeczytać cały plik (chcemy jego ostatniej linii). Ale jeśli nasz plik zawiera wiele wierszy, a chcemy po prostu wydrukować jego n-ty wiersz, nie ma potrzeby czytania całego pliku. Oto kilka lepszych sposobów na pobranie n-tej linii pliku w Pythonie: Co zastępuje xreadlines () w Pythonie 3? .

• O co chodzi z tym stwierdzeniem? Instrukcja with uruchamia blok kodu, w którym można użyć zmiennej f jako obiektu strumienia zwróconego przez wywołanie metody open (). Kiedy kończy się blok with, Python automatycznie wywołuje f.close (). Gwarantuje to, że plik zostanie zamknięty, gdy wyjdziesz z bloku with, bez względu na to, jak lub kiedy wyjdziesz z bloku (nawet jeśli wyjdziesz z niego przez nieobsługiwany wyjątek). Możesz jawnie wywołać f.close (), ale co się stanie, jeśli twój kod zgłosi wyjątek i nie dostaniesz się do wywołania f.close ()? Dlatego przydatne jest wyrażenie with.

• Nie musisz ponownie otwierać pliku przed każdą operacją. Możesz napisać cały kod wewnątrz jednego z blokiem.

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

  Użyłem trzech z blokami, aby podkreślić różnicę między trzema operacjami: zapis (tryb 'w'), dołączenie (tryb 'a'), odczyt (tryb 'r', domyślny).

LOLCODE

Specyfikacje są co najmniej pobieżne, ale zrobiłem, co mogłem. Niech rozpocznie się głosowanie w dół! :) Nadal uważam to za zabawne ćwiczenie.

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

Mózg *** k

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

COBOL

Ponieważ nikt inny tego nie zrobił ......

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

Jeśli chcesz tylko czytać / zapisywać plik:

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

re

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

Rubin

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

DO#

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)to tylko .Net 4.0, alternatywą jest File.ReadAllLines(path)[1]parsowanie całego pliku w tablicę.

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

Skrypt powłoki (UNIX)

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

Właściwie sed -n "2p"część drukuje drugą linię, ale pytanie prosi o zapisanie drugiej linii w zmiennej, a następnie wydrukowanie, więc ... :)

x86 Assembler (NASM) w systemie Linux

Nie tknąłem asm od 7 lat, więc musiałem trochę użyć google, żeby to razem zhakować, ale nadal działa;) Wiem, że to nie jest w 100% poprawne, ale hej: D

OK, to nie działa. przepraszam za to. chociaż drukuje worldna końcu, nie drukuje go z pliku, ale z tego, ecxktóry jest ustawiony w linii 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

Wykorzystane źródła: 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/LINUX%20System%20Call%20Quick%20Reference.pdf

JavaScript - node.js

Po pierwsze, wiele zagnieżdżonych wywołań zwrotnych.

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

Trochę czystsze:

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

Common Lisp

(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

Skrypt powłoki

Oto skrypt powłoki używający tylko poleceń wbudowanych, zamiast wywoływać polecenia zewnętrzne, takie jak sedlub tailtak, jak robiły to poprzednie odpowiedzi.

#!/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

Podczas pisania znaczących skryptów powłoki zaleca się używanie w jak największym stopniu wbudowanych, ponieważ tworzenie oddzielnego procesu może być powolne; z szybkiego testu na moim komputerze, sedrozwiązanie jest około 20 razy wolniejsze niż przy użyciu read. Jeśli zamierzasz zadzwonić sedraz, jak w tym przypadku, nie ma to większego znaczenia, ponieważ wykona to szybciej, niż możesz to zauważyć, ale jeśli zamierzasz wykonać to setki lub tysiące razy, może zsumować.

Dla tych, którzy nie są zaznajomieni ze składnią {i } wykonują listę poleceń w bieżącym środowisku powłoki (w przeciwieństwie do (i )które tworzą podpowłokę; musimy działać w bieżącym środowisku powłoki, abyśmy mogli później użyć wartości zmiennej) . Musimy pogrupować polecenia razem, aby oba działały na tym samym strumieniu wejściowym, utworzonym przez przekierowanie z fileio.txt; gdybyśmy po prostu uruchomili read < fileio.txt; read input < fileio.txt, otrzymalibyśmy po prostu pierwszą linię, ponieważ plik zostałby zamknięty i ponownie otwarty między dwoma poleceniami. Ze względu na specyfikę składni powłoki ( {i }są to słowa zastrzeżone, w przeciwieństwie do metaznaków), musimy oddzielić {i}od pozostałych poleceń spacjami i zakończ listę poleceń za pomocą ;.

readWbudowane bierze jako argument nazwy zmiennych do odczytu w. Zużywa wiersz danych wejściowych, dzieli dane wejściowe na białe znaki (technicznie rzecz biorąc, dzieli je zgodnie z zawartością $IFS, która domyślnie jest znakiem spacji, gdzie znak spacji oznacza podzielenie go na dowolną spację, tabulator lub nową linię), przypisuje każde słowo do nazw zmiennych podanych w kolejności, a pozostałą część wiersza przypisuje ostatniej zmiennej. Ponieważ dostarczamy tylko jedną zmienną, po prostu umieszcza cały wiersz w tej zmiennej. Używamy tej $inputzmiennej ponownie , ponieważ nie obchodzi nas, co znajduje się w pierwszym wierszu (jeśli używamy Bash, nie możemy po prostu podać nazwy zmiennej, ale aby była przenośna, zawsze musisz podać co najmniej jedną nazwę).

Zauważ, że chociaż możesz czytać wiersze pojedynczo, tak jak ja tutaj, znacznie bardziej powszechnym wzorcem byłoby zawinięcie go w pętlę 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)))))

Lub równoważnie, używając makra wątków ->(znanego również jako narzędzie do usuwania nawiasów):

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

FA#

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

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

PODSTAWOWY

Nie używałem BASICa od prawie 10 lat, ale to pytanie dało mi powód do szybkiego odświeżenia wiedzy. :)

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$

Cel 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:

cat ("cześć \ n", file = "fileio.txt")
cat ("świat \ n", plik = "fileio.txt", append = TRUE)
line2 = readLines ("fileio.txt", n = 2) [2]
kot (wiersz 2)

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

Jawa

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

lub nieco mniej pedantycznie,

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

Udać się

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

Chyba nie najbardziej idiomatyczny Erlang, ale:

#!/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

Pomimo tego, co niektórzy mówią, Emacs jest głównie edytorem tekstu [1]. Więc chociaż Emacs Lisp może być używany do rozwiązywania wszelkiego rodzaju problemów, jest on zoptymalizowany pod kątem potrzeb edytora tekstu. Ponieważ edytory tekstu (oczywiście) mają dość specyficzne potrzeby, jeśli chodzi o sposób obsługi plików, wpływa to na to, jakie funkcje związane z plikami oferuje Emacs Lisp.

Zasadniczo oznacza to, że Emacs Lisp nie oferuje funkcji do otwierania pliku jako strumienia i czytania go część po części. Podobnie nie możesz dołączyć do pliku bez uprzedniego załadowania całego pliku. Zamiast tego plik jest w całości [2] wczytywany do bufora [3], edytowany i ponownie zapisywany do pliku.

Do zadań typu „must” użyłbyś Emacs Lisp, ponieważ jest to odpowiednie, a jeśli chcesz zrobić coś, co nie wymaga edycji, możesz użyć tych samych funkcji.

Jeśli chcesz ciągle dołączać do pliku, wiąże się to z ogromnym narzutem, ale jest to możliwe, jak pokazano tutaj. W praktyce zwykle kończysz wprowadzanie zmian w buforze, ręcznie lub programowo, przed zapisaniem do pliku (po prostu połącz pierwsze dwa wyrażenia s w poniższym przykładzie).

(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] Przynajmniej nie posunąłbym się do nazywania go systemem operacyjnym; alternatywny interfejs użytkownika tak, system operacyjny nie.

[2] Możesz załadować tylko części pliku, ale można to określić tylko bajtowo.

[3] Bufor jest zarówno typem danych w pewnym sensie podobnym do łańcucha, jak i „rzeczą, którą widzisz podczas edycji pliku”. Podczas edycji bufor jest wyświetlany w oknie, ale bufory niekoniecznie muszą być widoczne dla użytkownika.

Edycja: Jeśli chcesz zobaczyć tekst wstawiany do bufora, musisz oczywiście uczynić go widocznym i spać między akcjami. Ponieważ Emacs normalnie wyświetla ponownie ekran tylko podczas oczekiwania na wejście użytkownika (a spanie to nie to samo, co oczekiwanie na wejście), musisz także wymusić ponowne wyświetlenie. Jest to konieczne w tym przykładzie (użyj go zamiast drugiego seksu); w praktyce ani razu nie musiałem używać `` redisplay '' - więc tak, to jest brzydkie, ale ...

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

Pliki wsadowe systemu Windows - wersja nr 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

Aby wyjaśnić to ostatnie okropne wyszukiwanie pętli, zakłada się, że w pliku jest tylko świat hello (nowa linia). Więc po prostu pomija pierwszą linię i odbija tylko drugą.

Changelog

• 2 - Ups, musiałem źle odczytać wymagania lub zmieniły się na mnie. Teraz czyta ostatnią linię z pliku

Scala:

Korzystanie z biblioteki standardowej:

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)

Korzystanie z biblioteki Scala-ARM Josha Sueretha :

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)      

Ponieważ wiele osób używa tego samego deskryptora pliku do zapisania dwóch ciągów, uwzględniam to również w mojej odpowiedzi.

Korzystanie z biblioteki standardowej:

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)

Korzystanie z biblioteki Scala-ARM Josha Sueretha :

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]
}