Dies muss eine häufige Frage sein, die alle Programmierer von Zeit zu Zeit haben. Wie lese ich eine Zeile aus einer Textdatei? Dann ist die nächste Frage immer, wie ich es zurückschreibe.

Natürlich verwenden die meisten von Ihnen ein High-Level-Framework für die tägliche Programmierung (das in Antworten gut zu verwenden ist), aber manchmal ist es auch schön zu wissen, wie man es auf niedrigem Level macht.

Ich selbst weiß, wie es gemacht wird C, C++und Objective-C, aber es wäre sicher praktisch zu sehen, wie es in allen gängigen Sprachen gemacht wird, wenn wir nur eine bessere Entscheidung darüber treffen wollen, in welcher Sprache wir unsere Datei io machen sollen. Insbesondere ich denke , es wäre interessant zu sehen , wie seine in den String - Manipulation Sprachen gemacht, wie: python, rubyund natürlich perl.

Also ich hier Abbildung können wir erstellen Community - Ressource , dass wir alle können Sterne in unseren Profilen und verweisen , wenn wir tun müssen , E / A - Datei in einigen der neuen Sprache. Ganz zu schweigen von der Exposition gegenüber Sprachen, mit denen wir uns nicht täglich beschäftigen.

So müssen Sie antworten:

1. Erstellen Sie eine neue Textdatei mit dem Namen " fileio.txt ".
2. Schreiben Sie die erste Zeile "Hallo" in die Textdatei.
3. Hängen Sie die zweite Zeile "Welt" an die Textdatei an.
4. Lesen Sie die zweite Zeile "Welt" in eine Eingabezeichenfolge.
5. Drucken Sie die Eingabezeichenfolge in die Konsole.

Klärung:

• Sie sollten zeigen, wie dies in einer Programmiersprache pro Antwort funktioniert.
• Angenommen, die Textdatei existiert vorher nicht
• Sie müssen die Textdatei nach dem Schreiben der ersten Zeile nicht erneut öffnen

Keine besondere Einschränkung der Sprache. C, C++, C#, Java, Objective-CSind alle großartig.

Wenn Sie wissen , wie es zu tun in Prolog, Haskell, Fortran, Lisp, oder Basicdann bitte rechts weiter gehen.

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)

Klarstellungen

• readlines () gibt eine Liste aller Zeilen in der Datei zurück. Daher führt der Aufruf von readlines () zum Lesen jeder einzelnen Zeile der Datei. In diesem speziellen Fall ist es in Ordnung, readlines () zu verwenden, da wir sowieso die gesamte Datei lesen müssen (wir wollen die letzte Zeile). Wenn unsere Datei jedoch viele Zeilen enthält und wir nur die n-te Zeile drucken möchten, ist es nicht erforderlich, die gesamte Datei zu lesen. Hier sind einige bessere Möglichkeiten, um die n-te Zeile einer Datei in Python abzurufen : Was ersetzt xreadlines () in Python 3? .

• Was ist das mit Aussage? Die with-Anweisung startet einen Codeblock, in dem Sie die Variable f als Stream-Objekt verwenden können, das vom Aufruf von open () zurückgegeben wird. Wenn der with-Block endet, ruft Python f.close () automatisch auf. Dies garantiert, dass die Datei geschlossen wird, wenn Sie den with-Block beenden, egal wie oder wann Sie den Block verlassen (auch wenn Sie ihn über eine nicht behandelte Ausnahme beenden). Sie könnten f.close () explizit aufrufen, aber was ist, wenn Ihr Code eine Ausnahme auslöst und Sie nicht zum Aufruf von f.close () gelangen? Deshalb ist die with-Anweisung nützlich.

• Sie müssen die Datei nicht vor jedem Vorgang erneut öffnen. Sie können den gesamten Code in einen mit Block schreiben.

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

  Ich habe drei mit Blöcken verwendet, um den Unterschied zwischen den drei Operationen hervorzuheben: Schreiben (Modus 'w'), Anhängen (Modus 'a'), Lesen (Modus 'r', Standardeinstellung).

LOLCODE

Die Spezifikationen sind gelinde gesagt lückenhaft , aber ich habe mein Bestes gegeben. Lass das Downvoting beginnen! :) Ich finde es immer noch eine lustige Übung.

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

