E / S de fichier dans chaque langage de programmation [fermé]

127

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.

Brock Woolf
la source
9
Le problème avec ceci est qu'il n'apparaîtra pas dans les recherches pour une langue spécifique car ce n'est pas, ni ne peut être, étiqueté avec chaque langue.
ChrisF
21
Je ne comprends pas pourquoi cette question est close. Le but de ce site n'est-il pas d'aider les gens à trouver des informations? Si quelqu'un sait comment faire quelque chose (comme IO) en C, et veut apprendre à faire la même chose en Python, cela pourrait l'aider en lui permettant de voir les deux côte à côte.
Slapout
18
Je ne comprends pas non plus pourquoi cela est fermé. Il semble que ce soit simplement parce qu'il n'inclut pas les mots "... dans le moindre nombre de caractères ...", ce qui est assez idiot. Le code golf est un exercice amusant. Mais est-il vraiment utile de faire en sorte que toutes les questions de la pierre de rosette aient obscurci un minuscule code dans toutes les réponses?
spencer nelson
12
Je ne comprends pas en quoi cela correspond à un site de questions-réponses: au moins avec le code golf, il existe une norme quelque peu objective par laquelle voter sur les réponses: la réponse la plus courte ou la plus intelligente obtient le plus de votes. Avec ceci: qu'est-ce que c'est, combien de personnes comme Haskell? Des questions comme celle-ci reviennent à essayer d'intégrer tous les types de contenu possibles dans un système conçu pour un seul. Quel est le problème avec le reste d'Internet pour gérer cela?
11
Pourquoi cela ne fonctionne pas bien. Aucune information sur les avantages et les inconvénients de chaque approche (quelles langues ne prennent en charge qu'une seule méthode?). Aucune discussion sur les compromis et les problèmes profonds dans chaque langue. Portée limitée qui implique que la nécessité d'une bajiliion sépare les questions «dans toutes les langues». Et surtout, il n'y a pas de modération communautaire de la qualité de chaque réponse. Pourquoi est-ce que je dis pas de modération lorsque les gens votent dessus? Parce qu'il est censé n'y avoir qu'une seule réponse pour chaque langue et que les gens ne liront pas suffisamment de réponses pour voir plusieurs alternatives dans leur domaine.
dmckee --- ex-moderator chaton

Réponses:

48

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

snakile
la source
19
Je ne pense vraiment pas que quiconque devrait jamais écrire un readlines()[1]exemple de code. Dans ce cas, vous savez peut-être que le fichier ne comporte que deux lignes, mais quelqu'un d'autre supposant que c'est une bonne solution pourrait l'essayer sur un fichier d'un million de lignes et avoir une mauvaise surprise.
Porculus
14
@Porculus avec readlines () nous ne parcourons pas toutes les lignes du fichier. Ceci est python 3. readlines () renvoie un itérateur (pas une liste). Par conséquent, seules les deux premières lignes du fichier seront lues. Ceci est similaire à xreadlines () en python 2 (qui n'existe pas en python 3).
snakile
7
@snakile: pourriez-vous s'il vous plaît citer quelque chose à l'appui des readlines()retours d'un itérateur (pas une liste) Juste une note: vous ne pouvez généralement pas indexer un itérateur.
SilentGhost
8
@SilentGhost Je cite "Plongez dans Python 3": "La méthode readlines () renvoie maintenant un itérateur, elle est donc aussi efficace que xreadlines () l'était en Python 2". Recherchez cette déclaration dans: diveintopython3.org/porting-code-to-python-3-with-2to3.html . Deuxièmement, en python 3, vous pouvez indexer un itérateur. Tapez range (10) [4] dans le shell (range () renvoie également un itérateur en Python 3 contrairement à python 2 où range () renvoie une liste). Notez que la plage (N) [i] se fait dans O (i), pas O (1) et pas O (N).
snakile
5
@snakile: Vos commentaires sont faux à plusieurs niveaux. Tout d'abord, readlines renvoie une liste en Python 3 (testez-la et voyez). Ainsi, le code donné lira le fichier entier. Deuxièmement, les itérateurs ne peuvent pas être indexés dans Python 2 ou 3. L' rangeobjet a un support spécial pour l'indexation, ce qui se fait dans O (1).
entre
242

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
Danita
la source
28
Je ne pense pas qu'il y ait d'autre langage pour avoir cette propriété, littéralement, me faire ... lol.
Ionuț G. Stan
85
Est-ce triste que je pense que LOLCODE est plus lisible que tout ce que j'ai vu d'autre?
Joel
13
C'est intéressant à quel point cela ressemble à un langage naturel.
Abhinav Sarkar
19
Dire que vous vous attendez à être critiqué est une garantie pour les votes positifs sur SO parce que la psychologie inverse est une action réflexe pour un programmeur.
Brock Woolf
13
Le PLZ? / AWSUM THX / O NOES est tout simplement génial. Cela me semble un peu tout-puissant.
Calvin1602
43

Cerveau *** k

,------------------------------------------------>,------------------------------------------------>,------------------------------------------------>[-]+++++++++>[-]+++++++++>[-]+++++++++<<<<<[>>>>>>+>>>+<<<<<<<<<-]>>>>>>>>>[<<<<<<<<<+>>>>>>>>>-]<<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]<<<<<<<[>>>>>>+>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]>>[-]<<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]<<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<<<->>>->>>>>[-]<<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]<<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>][-]<<<<<<<[>>>>>+>>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]<<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<<->>>->>>>[-]<<<<<<<[>>>>>+>>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]<<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>][-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<->>>->>>[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>]<[-]+<[-]+<<<<<<[>>>>>>[-]<<<<<<[-]]>>>>>>[[-]+<<<<<[>>>>>[-]<<<<<[-]]>>>>>[[-]+<<<<[>>>>[-]<<<<[-]]>>>>[[-]+<<<[>>>[-]<<<[-]]>>>[[-]+<<[>>[-]<<[-]]>>[[-]+<[>[-]<[-]]>[[-]+++++++++++++++++++++++++++++++++++++++++++++++++.-...>[-]<[-]]<>[-]]<<>>[-]]<<<>>>[-]]<<<<>>>>[-],------------------------------------------------>,------------------------------------------------>,------------------------------------------------>[-]+++++++++>[-]+++++++++>[-]+++++++++<<<<<[>>>>>>+>>>+<<<<<<<<<-]>>>>>>>>>[<<<<<<<<<+>>>>>>>>>-]<<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]<<<<<<<[>>>>>>+>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]>>[-]<<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]<<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<<<->>>->>>>>[-]<<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]<<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>][-]<<<<<<<[>>>>>+>>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]<<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<<->>>->>>>[-]<<<<<<<[>>>>>+>>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]<<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>][-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<->>>->>>[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>]<[-]+<[-]+<<<<<<[>>>>>>[-]<<<<<<[-]]>>>>>>[[-]+<<<<<[>>>>>[-]<<<<<[-]]>>>>>[[-]+<<<<[>>>>[-]<<<<[-]]>>>>[[-]+<<<[>>>[-]<<<[-]]>>>[[-]+<<[>>[-]<<[-]]>>[[-]+<[>[-]<[-]]>[[-]+++++++++++++++++++++++++++++++++++++++++++++++++.-...>[-]<[-]]<>[-]]<<>>[-]]<<<>>>[-]]<<<<>>>>[-]]<<<<<>>>>>[-]]<<<<<<>>>>>>>[<<<<<<<<[>>>>>>+>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]>[-]++++++++++<<+<<<<<<+>>>>>>>>>>>[-]<<<<<[>>>+>>+<<<<<-]>>>>>[<<<<<+>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<->>->>>[-]<<<<<[>>>+>>+<<<<<-]>>>>>[<<<<<+>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>]<<<<[-]+<[>[-]<[-]]>[[-]+>[<[-]>[-]]<[<<<<<<<[-]<+>>>>>>>>[-]]><[-]]<<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]>[-]++++++++++>>>[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<->>>->>>[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>]<<<<[-]+<<[>>[-]<<[-]]>>[[-]+>[<[-]>[-]]<[<<<<<<<<[-]<+>>>>>>>>>[-]]><[-]]<<<<<<<<<++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++.>>>>>>>>[-]]]<<<<<>>>>>[-]]<<<<<<>>>>>>>[<<<<<<<<[>>>>>>+>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]>[-]++++++++++<<+<<<<<<+>>>>>>>>>>>[-]<<<<<[>>>+>>+<<<<<-]>>>>>[<<<<<+>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<->>->>>[-]<<<<<[>>>+>>+<<<<<-]>>>>>[<<<<<+>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>]<<<<[-]+<[>[-]<[-]]>[[-]+>[<[-]>[-]]<[<<<<<<<[-]<+>>>>>>>>[-]]><[-]]<<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]>[-]++++++++++>>>[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<->>>->>>[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>]<<<<[-]+<<[>>[-]<<[-]]>>[[-]+>[<[-]>[-]]<[<<<<<<<<[-]<+>>>>>>>>>[-]]><[-]]<<<<<<<<<++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++.>>>>>>>>[-]]
Svisstack
la source
26
Avez-vous manqué un «-»? ;)
Aiden Bell
2
Oh l'effort. Pour mémoire, combien de temps a-t-il fallu pour écrire?
Riduidel
Et vous ne pouvez pas diviser cela sur plusieurs lignes? Meilleure langue de tous les temps
TheIronKnuckle
42

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.
Mark Mullin
la source
2
Cela devrait être voté au moins 1 million de fois pour la pure génialité +1
Brock Woolf
1
+1 pour "Cette langue existe toujours." = D
missingfaktor
3
Soyez prudent lorsque vous essayez cela à la maison. Votre compilateur cobol pourrait ne pas aimer ces lignes modernes de longueur variable ...
Stephan Eggermont
Ya, cela ramène quelques vieux souvenirs rouillés. Je ne pense pas que cela remplisse les conditions ...
EvilTeach
J'écris du code dans AcuCOBOL en ce moment! Au fait, où est la partie «I» de «I / O»?
Buggabill
39

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" 
Ionuț G. Stan
la source
7
Ahh le «Tout-Puissant» Haskell. Merci pour votre contribution :)
Brock Woolf
3
@Andreas Rejbrand Je suis presque sûr qu'il a oublié un `` être ''
Federico klez Culloca
4
Il existe un certain nombre d'autres approches des E / S de base dans Haskell qui deviennent utiles / importantes dans Haskell une fois que vous faites certains types d'applications. Les paquets text et bytestring sur cabal / hackage vous permettent de gérer divers encodages, et divers paquets de style iteratee tels que iteratee et enumerate représentent une "abstraction la plus connue" pour faire de l'io incrémental. Il est également important d'analyser les bibliothèques comme parsec et la chaîne d'octets incrémentielle uniquement attoparsec lib. Haskellers a adopté une approche très approfondie pour explorer les choix de conception io. Les exemples non viables incluent lazy io et les suites
Carter Tazio Schonwald
4
Yuji: en gros, en trichant. Haskell est un langage fonctionnel pur, à l' exception de tout type de langage, IO aqui a un support de compilateur spécial pour les effets secondaires. (La pureté est préservée ailleurs parce que tout ce qui effectue ou observe un effet secondaire est de type IO a, donc le système de types garantit que le reste de votre programme reste pur.)
Sam Stokes
4
Il se trouve que IOc'est une monade, mais ce n'est pas pourquoi il est autorisé à faire des effets secondaires. Être une monade est ce qui vous permet d'écrire cette syntaxe impérative: cela garantit également (également avec un support de langage spécial) que les effets secondaires se produisent dans un ordre raisonnable, de sorte que vous ne lisez pas le fichier avant de l'écrire, etc. .
Sam Stokes
35

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);
}
Bernard
la source
10
+1, tellement plus beau et lisible que la version C ++! Je rêve d'un jour où D remplace complètement C et C ++. :-)
missingfaktor
10
Agréable. Peut-être que je devrais apprendre D un jour.
helpermethod
34

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
Wayne Conrad
la source
2
+1 Bien, mais pour être strict, vous ne mettez pas l'entrée dans une variable avant de l'écrire dans la console.
Lasse Espeholt
3
@lasseespeholt, vous avez raison. Je l'ai corrigé.
Wayne Conrad
5
Aucune raison de mettre en majuscule varname et de dire «PATH». Dites simplement «chemin».
OTZ
2
@otz C'est une constante. Il aurait cependant pu l'appeler «Chemin», une constante dans Ruby doit simplement commencer par une lettre majuscule.
Sirupsen
1
@Thomas Ahle: lors de l'utilisation File.openavec un bloc, le fichier est ouvert, passé au bloc, puis fermé automatiquement.
Matchu
33

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.

