Bu, tüm programcıların zaman zaman sorduğu ortak bir soru olmalıdır. Bir metin dosyasından bir satırı nasıl okurum? O zaman bir sonraki soru her zaman onu nasıl geri yazacağımdır.

Elbette çoğunuz günlük programlamada yüksek seviyeli bir çerçeve kullanıyorsunuz (ki bu cevaplarda kullanmakta sorun yok) ama bazen bunu nasıl düşük seviyede yapacağınızı bilmek güzel.

Kendimi içinde nasıl yapılacağını biliyorum C, C++ve Objective-C, ama emin sadece yardım etmek bize io dosyamızı ne yapacağını dil hakkında daha iyi karar eğer, popüler tüm dillerde nasıl yapıldığını görmek için kullanışlı olacaktır. Özellikle : Ben onun gibi dize manipülasyon dillerinde yapılması görmek ilginç olacağını düşünüyorum python, rubyve tabii ki perl.

Bu yüzden, burada hepimizin profillerimize yıldız verebileceğimiz ve yeni bir dilde G / Ç dosyası yapmamız gerektiğinde başvurabileceğimiz bir topluluk kaynağı oluşturabileceğimizi düşündüm . Maruziyetten bahsetmiyorum bile, hepimiz her gün uğraşmadığımız dillere ulaşacağız.

Bu şekilde cevaplamanız gerekiyor:

1. " Fileio.txt " adlı yeni bir metin dosyası oluşturun
2. Metin dosyasına ilk satırı "merhaba" yazın.
3. Metin dosyasına ikinci satır olan "dünya" yı ekleyin.
4. İkinci satır olan "dünya" yı bir giriş dizesine okuyun.
5. Giriş dizesini konsola yazdırın.

Açıklama:

• Bunun nasıl yapılacağını yanıt başına yalnızca bir programlama dilinde göstermelisiniz.
• Metin dosyasının önceden mevcut olmadığını varsayın
• İlk satırı yazdıktan sonra metin dosyasını yeniden açmanıza gerek yoktur

Dil konusunda belirli bir sınır yok. C, C++, C#, Java, Objective-CTüm mükemmeldir.

Bunu yapmak biliyorsanız Prolog, Haskell, Fortran, Lisp, veya Basico halde durma lütfen.

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)

Açıklamalar

• readlines () , dosyadaki tüm satırların bir listesini döndürür . Bu nedenle, readlines () 'ın çağrılması, dosyanın her satırının okunmasıyla sonuçlanır. Bu özel durumda readlines () kullanmakta sorun yok çünkü yine de tüm dosyayı okumamız gerekiyor (son satırını istiyoruz). Ancak dosyamız çok sayıda satır içeriyorsa ve sadece n'inci satırını yazdırmak istiyorsak, tüm dosyayı okumak gereksizdir. Python'da bir dosyanın n'inci satırını almanın daha iyi yolları şunlardır: Python 3'te xreadlines () yerine ne koyar? .

• Bu ifade ile nedir? With ifadesi, f değişkenini open () çağrısından döndürülen bir akış nesnesi olarak kullanabileceğiniz bir kod bloğu başlatır . With bloğu bittiğinde, python otomatik olarak f.close () öğesini çağırır. Bu, bloktan nasıl veya ne zaman çıkarsanız çıkın (işlenmemiş bir istisna yoluyla çıksanız bile) bloğa sahip çıktığınızda dosyanın kapatılacağını garanti eder. F.close () öğesini açıkça çağırabilirsiniz, ancak ya kodunuz bir istisna yaratırsa ve f.close () çağrısına ulaşamazsanız ne olur? Bu yüzden with ifadesi kullanışlıdır.

• Her işlemden önce dosyayı yeniden açmanıza gerek yoktur. Tüm kodu bir blok ile yazabilirsiniz.

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

  Üç işlem arasındaki farkı vurgulamak için bloklu üç kullandım: yazma (mod 'w'), ekleme ('a' modu), okuma ('r' modu, varsayılan).

LOLCODE

Özellikler en azını söylemek için yarım yamalak ama elimden gelenin en iyisini yaptım. Olumsuz oylama başlasın! :) Hala eğlenceli bir egzersiz buluyorum.

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

