Cela doit être une question commune que tous les programmeurs se posent de temps en temps. Comment lire une ligne d'un fichier texte? Ensuite, la question suivante est toujours de savoir comment l'écrire.

Bien sûr, la plupart d'entre vous utilisent un cadre de haut niveau dans la programmation quotidienne (ce qui est bien à utiliser dans les réponses) mais parfois il est bon de savoir comment le faire à un niveau bas aussi.

Je sais moi-même comment le faire dans C, C++et Objective-C, mais il serait certainement utile de voir comment cela se fait dans toutes les langues populaires, ne serait-ce que pour nous aider à prendre une meilleure décision sur la langue dans laquelle créer notre fichier io. En particulier Je pense qu'il serait intéressant de voir comment son fait dans les langues de manipulation de chaîne, comme: python, rubyet bien sûr perl.

Je pense donc que nous pouvons créer une ressource communautaire à laquelle nous pouvons tous mettre en vedette nos profils et à laquelle nous nous référons lorsque nous devons effectuer des E / S de fichiers dans une nouvelle langue. Sans parler de l'exposition que nous aurons tous à des langues que nous ne traitons pas quotidiennement.

Voici comment vous devez répondre:

1. Créez un nouveau fichier texte appelé " fileio.txt "
2. Écrivez la première ligne "bonjour" dans le fichier texte.
3. Ajoutez la deuxième ligne «monde» au fichier texte.
4. Lisez la deuxième ligne "monde" dans une chaîne d'entrée.
5. Imprimez la chaîne d'entrée sur la console.

Clarification:

• Vous devez montrer comment faire cela dans un seul langage de programmation par réponse.
• Supposons que le fichier texte n'existe pas au préalable
• Vous n'avez pas besoin de rouvrir le fichier texte après avoir écrit la première ligne

Aucune limite particulière sur la langue. C, C++, C#, Java, Objective-CSont tous excellents.

Si vous savez comment le faire dans Prolog, Haskell, Fortran, Lispou Basicalors s'il vous plaît allez - y.

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)

Clarifications

• readlines () renvoie une liste de toutes les lignes du fichier. Par conséquent, l'invocation de readlines () entraîne la lecture de chaque ligne du fichier. Dans ce cas particulier, il est bien d'utiliser readlines () car nous devons quand même lire le fichier entier (nous voulons sa dernière ligne). Mais si notre fichier contient de nombreuses lignes et que nous voulons simplement imprimer sa nième ligne, il est inutile de lire le fichier entier. Voici quelques meilleures façons d'obtenir la nième ligne d'un fichier en Python: Qu'est - ce qui remplace xreadlines () dans Python 3? .

• Qu'est-ce que c'est avec déclaration? L'instruction with démarre un bloc de code dans lequel vous pouvez utiliser la variable f comme objet de flux renvoyé par l'appel à open (). Lorsque le bloc with se termine, python appelle automatiquement f.close (). Cela garantit que le fichier sera fermé lorsque vous quitterez le bloc with, peu importe comment ou quand vous quittez le bloc (même si vous le quittez via une exception non gérée). Vous pouvez appeler f.close () explicitement, mais que faire si votre code lève une exception et que vous n'obtenez pas l'appel à f.close ()? C'est pourquoi l'instruction with est utile.

• Vous n'avez pas besoin de rouvrir le fichier avant chaque opération. Vous pouvez écrire tout le code à l'intérieur d'un avec block.

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

  J'en ai utilisé trois avec des blocs pour illustrer la différence entre les trois opérations: write (mode 'w'), append (mode 'a'), read (mode 'r', la valeur par défaut).

LOLCODE

Les spécifications sont pour le moins fragmentaires, mais j'ai fait de mon mieux. Que le vote négatif commence! :) Je trouve toujours que c'est un exercice amusant.

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

Cerveau *** k

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

COBOL

Puisque personne d'autre ne l'a fait ......

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

Si vous souhaitez simplement lire / écrire un fichier:

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

ré

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

Rubis

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)est .Net 4.0 uniquement, l'alternative est d' File.ReadAllLines(path)[1]analyser le fichier entier dans un tableau.

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

Script de shell (UNIX)

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

En fait, la sed -n "2p"pièce imprime la deuxième ligne, mais la question demande que la deuxième ligne soit stockée dans une variable puis imprimée, donc ... :)

Assembleur x86 (NASM) sous Linux

Je n'ai pas touché asm depuis 7 ans, j'ai donc dû utiliser un peu google pour pirater cela ensemble, mais ça marche quand même;) Je sais que ce n'est pas correct à 100%, mais bon: D

OK, ça ne marche pas. désolé pour ça. bien qu'il imprime worldà la fin, il ne l'imprime pas à partir du fichier, mais à partir de celui ecxqui est défini à la ligne 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

Références utilisées: 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

Tout d'abord, de nombreux rappels imbriqués.

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

Un peu plus propre:

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

Script de Shell

Voici un script shell utilisant uniquement des commandes intégrées, plutôt que d'appeler des commandes externes telles que sedou tailcomme l'ont fait les réponses précédentes.

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

Lors de l'écriture de scripts shell importants, il est conseillé d'utiliser autant que possible les fonctions intégrées, car la création d'un processus séparé peut être lente; à partir d'un test rapide sur ma machine, la sedsolution est environ 20 fois plus lente que l'utilisation read. Si vous appelez sedune fois, comme dans ce cas, cela n'a pas vraiment d'importance, car il s'exécutera plus rapidement que vous ne pouvez le remarquer, mais si vous allez l'exécuter des centaines ou des milliers de fois, il peut additionner.