Lasse Espeholt
la source
1
c'est assez court en C #. merci pour votre contribution
Brock Woolf
13
REMARQUE: File.ReadLines est spécifique à .NET 4
kirk.burleson
5
Quelle syntaxe désagréable C # a
Aiden Bell
3
@Aiden Bell: par rapport à quelle langue?
zfedoran
2
@Aiden Bell - Cette réponse essaie d'être succincte plutôt que lisible. Il existe de nombreuses façons «sympas» de réaliser la même chose en C #. Voir dotnetperls.com/file-handling pour des exemples plus réalistes.
Dan Diplo
29

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;
}
Maister
la source
Bonne réponse. Merci d'avoir contribué +1
Brock Woolf
Pourquoi appelez-vous fgets () deux fois?
kirk.burleson
2
Parce que la deuxième ligne est celle que nous voulons imprimer sur stdout
JeremyP
1
#include <stdio.h> int main (void) { fichier FILE ; char buf [128]; file = fopen ("fileio.txt", "w"); if (! fichier) goto erreur; fputs ("bonjour \ n", fichier); fflush (fichier); fputs ("monde \ n", fichier); fclose (fichier); fichier = fopen ("fileio.txt", "r"); if (! fichier) goto erreur; fgets (buf, sizeof (buf), fichier); / skip 'bonjour' / fgets (buf, sizeof (buf), fichier); / get 'mot' * / fclose (fichier); fputs (buf, stdout); return 0; erreur: fputs ("Impossible d'ouvrir le fichier \ n", stderr); return 1; }
FelipeC
Bon codage propre (beaucoup de vérification d'erreur décente) dans le message d'origine C (ce qui fait un peu exploser la longueur).
xagyg
29

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

robertbasic
la source
9
Je ne sais pas pourquoi, mais j'adore ça :)
Federico klez Culloca
Bien sûr, cela compte. Belle réponse et merci d'avoir contribué +1
Brock Woolf
Pourquoi ne pas envoyer le standard à / dev / null?
Gumbo
Il existe une version un peu plus simple et plus rapide, utilisant uniquement des composants internes du shell (au lieu de lancer un processus séparé à invoquer sed), ici: stackoverflow.com/questions/3538156/...
Brian Campbell
@Gumbo, alors comment obtiendriez-vous la deuxième ligne? LINE=`foo`capture la sortie de foodans la variable LINE.
strager
27

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

robertbasic
la source
Allez-vous le corriger pour qu'il fonctionne à 100%? Sinon, supprimez-le pour qu'une version fonctionnelle puisse prendre sa place.
kirk.burleson
4
Ce qui est assez drôle, c'est que l'exemple en C, qui est censé être un langage de niveau supérieur, est à peu près aussi long que celui-ci ... =)
Jani Hartikainen
1
@Jani: Mais au moins, c'est un peu plus facile à comprendre.
sbi
Je pensais que c'était pour DOS au début :)
mlvljr
21

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)));
Ionuț G. Stan
la source
@Ionut: Merci pour vos nombreuses contributions +1
Brock Woolf
4
@Dave, ce n'est pas le JS trouvé dans les navigateurs. Je veux dire, syntaxiquement et sémantiquement, c'est le même JS, juste la bibliothèque standard est différente. J'ai utilisé le stdlib de la node.jsplateforme. Voir nodejs.org
Ionuț
5
Ce code réclame des suites. J'entends ses larmes.
Matt
2
N'est-il pas drôle que le nombre de lignes corresponde presque à celui de la solution ASM en bas?
kizzx2
1
@Matt oui, les continuations ou les monades aideraient ici aussi.
Martijn
21

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))))
points718
la source
1
pour une langue appelée "lisp", il devrait y avoir beaucoup plus de lettres "s" impliquées :)
iwasrobbed
18