Beyin *** k

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

COBOL

Kimse yapmadığı için ......

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

Sadece bir dosya okumak / yazmak istiyorsanız:

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

yakut

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)Yalnızca .Net 4.0 ise, bunun alternatifi File.ReadAllLines(path)[1]tüm dosyayı bir diziye ayrıştırmaktır.

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

Kabuk Komut Dosyası (UNIX)

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

Aslında sed -n "2p"parça ikinci satırı yazdırıyor, ancak soru ikinci satırın bir değişkende saklanmasını ve ardından yazdırılmasını istiyor, yani ... :)

Linux'ta x86 Assembler (NASM)

7 yıldır asm'e dokunmadım, bu yüzden bunu birlikte kesmek için google'ı biraz kullanmak zorunda kaldım, ama yine de çalışıyor;)% 100 doğru olmadığını biliyorum, ama hey: D

Tamam, çalışmıyor. bunun için üzgünüm. o yazdırmak yapar iken worldsonunda, bu dosyadan yazdırmak değil, ama gelen ecxhangi hat 27 üzerinde ayarlanır.

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

Kullanılan referanslar: 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

İlk olarak, çok sayıda iç içe geçmiş geri arama.

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

Biraz daha temiz:

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

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

Güç kalkanı

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

Kabuk Komut Dosyası

İşte önceki yanıtların yaptığı gibi sedveya harici komutları çağırmak yerine, yalnızca yerleşik komutları kullanan bir kabuk betiği tail.

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

Önemli kabuk komut dosyalarını yazarken, yerleşikleri olabildiğince çok kullanmanız önerilir, çünkü ayrı bir işlemin oluşturulması yavaş olabilir; makinemdeki hızlı bir testten, sedçözüm kullanmaktan yaklaşık 20 kat daha yavaş read. sedBu durumda olduğu gibi bir kez arayacaksanız , fark edebileceğinizden daha hızlı çalışacağından pek bir önemi yoktur, ancak bunu yüzlerce veya binlerce kez gerçekleştirecekseniz, ekleyin.

Sözdizimi aşina olanlar için {ve } mevcut kabuk ortamında komutların bir listesini çalıştırma (karşıt olarak (ve )burada bir altkabuk oluşturmak; daha sonra değişkenin değeri kullanabilir bu yüzden, mevcut kabuk ortamında çalışan gereken) . Yönlendirme ile oluşturulan aynı girdi akışı üzerinde her ikisinin de çalışmasını sağlamak için komutları birlikte gruplamamız gerekir fileio.txt; basitçe koşarsak read < fileio.txt; read input < fileio.txt, dosya iki komut arasında kapanıp yeniden açılacağı için ilk satırı alırdık. Kabuk sözdiziminin kendine özgü olması nedeniyle ( {ve }metakarakterlerin aksine ayrılmış kelimelerdir), {ve}boşluklu komutların geri kalanından ve komutların listesini bir ;.

readYerleşik değişkenlerin isimleri içine okumak için bir argüman olarak alır. Bir girdi satırı tüketir, girdiyi boşlukla böler (teknik olarak, içeriğine göre keser $IFS, varsayılan olarak bir boşluk karakteridir, burada boşluk karakteri herhangi bir boşluk, sekme veya yeni satıra bölmek anlamına gelir), atar her bir kelime sırayla verilen değişken isimlerine ve satırın kalanını son değişkene atar. Sadece bir değişken sağladığımız için, sadece tüm satırı o değişkene koyar. $inputİlk satırda ne olduğunu umursamadığımız için değişkeni yeniden kullanıyoruz (Bash kullanıyorsak, bir değişken adı sağlayamayız, ancak taşınabilir olmak için her zaman en az bir ad sağlamalısınız).

Burada yaptığım gibi, satırları birer birer okuyabilseniz de, onu bir while döngüsüne sarmak çok daha yaygın bir model olacaktır:

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

Veya eşdeğeri olarak, iş parçacığı makrosunu kullanarak ->(aynı zamanda paren kaldırıcı olarak da bilinir):