Gehirn *** k

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

COBOL

Da hat sonst niemand ......

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

Wenn Sie nur eine Datei lesen / schreiben möchten:

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

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

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)ist nur .NET 4.0, die Alternative besteht darin File.ReadAllLines(path)[1], die gesamte Datei in ein Array zu analysieren.

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

Shell-Skript (UNIX)

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

Eigentlich sed -n "2p"druckt der Teil die zweite Zeile, aber die Frage fragt, ob die zweite Zeile in einer Variablen gespeichert und dann gedruckt werden soll, also ... :)

x86 Assembler (NASM) unter Linux

Ich habe asm seit 7 Jahren nicht mehr berührt, also musste ich ein bisschen Google verwenden, um dies zusammen zu hacken, aber es funktioniert trotzdem;) Ich weiß, dass es nicht 100% korrekt ist, aber hey: D.

OK, es funktioniert nicht. Entschuldigung. Während es worldam Ende druckt, druckt es es nicht aus der Datei, sondern aus der ecxin Zeile 27 festgelegten.

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

Verwendete Referenzen: 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

Erstens viele verschachtelte Rückrufe.

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

Ein bisschen sauberer:

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

Power Shell

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

Shell-Skript

Hier ist ein Shell - Skript nur gebautet Befehle, anstatt Berufung auf externe Befehle wie sedoder tailwie in früheren Antworten getan haben.

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

Wenn Sie wichtige Shell-Skripte schreiben, ist es ratsam, so viele integrierte Funktionen wie möglich zu verwenden, da das Erstellen eines separaten Prozesses langsam sein kann. Nach einem kurzen Test auf meinem Computer ist die sedLösung etwa 20-mal langsamer als die Verwendung read. Wenn Sie sedeinmal anrufen , wie in diesem Fall, spielt es keine große Rolle, da es schneller ausgeführt wird, als Sie bemerken können, aber wenn Sie es hunderte oder tausende Male ausführen, kann es addieren.

Für diejenigen, die mit der Syntax nicht vertraut sind {und } eine Liste von Befehlen in der aktuellen Shell-Umgebung ausführen (im Gegensatz zu (und )die eine Subshell erstellen; wir müssen in der aktuellen Shell-Umgebung arbeiten, damit wir den Wert der Variablen später verwenden können). . Wir müssen die Befehle zusammenfassen, damit beide mit demselben Eingabestream arbeiten, der durch Umleiten von erstellt wurde fileio.txt. Wenn wir einfach laufen würden read < fileio.txt; read input < fileio.txt, würden wir nur die erste Zeile erhalten, da die Datei zwischen den beiden Befehlen geschlossen und wieder geöffnet würde. Aufgrund einer Eigenart der Shell-Syntax ( {und }sind reservierte Wörter im Gegensatz zu Metazeichen) müssen wir das {und trennen}aus dem Rest der Befehle mit Leerzeichen und beenden Sie die Liste der Befehle mit a ;.

Das readeingebaute Argument verwendet die Namen der Variablen, in die eingelesen werden soll. Es verbraucht eine Eingabezeile, unterbricht die Eingabe durch Leerzeichen (technisch gesehen unterbricht es sie gemäß dem Inhalt von $IFS, wobei standardmäßig ein Leerzeichen verwendet wird, wobei ein Leerzeichen bedeutet, dass es in ein beliebiges Leerzeichen, eine Registerkarte oder eine neue Zeile aufgeteilt wird) jedes Wort den Variablennamen in der angegebenen Reihenfolge und ordnet den Rest der Zeile der letzten Variablen zu. Da wir nur eine Variable angeben, wird nur die gesamte Zeile in diese Variable eingefügt. Wir verwenden die $inputVariable wieder, da es uns egal ist, was in der ersten Zeile steht (wenn wir Bash verwenden, können wir einfach keinen Variablennamen angeben, aber um portabel zu sein, müssen Sie immer mindestens einen Namen angeben).

Beachten Sie, dass Sie zwar wie ich hier Zeilen nacheinander lesen können, ein viel häufigeres Muster jedoch darin besteht, sie in eine while-Schleife zu packen:

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

Oder gleichwertig mit dem Threading-Makro ->(auch als Paren-Entferner bezeichnet):