Pour ceux qui ne connaissent pas la syntaxe, {et } exécutez une liste de commandes dans l'environnement shell actuel (par opposition à (et )qui créent un sous-shell; nous devons fonctionner dans l'environnement shell actuel, nous pouvons donc utiliser la valeur de la variable plus tard) . Nous devons regrouper les commandes afin qu'elles fonctionnent toutes les deux sur le même flux d'entrée, créé en redirigeant à partir de fileio.txt; si nous exécutions simplement read < fileio.txt; read input < fileio.txt, nous obtiendrions simplement la première ligne, car le fichier serait fermé et rouvert entre les deux commandes. En raison d'une idiosyncrasie de la syntaxe du shell ( {et }sont des mots réservés, par opposition aux métacaractères), nous devons séparer les {et}à partir du reste des commandes avec des espaces, et terminez la liste des commandes avec un ;.

L' readintégré prend comme argument les noms des variables à lire. Il consomme une ligne d'entrée, rompt l'entrée par un espace (techniquement, il le rompt en fonction du contenu de $IFS, qui par défaut est un caractère d'espace, où un caractère d'espace signifie le diviser sur n'importe quel espace, tabulation ou nouvelle ligne), assigne chaque mot aux noms de variables donnés dans l'ordre, et affecte le reste de la ligne à la dernière variable. Étant donné que nous ne fournissons qu'une seule variable, cela met simplement toute la ligne dans cette variable. Nous réutilisons la $inputvariable, car nous ne nous soucions pas de ce qui se trouve sur la première ligne (si nous utilisons Bash, nous ne pourrions tout simplement pas fournir un nom de variable, mais pour être portable, vous devez toujours fournir au moins un nom).

Notez que même si vous pouvez lire les lignes une à la fois, comme je le fais ici, un modèle beaucoup plus courant serait de l'envelopper dans une boucle 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)))))

Ou de manière équivalente, en utilisant la macro de threading ->(également connue sous le nom de paren Remover):

(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

DE BASE

Je n'ai pas utilisé BASIC depuis près de 10 ans, mais cette question m'a donné une raison de rafraîchir rapidement mes connaissances. :)

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$

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

chat ("bonjour \ n", file = "fileio.txt")
cat ("monde \ n", fichier = "fileio.txt", append = TRUE)
line2 = readLines ("fileio.txt", n = 2) [2]
chat (ligne2)

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

ou un peu moins pédantiquement,

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

Aller

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

Probablement pas l'Erlang le plus idiomatique, mais:

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

Malgré ce que certains disent, Emacs est principalement un éditeur de texte [1]. Ainsi, alors qu'Emacs Lisp peut être utilisé pour résoudre toutes sortes de problèmes, il est optimisé pour les besoins d'un éditeur de texte. Étant donné que les éditeurs de texte ont (évidemment) des besoins assez spécifiques en ce qui concerne la manière dont les fichiers sont traités, cela affecte les fonctionnalités liées aux fichiers qu'offre Emacs Lisp.

Fondamentalement, cela signifie qu'Emacs Lisp n'offre pas de fonctions pour ouvrir un fichier en tant que flux, et le lire partie par partie. De même, vous ne pouvez pas ajouter à un fichier sans charger d'abord le fichier entier. Au lieu de cela, le fichier est complètement [2] lu dans un tampon [3], édité puis sauvegardé à nouveau dans un fichier.

Pour les tâches incontournables, vous utiliseriez Emacs Lisp car cela convient et si vous voulez faire quelque chose qui n'implique pas l'édition, les mêmes fonctions peuvent être utilisées.

Si vous souhaitez ajouter à un fichier encore et encore, cela entraîne une surcharge énorme, mais c'est possible comme illustré ici. En pratique, vous terminez normalement d'apporter des modifications à un tampon, que ce soit manuellement ou par programme avant d'écrire dans un fichier (combinez simplement les deux premières expressions s dans l'exemple ci-dessous).

(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] Au moins, je n'irais pas jusqu'à l'appeler un OS; une interface utilisateur alternative oui, un OS non.

[2] Vous ne pouvez charger que des parties d'un fichier, mais cela ne peut être spécifié que par octet.

[3] Un tampon est à la fois un type de données en quelque sorte similaire à une chaîne ainsi que la "chose que vous voyez lors de l'édition d'un fichier". Lors de l'édition, un tampon est affiché dans une fenêtre, mais les tampons ne doivent pas nécessairement être visibles pour l'utilisateur.

Modifier: si vous voulez voir le texte inséré dans le tampon, vous devez évidemment le rendre visible et dormir entre les actions. Étant donné qu'Emacs ne réaffiche normalement l'écran que lorsqu'il attend l'entrée de l'utilisateur (et que le sommeil n'est pas la même chose que l'attente d'une entrée), vous devez également forcer le réaffichage. Ceci est nécessaire dans cet exemple (utilisez-le à la place du second sexp); dans la pratique, je n'ai jamais eu à utiliser `redisplay 'ne serait-ce qu'une seule fois - donc oui, c'est moche mais ...

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

Fichiers batch Windows - 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

Pour expliquer cette dernière horrible boucle de recherche, il suppose qu'il n'y a que le monde bonjour (nouvelle ligne) dans le fichier. Donc, il saute simplement la première ligne et ne fait écho qu'à la seconde.

Changelog

• 2 - Opps, faut de mal lire les exigences ou elles ont changé sur moi. Lit maintenant la dernière ligne du fichier

Scala:

Utilisation de la bibliothèque standard:

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)

Utilisation de la bibliothèque Scala-ARM de 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)      

Étant donné que de nombreuses personnes ont utilisé le même descripteur de fichier pour écrire les deux chaînes, j'inclus également de cette façon dans ma réponse.

Utilisation de la bibliothèque standard:

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)

Utilisation de la bibliothèque Scala-ARM de 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)

Sensationnel

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