(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

TEMEL

BASIC'i neredeyse 10 yıldır kullanmadım, ancak bu soru bana bilgimi hızla tazelemem için bir neden verdi. :)

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$

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

kedi ("merhaba \ n", file = "fileio.txt")
kedi ("dünya \ n", dosya = "fileio.txt", ekleme = DOĞRU)
line2 = readLines ("fileio.txt", n = 2) [2]
Kedi (satır2)

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

ya da biraz daha az bilgiççe,

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

Git

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

Muhtemelen en deyimsel Erlang değil, ama:

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

Bazılarının Emacs'ın esas olarak bir metin editörü olduğunu söylediklerine rağmen [1]. Dolayısıyla Emacs Lisp her türlü sorunu çözmek için kullanılabilirken, bir metin düzenleyicinin ihtiyaçlarına göre optimize edilmiştir. Metin editörlerinin (tabii ki) dosyaların nasıl işlendiğine gelince oldukça özel ihtiyaçları olduğundan, bu Emacs Lisp'in dosya ile ilgili hangi işlevselliği sunduğunu etkiler.

Temel olarak bu, Emacs Lisp'in bir dosyayı akış olarak açma ve onu parça parça okuma işlevleri sunmadığı anlamına gelir. Aynı şekilde, önce tüm dosyayı yüklemeden bir dosyaya ekleyemezsiniz. Bunun yerine dosya tamamen [2] bir arabelleğe [3] okunur, düzenlenir ve sonra tekrar bir dosyaya kaydedilir.

Zorunlu görevler için Emacs Lisp kullanmalısınız, bunun için uygundur ve eğer aynı işlevleri düzenlemeyi içermeyen bir şey yapmak istiyorsanız kullanılabilir.

Bir dosyaya tekrar tekrar eklemek isterseniz, bu çok büyük bir ek yük getirir, ancak burada gösterildiği gibi mümkündür. Pratikte normalde bir dosyaya yazmadan önce manuel veya programlı olarak bir arabellekte değişiklik yapmayı bitirirsiniz (sadece aşağıdaki örnekte ilk iki s-ifadesini birleştirin).

(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] En azından işletim sistemi olarak adlandıracak kadar ileri gitmem; alternatif bir UI evet, bir işletim sistemi hayır.

[2] Bir dosyanın yalnızca bölümlerini yükleyebilirsiniz, ancak bu yalnızca bayt bazında belirtilebilir.

[3] Arabellek, hem bir dizeye benzer bir veri türü hem de "bir dosyayı düzenlerken gördüğünüz şey" dir. Bir arabelleği düzenlerken bir pencerede görüntülenir, ancak arabelleklerin kullanıcı tarafından görülmesi gerekmez.

Düzenle: Eğer arabelleğe eklenen metni görmek istiyorsanız, açıkça görünür hale getirmeniz ve eylemler arasında uyumanız gerekir. Emacs normalde yalnızca kullanıcı girdisini beklerken ekranı yeniden görüntülediğinden (ve uyumak, girdi beklemekle aynı şey değildir), ayrıca yeniden görüntülemeye zorlamanız gerekir. Bu, bu örnekte gereklidir (ikinci sexp yerine kullanın); pratikte bir kez bile `` yeniden gösterimi '' kullanmak zorunda kalmadım - bu yüzden evet, bu çirkin ama ...

(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 Toplu İş Dosyaları - Sürüm # 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

Bu son korkunç arayış döngüsünü açıklamak için, dosyada yalnızca merhaba (yeni satır) dünyası olduğunu varsayar. Böylece sadece ilk satırı atlar ve yalnızca ikinciyi yansıtır.

Değişiklikler

• 2 - Opps, gereksinimleri yanlış okumalı veya benden değişmiş olmalı. Şimdi dosyadan son satırı okuyor

Scala:

Standart kitaplığı kullanma:

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)

Josh Suereth'in Scala-ARM Kitaplığını Kullanma :

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)      

Birçok kişi iki dizeyi yazmak için aynı dosya tanımlayıcısını kullandığından, cevabıma bu yolu da dahil ediyorum.

Standart kitaplığı kullanma:

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)

Josh Suereth'in Scala-ARM Kitaplığını Kullanma :

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)

harika

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