file-io - programacion - que es java
Archivo de E/S en todos los lenguajes de programación (30)
Esta debe ser una pregunta común que todos los programadores tienen de vez en cuando. ¿Cómo leo una línea de un archivo de texto? Entonces la siguiente pregunta es siempre cómo la vuelvo a escribir.
Por supuesto, la mayoría de ustedes usa un marco de alto nivel en la programación diaria (que está bien usar en las respuestas), pero a veces es bueno saber cómo hacerlo en un nivel bajo también.
Yo mismo sé cómo hacerlo en C , C++ y Objective-C , pero seguramente sería útil ver cómo se hace en todos los idiomas populares, aunque solo sea para ayudarnos a tomar una mejor decisión sobre qué idioma usar para nuestro archivo. io in. En particular, creo que sería interesante ver cómo se hace en los lenguajes de manipulación de cadenas, como: python , ruby y por supuesto perl .
Así que creo que aquí podemos crear un recurso de la comunidad que todos podamos destacar en nuestros perfiles y referirnos a cuando necesitamos hacer E / S de archivos en algún idioma nuevo. Por no hablar de la exposición, todos llegaremos a idiomas que no manejamos día a día.
Así es como debes responder:
- Crea un nuevo archivo de texto llamado " fileio.txt "
- Escriba la primera línea "hola" en el archivo de texto.
- Agregue la segunda línea "mundo" al archivo de texto.
- Lea la segunda línea "mundo" en una cadena de entrada.
- Imprime la cadena de entrada a la consola.
Aclaración:
- Debería mostrar cómo hacer esto en un lenguaje de programación por respuesta solamente.
- Supongamos que el archivo de texto no existe de antemano
- No es necesario volver a abrir el archivo de texto después de escribir la primera línea
Sin límite particular en el idioma. C , C++ , C# , Java , Objective-C son geniales.
Si sabes cómo hacerlo en Prolog , Haskell , Fortran , Lisp o Basic , sigue adelante.
COBOL
Como nadie más lo hizo ......
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.
Ensamblador x86 (NASM) en Linux
No he tocado el asm en 7 años, así que tuve que usar Google un poco para hackear esto juntos, pero aún así, funciona;) Sé que no es 100% correcto, pero oye: D
OK, no funciona. lo siento por esto mientras imprime el world al final, no lo imprime desde el archivo, sino desde el ecx que está configurado en la línea 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
Referencias utilizadas: 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
LOLCODE
Las especificaciones son incompletas para decir lo menos, pero lo hice lo mejor que pude. ¡Que comience la votación! :) Todavía me parece un ejercicio divertido.
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
Emacs Lisp
Despite what some people say Emacs is mainly a text editor [1]. So while Emacs Lisp can be used to solve all kinds of problems it is optimized towards the needs of a text editor. Since text editors (obviously) have quite specific needs when it comes to how files are handled this affects what file related functionality Emacs Lisp offers.
Basically this means that Emacs Lisp does not offer functions to open a file as a stream, and read it part by part. Likewise you can''t append to a file without loading the whole file first. Instead the file is completely [2] read into a buffer [3], edited and then saved to a file again.
For must tasks you would use Emacs Lisp for this is suitable and if you want to do something that does not involve editing the same functions can be used.
If you want to append to a file over and over again this comes with a huge overhead, but it is possible as demonstrated here. In practice you normally finish making changes to a buffer whether manually or programmatically before writing to a file (just combine the first two s-expressions in the example below).
(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] At least I would not go as far as calling it an OS; an alternative UI yes, an OS no.
[2] You can load only parts of a file, but this can only be specified byte-wise.
[3] A buffer is both a datatype in someways similar to a string as well as the "thing you see while editing a file". While editing a buffer is displayed in a window but buffers do not necessarily have to be visible to the user.
Edit: If you want to see the text being inserted into the buffer you obviously have to make it visible, and sleep between actions. Because Emacs normally only redisplays the screen when waiting for user input (and sleeping ain''t the same as waiting for input) you also have to force redisplay. This is necessary in this example (use it in place of the second sexp); in practice I never had to use `redisplay'' even once - so yes, this is ugly but ...
(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"))
R:
cat("hello/n", file="fileio.txt") cat("world/n", file="fileio.txt", append=TRUE) line2 = readLines("fileio.txt", n=2)[2] cat(line2)
Scala:
Using standard library:
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)
Using Josh Suereth''s Scala-ARM Library :
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)
Since many people have used the same file descriptor to write the two strings, I''m also including that way in my answer.
Using standard library:
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)
Using Josh Suereth''s Scala-ARM Library :
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)
BASIC
No he usado BASIC en casi 10 años, pero esta pregunta me dio una razón para actualizar mi conocimiento rápidamente. :)
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$
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'';
}
or somewhat less pedantically,
#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;
}
Cerebro *** k
,------------------------------------------------>,------------------------------------------------>,------------------------------------------------>[-]+++++++++>[-]+++++++++>[-]+++++++++<<<<<[>>>>>>+>>>+<<<<<<<<<-]>>>>>>>>>[<<<<<<<<<+>>>>>>>>>-]<<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]<<<<<<<[>>>>>>+>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]>>[-]<<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]<<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<<<->>>->>>>>[-]<<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]<<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>][-]<<<<<<<[>>>>>+>>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]<<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<<->>>->>>>[-]<<<<<<<[>>>>>+>>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]<<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>][-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<->>>->>>[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>]<[-]+<[-]+<<<<<<[>>>>>>[-]<<<<<<[-]]>>>>>>[[-]+<<<<<[>>>>>[-]<<<<<[-]]>>>>>[[-]+<<<<[>>>>[-]<<<<[-]]>>>>[[-]+<<<[>>>[-]<<<[-]]>>>[[-]+<<[>>[-]<<[-]]>>[[-]+<[>[-]<[-]]>[[-]+++++++++++++++++++++++++++++++++++++++++++++++++.-...>[-]<[-]]<>[-]]<<>>[-]]<<<>>>[-]]<<<<>>>>[-],------------------------------------------------>,------------------------------------------------>,------------------------------------------------>[-]+++++++++>[-]+++++++++>[-]+++++++++<<<<<[>>>>>>+>>>+<<<<<<<<<-]>>>>>>>>>[<<<<<<<<<+>>>>>>>>>-]<<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]<<<<<<<[>>>>>>+>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]>>[-]<<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]<<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<<<->>>->>>>>[-]<<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]<<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>][-]<<<<<<<[>>>>>+>>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]<<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<<->>>->>>>[-]<<<<<<<[>>>>>+>>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]<<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>][-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<->>>->>>[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>]<[-]+<[-]+<<<<<<[>>>>>>[-]<<<<<<[-]]>>>>>>[[-]+<<<<<[>>>>>[-]<<<<<[-]]>>>>>[[-]+<<<<[>>>>[-]<<<<[-]]>>>>[[-]+<<<[>>>[-]<<<[-]]>>>[[-]+<<[>>[-]<<[-]]>>[[-]+<[>[-]<[-]]>[[-]+++++++++++++++++++++++++++++++++++++++++++++++++.-...>[-]<[-]]<>[-]]<<>>[-]]<<<>>>[-]]<<<<>>>>[-]]<<<<<>>>>>[-]]<<<<<<>>>>>>>[<<<<<<<<[>>>>>>+>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]>[-]++++++++++<<+<<<<<<+>>>>>>>>>>>[-]<<<<<[>>>+>>+<<<<<-]>>>>>[<<<<<+>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<->>->>>[-]<<<<<[>>>+>>+<<<<<-]>>>>>[<<<<<+>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>]<<<<[-]+<[>[-]<[-]]>[[-]+>[<[-]>[-]]<[<<<<<<<[-]<+>>>>>>>>[-]]><[-]]<<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]>[-]++++++++++>>>[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<->>>->>>[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>]<<<<[-]+<<[>>[-]<<[-]]>>[[-]+>[<[-]>[-]]<[<<<<<<<<[-]<+>>>>>>>>>[-]]><[-]]<<<<<<<<<++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++.>>>>>>>>[-]]]<<<<<>>>>>[-]]<<<<<<>>>>>>>[<<<<<<<<[>>>>>>+>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]>[-]++++++++++<<+<<<<<<+>>>>>>>>>>>[-]<<<<<[>>>+>>+<<<<<-]>>>>>[<<<<<+>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<->>->>>[-]<<<<<[>>>+>>+<<<<<-]>>>>>[<<<<<+>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>]<<<<[-]+<[>[-]<[-]]>[[-]+>[<[-]>[-]]<[<<<<<<<[-]<+>>>>>>>>[-]]><[-]]<<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]>[-]++++++++++>>>[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<->>>->>>[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>]<<<<[-]+<<[>>[-]<<[-]]>>[[-]+>[<[-]>[-]]<[<<<<<<<<[-]<+>>>>>>>>>[-]]><[-]]<<<<<<<<<++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++.>>>>>>>>[-]]
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)))))
O de manera equivalente, usando la macro de subprocesamiento -> (también conocido como removedor de par):
(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))
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))))
DO#
string path = "fileio.txt";
File.WriteAllLines(path, new[] { "hello"}); //Will end it with Environment.NewLine
File.AppendAllText(path, "world");
string secondLine = File.ReadLines(path).ElementAt(1);
Console.WriteLine(secondLine);
File.ReadLines(path).ElementAt(1) es .Net 4.0 solamente, la alternativa es File.ReadAllLines(path)[1] que analiza todo el archivo en una matriz.
F#
let path = "fileio.txt"
File.WriteAllText(path, "hello")
File.AppendAllText(path, "/nworld")
let secondLine = File.ReadLines path |> Seq.nth 1
printfn "%s" secondLine
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 solo quieres leer / escribir un archivo:
main :: IO ()
main = readFile "somefile.txt" >>= writeFile "someotherfile.txt"
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());
}
}
}
JavaScript - node.js
Primero, muchas devoluciones de llamada anidadas.
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 poco más limpio:
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)));
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
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];
Potencia Shell
sc fileio.txt ''hello''
ac fileio.txt ''world''
$line = (gc fileio.txt)[1]
$line
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)
Aclaraciones
readlines() devuelve una list de todas las líneas en el archivo. Por lo tanto, la invocación de readlines () da como resultado la lectura de todas y cada una de las líneas del archivo. En ese caso particular, está bien usar readlines () porque tenemos que leer todo el archivo de todos modos (queremos su última línea). Pero si nuestro archivo contiene muchas líneas y solo queremos imprimir su enésima línea, no es necesario leer todo el archivo. Aquí hay algunas formas mejores de obtener la n-ésima línea de un archivo en Python: ¿Qué sustituye xreadlines () en Python 3? .
¿Qué es esto con la declaración? La sentencia with inicia un bloque de código donde puede usar la variable f como un objeto de flujo devuelto por la llamada a open (). Cuando termina el bloque con, python llama a f.close () automáticamente. Esto garantiza que el archivo se cerrará cuando salga del bloque con, sin importar cómo o cuándo salga del bloque (incluso si sale de él a través de una excepción no controlada). Puede llamar a f.close () explícitamente, pero ¿qué ocurre si su código genera una excepción y no obtiene la llamada f.close ()? Es por eso que la declaración con es útil.
No necesita volver a abrir el archivo antes de cada operación. Puedes escribir todo el código dentro de uno con bloque.
with open(''fileio.txt'', ''w+'') as f: f.write(''hello'') f.write(''/nworld'') s = f.readlines()[1] print(s)Utilicé tres con bloques para enfatizar la diferencia entre las tres operaciones: escritura (modo ''w''), agregar (modo ''a''), lectura (modo ''r'', valor predeterminado).
Rubí
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
Shell Script (UNIX)
#!/bin/sh
echo "hello" > fileio.txt
echo "world" >> fileio.txt
LINE=`sed -ne2p fileio.txt`
echo $LINE
En realidad, la parte sed -n "2p" imprime la segunda línea, pero la pregunta pide que la segunda línea se almacene en una variable y luego se imprima, así que ... :)
Shell Script
Aquí hay un script de shell que usa solo comandos integrados, en lugar de invocar comandos externos como sed o tail como lo han hecho las respuestas anteriores.
#!/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
Al escribir scripts de shell significativos, es aconsejable usar builtins tanto como sea posible, ya que generar un proceso separado puede ser lento; a partir de una prueba rápida en mi máquina, la solución sed es aproximadamente 20 veces más lenta que con la read . Si vas a llamar a sed una vez, como en este caso, realmente no importa mucho, ya que se ejecutará más rápido de lo que puedes notar, pero si vas a ejecutarlo cientos o miles de veces, puede sumar
Para aquellos que no están familiarizados con la sintaxis, { y } ejecutan una lista de comandos en el entorno de shell actual (a diferencia de ( y ) que crean una subshell; necesitamos estar operando en el entorno de shell actual, para que podamos usar el valor de la variable más tarde). Necesitamos agrupar los comandos para que ambos operen en el mismo flujo de entrada, creado redirigiendo desde fileio.txt ; si simplemente read < fileio.txt; read input < fileio.txt read < fileio.txt; read input < fileio.txt , obtendríamos la primera línea, ya que el archivo se cerraría y se volvería a abrir entre los dos comandos. Debido a una idiosincrasia de sintaxis de shell ( { y } son palabras reservadas, a diferencia de los metacaracteres), necesitamos separar { y } del resto de los comandos con espacios, y terminar la lista de comandos con a ; .
La read integrada de read toma como argumento los nombres de las variables para leer. Consume una línea de entrada, rompe la entrada por espacio en blanco (técnicamente, la rompe de acuerdo con los contenidos de $IFS , que por defecto es un carácter de espacio, donde un carácter de espacio significa dividirlo en cualquier espacio, pestaña o nueva línea) , asigna cada palabra a los nombres de variable dados en orden y asigna el resto de la línea a la última variable. Como solo estamos suministrando una variable, solo pone toda la línea en esa variable. Reutilizamos la variable $input , ya que no nos importa lo que está en la primera línea (si usamos Bash no podríamos proporcionar un nombre de variable, pero para ser portátil, siempre debe proporcionar al menos un nombre).
Tenga en cuenta que si bien puede leer las líneas una a la vez, como hago aquí, un patrón mucho más común sería envolverlo en un ciclo while:
while read foo bar baz
do
process $foo $bar $baz
done < input.txt
re
module d_io;
import std.stdio;
void main()
{
auto f = File("fileio.txt", "w");
f.writeln("hello");
f.writeln("world");
f.open("fileio.txt", "r");
f.readln;
auto s = f.readln;
writeln(s);
}
Go
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)
}
C objetivo
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]);
Erlang
Probably not the most idiomatic Erlang, but:
#!/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).
Groovy
new File("fileio.txt").with {
write "hello/n"
append "world/n"
println secondLine = readLines()[1]
}
Windows Batch Files - 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
To explain that last horrible looking for loop, it assumes that there is only hello (newline) world in the file. So it just skips the first line and echos only the second.
Changelog
2 - Opps, must of misread the requirements or they changed on me. Now reads last line from file
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;
}