PowerShell

sc fileio.txt 'hello'
ac fileio.txt 'world'
$line = (gc fileio.txt)[1]
$line
Lasse Espeholt
la source
3
C'est agréable et propre. Yay powershell.
Jay Bazuzi
Je suis d'accord avec votre logique concernant la citation. La raison pour laquelle je les ai supprimés était que je me suis rendu compte que ce script est en fait dans le top pour être compact, donc je le voulais encore plus petit - mais nous laissons cela clair :). Et l'utilisation de gcau lieu de a du catsens :-) get-aliasm'a donné le catpremier (je n'utilise pas beaucoup PowerShell).
Lasse Espeholt
4
Merde, y a-t-il quelque chose de plus court ??
0fnt
18

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
Brian Campbell
la source
3
Très agréable. J'ai appris quelque chose (quoique temporairement).
Potatoswatter
Merci pour votre contribution Brian.
Brock Woolf
Totalement malade! Dans le bon sens :-)
helpermethod
18

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))
Abhinav Sarkar
la source
1
WTF, au cours des 50 dernières années, presque personne n'a dit que Lisp / Scheme était génial!
Ionuț G. Stan
11
Attendez, spitest vraiment le nom de la fonction d'écriture dans un fichier?
Sam Stokes
4
Clojure ne bascule définitivement pas!
kirk.burleson
1
@ [Sam Stokes] Il existe une fonction dans le noyau appelée slurp qui lit un fichier entier dans une chaîne et le renvoie. cracher fait exactement le contraire. Quel est le problème? Il existe d'autres fonctions, comme line-seq, qui font des choses similaires de différentes manières.
Rayne
4
@ kirk.burleson Rocks plus que Java, certainement. :)
Rayne
17