(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

BASIC

Ich habe BASIC seit fast 10 Jahren nicht mehr verwendet, aber diese Frage gab mir einen Grund, mein Wissen schnell aufzufrischen. :) :)

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$

Ziel 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 ("Hallo \ n", file = "fileio.txt")
cat ("world \ n", file = "fileio.txt", append = TRUE)
line2 = readLines ("fileio.txt", n = 2) [2]
Katze (Zeile 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

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

oder etwas weniger pedantisch,

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

Gehen

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

Wahrscheinlich nicht der idiomatischste Erlang, aber:

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

Trotz allem, was manche Leute sagen, ist Emacs hauptsächlich ein Texteditor [1]. Während Emacs Lisp zur Lösung aller Arten von Problemen verwendet werden kann, ist es für die Anforderungen eines Texteditors optimiert. Da Texteditoren (offensichtlich) ganz bestimmte Anforderungen an den Umgang mit Dateien haben, wirkt sich dies auf die dateibezogenen Funktionen von Emacs Lisp aus.

Grundsätzlich bedeutet dies, dass Emacs Lisp keine Funktionen zum Öffnen und teilweisen Lesen einer Datei als Stream bietet. Ebenso können Sie keine Datei anhängen, ohne zuerst die gesamte Datei zu laden. Stattdessen wird die Datei vollständig [2] in einen Puffer [3] eingelesen, bearbeitet und dann erneut in einer Datei gespeichert.

Für Pflichtaufgaben, für die Sie Emacs Lisp verwenden würden, ist dies geeignet. Wenn Sie etwas tun möchten, bei dem nicht dieselben Funktionen bearbeitet werden müssen, können Sie diese verwenden.

Wenn Sie immer wieder an eine Datei anhängen möchten, ist dies mit einem enormen Overhead verbunden, der jedoch wie hier gezeigt möglich ist. In der Praxis nehmen Sie normalerweise manuell oder programmgesteuert Änderungen an einem Puffer vor, bevor Sie in eine Datei schreiben (kombinieren Sie einfach die ersten beiden S-Ausdrücke im folgenden Beispiel).

(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] Zumindest würde ich nicht so weit gehen, es als Betriebssystem zu bezeichnen. eine alternative Benutzeroberfläche ja, ein Betriebssystem nein.

[2] Sie können nur Teile einer Datei laden, dies kann jedoch nur byteweise angegeben werden.

[3] Ein Puffer ist sowohl ein Datentyp, der einer Zeichenfolge ähnlich ist, als auch das "Ding, das Sie beim Bearbeiten einer Datei sehen". Während der Bearbeitung wird ein Puffer in einem Fenster angezeigt, aber Puffer müssen nicht unbedingt für den Benutzer sichtbar sein.

Bearbeiten: Wenn Sie möchten, dass der Text in den Puffer eingefügt wird, müssen Sie ihn offensichtlich sichtbar machen und zwischen den Aktionen schlafen. Da Emacs den Bildschirm normalerweise nur beim Anzeigen auf Benutzereingaben erneut anzeigt (und das Schlafen nicht mit dem Warten auf Eingaben identisch ist), müssen Sie auch die erneute Anzeige erzwingen. Dies ist in diesem Beispiel erforderlich (verwenden Sie es anstelle des zweiten Geschlechts). in der Praxis musste ich "redisplay" nicht einmal verwenden - also ja, das ist hässlich, aber ...

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

Windows-Batchdateien - Version 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

Um diese letzte schreckliche Suchschleife zu erklären, wird davon ausgegangen, dass die Datei nur eine Hallo-Welt (Newline) enthält. Es wird also nur die erste Zeile übersprungen und nur die zweite wiedergegeben.

Änderungsprotokoll

• 2 - Opps, müssen die Anforderungen falsch verstanden haben oder sie haben sich an mir geändert. Liest jetzt die letzte Zeile aus der Datei

Scala:

Standardbibliothek verwenden:

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)

Verwenden der Scala-ARM-Bibliothek von 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)      

Da viele Leute denselben Dateideskriptor zum Schreiben der beiden Zeichenfolgen verwendet haben, beziehe ich dies auch in meine Antwort ein.

Standardbibliothek verwenden:

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)

Verwenden der Scala-ARM-Bibliothek von 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]
}