F#

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

let secondLine = File.ReadLines path |> Seq.nth 1
printfn "%s" secondLine
Lasse Espeholt
la source
1
F#. Agréable. Merci pour votre contribution.
Brock Woolf
16

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$
casablanca
la source
C'est incroyable que vous puissiez encore le faire après 10 ans !. Bravo et merci pour votre contribution.
Brock Woolf
Bien sûr, je ne l'ai pas fait du haut de ma tête: j'ai pris quelques minutes pour chercher des choses.
casablanca
Ouais, bien sûr. Encore bien fait.
Brock Woolf
N'avez-vous pas besoin de numéros de ligne dans la version la plus classique de BASIC ???
Yuji
@Yuji: Dans la "version la plus classique", oui, mais je ne pense pas qu'aucune version depuis le début des années 90 les ait exigées.
casablanca
16

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]);
Brock Woolf
la source
17
Je n'ai jamais aimé Objective-C. La syntaxe semble tellement étrangère lorsqu'elle vient d'un langage comme Java.
Faisal Abid
5
Le secret d'Objective-C est que Xcode effectue tout le code pour vous. Vous n'avez pas à vous souvenir des longs noms de méthode. Ils rendent certainement votre code beaucoup plus lisible
Brock Woolf
7
Et je pensais que la syntaxe C ++ était déjà la pire.
Toad
6
Objective-C n'a l'air mauvais que parce que le surligneur de syntaxe Stackoverflow n'est pas coloré correctement.
Brock Woolf
4
Je ne peux pas croire que ce soit si loin dans la liste! Aussi les gars de Java commentant que Objective-C est moche, avez-vous vu combien de lignes il a fallu pour écrire le même fichier? J'étais un passionné de Java, mais je pense qu'Objective-C est entré dans mon cœur.
Kyle
16

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];
Vivin Paliath
la source
15
qu'en est-il des gestionnaires de fichiers lexicaux, 3 arguments ouverts?
MkV
6
Les descripteurs de fichiers non lexicaux ne doivent jamais être utilisés sur Stack Overflow. Ils sont rarement nécessaires dans la pratique, et les débutants ne devraient jamais se voir montrer qu’ils existent même.
Ether
4
Il en va de même pour deux arguments ouverts: vous ne devriez jamais l'utiliser sur Stack Overflow, et probablement pas dans la pratique.
rpkelly
2
J'utilise tellement les descripteurs de fichiers ouverts et lexicaux 3-arg que je le considère pratiquement comme une erreur de syntaxe quand je le vois. Et c'est ainsi que cela devrait être. / me réfléchit à l'écriture d'un module pour y parvenir.
Kent Fredric
2
"Même unaire ouvert a ses usages", il a ses usages, oui, mais je me suis senti abusé le jour où j'ai compris comment ça marche, et j'irai "Il y a sûrement un autre moyen" chaque fois que je vois quelqu'un qui pense en avoir besoin. perl -we 'for (q{ps aux |}){ open _; print <_>; }'
Kent Fredric
15

R:

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

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
Ionuț G. Stan
la source
C'est génial. Merci pour la contribution.
Brock Woolf
20
Vous pouvez également utiliser l'implémentation C et ajouter des signes dollar.
Kendall Hopkins
@strager Je n'ai aucune idée. Il y a des gens qui ne savent pas que c'est optimal et que c'est mieux sans ça.
Ionuț G. Stan
6
Juste au cas où quelqu'un serait curieux, la raison pour laquelle il a laissé la balise de fermeture est que si vous l'incluez et laissez un espace blanc à la fin, vous risquez d'obtenir une erreur «en-têtes déjà envoyés».
Bill H
Référence pour no ?>: framework.zend.com/manual/en
...
15

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());
    }       
  }
}
st0le
la source
36
@Brock: De nos jours, Java n'est pas lent. Juste verbeux, mais pas lent. Veuillez ne pas faire de tels commentaires; nous blesse les gens JVM. : '|
missingfaktor
9
Quiconque a dit que Java est lent est soit un haineux aveugle de Java, soit vit sous un rocher. Java peut être aussi rapide, sinon plus rapide, que C, avec l'indépendance de la plate-forme pour démarrer.
NullUserException
4
@Missing Faktor: Et alors?
Jerry Coffin
19
la vitesse d'exécution est la forme la plus retardée de concours de pisse des programmeurs. Il s'agit toujours de choisir le bon outil pour le travail, choisir une métrique aléatoire comme la vitesse d'exécution et lui attribuer des tas d'importance est tout simplement idiot, d'autant plus que la vitesse d'exécution n'est pas horriblement importante pour la grande majorité des tâches, tant qu'elle est assez rapide (ce que java est pour presque tout)
Matt Briggs
11
"le câblage est plus rapide que le code machine", "le code machine est plus rapide que asm", "asm est plus rapide que C", "C est plus rapide que Java", "bla bla bla" ... Avez-vous même une idée de combien l'indirection est déjà entre le code machine et le CPU? microcode, optimiseur prédictif, caches d'instructions / données, décodeur, etc., sans oublier le non-déterminisme causé par l'allocation dynamique en C / asm. Java et d'autres langages sûrs ne sont qu'une petite étape supplémentaire de l'indirection, ce n'est pas grave. Vous pouvez soit rester à jamais dans votre forme primitive, soit évoluer avec nous.
L̲̳o̲̳̳n̲̳̳g̲̳̳p̲̳o̲̳̳k̲̳̳e̲̳̳
14

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;
}
Potatoswatter
la source
1
Génial! Merci d'avoir contribué +1
Brock Woolf
14
J'ai oublié à quel point la syntaxe de C ++ peut être laide.
Toad
C'est atroce par rapport à ce code le plus C ++ ressemble. Le problème principal est un manque de constantes appropriées définies dans la bibliothèque standard, mais pas de syntaxe. Cela me stupéfie de devoir inclure <limits>juste pour dire ignorequ'il n'y a pas de limite à la taille de la ligne.
Potatoswatter
8
@Hans: Voulez-vous clarifier cela? Personnellement, je pense que les E / S appartiennent à une bibliothèque plutôt qu'au langage, et tous les langages dans lesquels je programme le font de cette façon (C, C ++, Java, Python, etc.)
Chinmay Kanchi
2
Maintenant, je sais pourquoi Linus dit que C ++ est moche. (sans infraction)
kizzx2
13

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)
}
eclark
la source
23
Cette langue doit être renommée "type"
Aiden Bell
Est - ce os.O_RDWR | os.O_CREATE, 0666indésirable même nécessaire pour les E / S de fichier de base dans Go?
Joey Adams
1
Ou peut-être devrait-il être renommé "Stop"
xagyg
16
C'est plutôt étonnant que, compte tenu de 30 ans d'évolution et de conception de langage, ils aient réussi à inventer un nouveau langage qui est aussi difficile à écrire du code de vérification des erreurs que C. Même Java est moins verbeux!
DK.
5
Wow ... Go semble tellement
Échouer
12

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).
clofresh
la source
12

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"))
tarsius
la source
1
gentil merci. Est-il possible d'améliorer cela pour que je voie réellement un «fantôme» ouvrir le fichier et le saisir, comme une sorte de macro?
zedoo
11

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

TheLQ
la source
soigné. merci pour votre contribution.
Brock Woolf
Je comprends l'étape 4) comme la lecture du fichier créé.
devio
@devio - Les exigences doivent avoir changé ou je les ai juste mal interprétées ... Quoi qu'il en soit, je vais voir si une telle solution existe même
TheLQ
11

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)
manquants
la source
Je pense que cela serait plus joli avec flush () au lieu de close () ... pas de ré-instanciation du FileWriter.
Radtoo
2
@Radtoo: J'ai dû montrer l'opération d'ajout. C'est pourquoi je l'ai fait de cette façon.
missingfaktor
@Radtoo: Après avoir regardé d'autres réponses dans ce fil, j'ai finalement décidé d'inclure cette façon dans ma réponse. Vérifie ça. (Je n'ai pas supprimé le code d'origine cependant.)
missingfaktor
@Missing Faktor, getLines().toList()devrait être getLines().toSeqce qui est paresseux?
Elazar Leibovich
@Elazar: Bonne suggestion. Merci. :)
missingfaktor
11

Sensationnel

new File("fileio.txt").with { 
    write  "hello\n"
    append "world\n"   
    println secondLine = readLines()[1]
}
Wayne Keenan
la source
merci pour votre contribution.
Brock Woolf
3
Vous trichez sur la partie "monde \ n". Il ne s'agit pas d'ajout, il s'agit simplement d'écrire dans le même descripteur de fichier.
OTZ
La troisième clarification dans le message d'origine indique "Vous n'avez pas besoin de rouvrir le fichier texte après avoir écrit la première ligne"
Wayne Keenan