INSTITUTO TECNOLÓGICO SUPERIOR DE LERDO
Ensayo: ³Uso de archivos secuenciales en diferentes lenguajes´
Nombre: Miguel Ángel Gaytán Gómez
Materia: Administración de datos
Especialidad: Ingeniería en Informática
Profesor: Ricardo de Jesús Bustamante González
A viernes 17 de febrero de 2012, Cd. Lerdo, Durango.
Uso de archivos secuenciales en C#:
Lectura y Escritura de Archivos. Existen dos formas de obtener flujos ( streams) streams) que conectan a un archivo, uno utilizando la clase FileStream, la cual provee un control total sobre el acceso de archivos, incluyendo modo de acceso, compartido y buffering . La entrada/salida (E/S ) en C# está organizada alrededor del concepto de stream, el cual puede corresponder a un canal de comunicación y será aplicado a escritura y lectura de de ficheros en disco. Para empezar, el espacio de nombres donde se encuentran la mayoría de las clases de entrada salida se llama, sin demasiada imaginación, System.IO; es necesario incluirlo. De ahí se sacan clases como FileStream, un stream para escribir en fichero. Este es un fichero sin estructura, que se puede leer, en principio, de forma secuencial. Para abrirlo, hay que pasarle al constructor de la clase, además del nombre de fichero: el modo de apertura : FileMode.Open, en este caso; hay otros modos de apertura que incluyen Append para añadir y OpenOrCreate, que crearía un fichero si no existe, el tipo de acceso: en este caso es acceso para leer, pero otros modos de acceso incluyen de escritura o combinado de lectura/escritura (ReadWrite ), el modo de compartir : FileShare.Read indica una especie de cerrojo en el fichero, que permite a otros procesos abrirlo para leer, pero no para escribir. Hay otros modos de compartir, por ejemplo, None no permitiría a ningún otro recurso usar el fichero abierto y
y
y
Es una forma un tanto prolija de abrir un fichero, por eso hay formas más simples: la clase tiene constructores que permiten especificar sólo uno de los tres parámetros, y usar los valores por defecto de los otros dos, por ejemplo: FileStream = new newFileStream FileStream (name, FileMode.OpenOrCreate );
En este caso se abriría un fichero (o se crearía si no existiera) con acceso de lectura y escritura, y con modo Read de compartición de recursos. Una vez abierto el fichero, es cuestión de leerlo; como el fichero no tiene estructura, lo más fácil es irlo leyendo byte a byte, y presentándolo en pantalla (o cualquier otra cosa un poco más seria que queramos hacer ). La lectura se realiza en un bucle while, que lee mientras que la longitud Length del canal es mayor que la posición Position del cursor de lectura. Cada byte se lee usando ReadByte( ), una función sin parámetros que devuelve el byte situado en el cursor de lectura en el canal.
Se puede cambiar este fichero a una lectura con buffer, que teóricamente es más eficiente, pero no porque sea más rápida, sino porque es más buena persona con el resto de los recursos del sistema: hace menos llamadas al sistema operativo, porque la lectura la hace a través de lecturas de bloques de bytes: using System; using System.IO;
public class file1a { public static void Main ( string[] args ) { FileStream s2 = new FileStream(args[0], FileMode.Open, FileAccess.Read, FileShare.Read); BufferedStream bs = new BufferedStream( s2 ); while ( bs.Length > bs.Position ) { Console.Write( (char) bs.ReadByte() ); } } }
Sin embargo, hay una forma más eficiente todavía de leer ficheros de texto, y es suponer que efectivamente se trata de ficheros de texto. Lo hacemos en el siguiente ejemplo: using System; using System.IO;
public class file2 { public static void Main ( string[] args) { StreamReader lector=File.OpenText(args[0]); string linea; do { linea = lector.ReadLine(); if ( linea != n ull ) { Console.WriteLine( linea ); } } while( linea !=null); lector.Clo se(); } }
A continuación se muestra un ejemplo donde, cada vez que el programa es ejecutado se sobrescribe el contenido del archivo en caso de que este exista, si no existe se crea: using System; using System.IO;
class App{ public static void Main(){ FileStream f = new FileStream("n uevo.txt", FileMode.Create);
StreamWriter s = new StreamWriter(f); for(int iNumberLine = 1; iNumberLine <= 10; iNumberLine++){ s.WriteLine("Linea " + iN umberLine); } s.Close(); f.Close();
} }
uevo.txt cuyo contenido es: Salida, Archivo N uevo.txt Linea Linea Linea Linea Linea Linea Linea Linea Linea Linea
1 2
3 4 5 6 7 8 9 10
Uso de archivos secuenciales en PHP:
El tratamiento de archivos resulta ser una práctica muy común en cualquier sitio web. Muy a menudo nos vemos en la necesidad de procesar un texto para cambiarle el formato, buscar una cadena en su interior o cualquier otro tipo de operación. PHP propone un sinfín de funciones para la gestión de archivos que van desde las más elementales de apertura, lectura y cierre a otras más rebuscadas como el cálculo de espacio en el disco duro, tamaño del archivo, gestión de derechos de acceso, etc. En este artículo pretendemos mostrar cuáles son las funciones más esenciales para el tratamiento de archivos para posteriormente ejemplificarlas en un par de scripts que nos pueden resultar útiles:
Funciones
de gestión de archivos
Función
Descripción
Sintaxis
copy
Copia un archivo
copy($origen,$destino )
rename
antes a $ despues despues Cambia el nombre del archivo de $ antes
rename($antes,$despues )
unlink
Borra el archivo
unlink($archivo )
Funciones Función
para la lectura de archivos Descripción
Sintaxis
fopen
Abre un archivo y le asigna un identificador id. Veremos el modo más $id = Fopen($archivo, $modo ) adelante
fgets
Lee una línea de un archivo archivo hasta un numero numero máximo de caracteres fgets($id,$max )
fwrite
Escribe una cadena dentro del archivo
fwrite($id, $cadena )
fseek
Avanza o retrocede el puntero del archivo un cierto numero de posiciones
fseek($id,$posiciones )
feof
Comprueba si el puntero que lee el archivo ha llegado al final
feof($id )
fpassthru lee completamente el archivo y lo muestra fclose
Cierra el archivo abierto previamente
fpassthru($id ) fclose($id )
Las operaciones más elementales, copia, borrado y cambiar el nombre, requieren únicamente el nombre (y path ) del archivo sobre el cual se ejerce la operación.
Para operaciones más complejas, como la lectura de líneas o la escritura de texto dentro del archivo, se requiere de una previa apertura del archivo al cual le asignaremos un identificador $ id id . Una vez abierto el archivo, podremos desplazarnos a lo largo de él por medio de un puntero imaginario que avanza o retrocede por las líneas de texto y mediante el cual nos situaremos en el lugar escogido para insertar, modificar o simplemente copiar una cadena. Existen distintos modos de apertura que nos permiten definir las acciones que podemos realizar sobre el archivo. Aquí mostramos los diferentes modos que, como vemos, son de lo más variado: Modos
de apertura de archivos archivos
Sintaxis
Descripción
'r'
Sólo lectura
'r+'
Lectura y escritura
'w'
Sólo escritura
'w+'
Lectura y escritura. Suprime el contenido anterior si se escribe. El archivo es creado si no existe.
'a'
Sólo escritura. El archivo es creado si no existe y el puntero se coloca al final.
'a+'
Lectura y escritura. El archivo es creado si no existe y el puntero se coloca al final.
Para poder abrir un archivo utilizamos la función fopen y posteriormente para leer el contenido de un archivo se realiza mediante la función fgets, esta función se encarga de leer línea a línea el contenido de un archivo texto por lo que su utilización ha de ser incluida dentro de una estructura de tipo bucle. En el ejemplo que mostramos a continuación nos hemos servido de esta lectura secuencial para localizar dentro del texto una cadena cualquiera a la que, a continuación, le cambiamos el formato para ponerla en negrita por medio de la etiqueta
. Esto nos puede resultar útil si llevamos a cabo búsquedas internas en nuestro sitio y queremos resaltar la cadena de búsqueda en el texto de la página encontrada. Evidentemente, la utilidad de fgets resulta ser mucho más amplia. Podemos emplearla, por ejemplo, con archivos remotos para extraer las etiquetas meta o para muchas otras cosas que se nos puedan ocurrir. A continuación se presenta el script:
//Iniciamos //Iniciamos la variable $texto = ""; //Abrimos el archivo en modo lectura $fp = fopen($path,"r"); //Leemos linea por linea el contenido del archivo while ($linea= fgets($fp,1024)) fgets($fp,1024)) { //Sustituimos las ocurrencias de la cadena que buscamos $linea = str_replace($cadena,"$cadena",$linea); //Anadimos la linea modificada al texto $texto .= $linea; } return $texto; } //Definimos el path y la cadena $path="escribe el camino de acceso a tu archivo"; $cadena = "escribe tu cadena"; //Llamamos la funcion $texto = negrita ($path,$cadena); //Mostramos el texto echo $texto; ?>
En este ejemplo se analiza la búsqueda de un registro o renglón determinado. En este proceso el usuario del programa quiere que se despliegue un y solo un registro de información proporcionando un dato da to de búsqueda generalmente la la clave del registro.
Ejemplo: "; echo"| CLAVE | NOMBRE | EDAD | ESTATURA |
"; // leyendo el archivo while (!feof($archivo)){
$clave=fgets($archivo); $nombre=fgets($archivo); $edad=fgets($archivo); $estatura=fgets($archivo); // convirtiendo al mi smo tipo settype($clave,"integer");
// settype($CLAVE,"integer"); if ( $CLAVE == $clave){ // desplegando en celda de ta bla html echo""; echo "| ".$clave." | "; echo "".$nom bre." | "; echo "".$edad." | "; echo "".$e statura." | "; echo"
";}; }; // cerrando archivo y la ta bla html echo "
"; fclose($archivo); }; ?>
Recordar que la característica principal de un archivo secuencial, es que no es posible acceder o accesar a un registro o renglón especifico o determinado sino que se deberá recorrer todos los n-1 renglones anteriores. Esta situación se da porque al construir un registro cualquiera con un montón de campos strings a la hora de almacenar dichos registros, estos registros tendrán tamaños diferentes, esta es la razón principal por la cual al buscar un registro específico se tiene que recorrer y validar todos los registros anteriores. En el programa ejemplo se está usando un ciclo while (!eof(ARCHIVO )) para recorrer todos los registros del archivo (eof=end of file ), por supuesto que si se tiene un archivo con 5000 registro y el buscado es el 4500 al menos se tendrá que recorrer todos los 4499 registros anteriores. Uso de archivos secuenciales en Java:
Existen además muchas otras operaciones asociadas a archivos las mas elementales son: 1.- Creación de Archivo.- En este proceso se pretende solamente crear un archivo nuevo en disco, con su nombre, tipo y especialidad de almacenamiento de datos apropiado. 2.- Apertura de Archivos.- En este caso se pretende abrir un archivo ya existente en disco para procesarlo, ya sea cargar o grabar datos en sus registros, o leer algun registro en especial para mandarlo a una variable de cualquier tipo. No confundir creación con apertura creación es un proceso que solo se ejecuta una sola vez en la vida de un archivo, mientras que apertura siempre se esta realizando por los programas especializados en algun proceso. 3.-Cierre de archivos: Es la operación mas importante en cualquier programa que maneje archivos o se cierra el archivo como ultima instrucción del pograma o se vera el anuncio ABORT,RETRY,FAIL. 4.-Altas en archivo.- En este proceso se carga una clase en memoria con sus datos pertinentes y se graba la clase en el archivo en disco. 5.-Lectura de archivo.- En este proceso, se abre el archivo y se manda el registro de disco, a una clase en memoria para su procesamiento. 6.- Consulta de archivos: En este proceso se pretende desplegar todos los registros del archivo en disco a la pantalla ya sea consola o mejor aún, a una pagina html 7.-Busqueda en archivos: Una de las operaciones mas comunes, consiste en que el usuario pide toda la información de algun renglon en disco, porporcionando la información de algun campo, generalmente el campo clave de la clase. 8.- Filtros.- En este proceso el usuario esta interesado en algun conjunto de renglones con caracteristicas comunes (condición), por ejemplo todos los alumnos de ³sistemas´, o todos los empleados que ganen mas de $500.00 pesos, o todos los clientes que sean de ³tijuana´, etc 9.-Modificaciones de registros o archivos: Problema muy comun, donde los datos originales ya grabados se tienen que cambiar o actualizar, por ejemplo el nombre no era ³juan´ es ³juana´, o la calificación no es 100 es 20, etc. 10.- Bajas de registros: tambien muy comun este proceso por ejemplo el alumno ya egreso, el cliente huyo, etc.
Grabación de archivos secuenciales en Java:
Grabación y lectura son los dos procesos mas comunes con archivos en cualquier lenguaje de programación. Código de grabación: import java.lang.*; import java.io.*; class prog22 { public static void main(String[] arg s) { // crear un objeto de tipo archivo DataOutputStream archivo = n ull; // creando e inicializando lo s campos del registro // observar que se debe usar clases numericas apropiadas int clave=0; String nombre=new String(""); int edad=0; // creando o bjeto teclado BufferedReader teclado = new B ufferedReader(new Inp utStreamReader(System.in)); // abriendo archivo, capt urando y grabando dato s try { //* Creando y gra bando a un archivo, e sta larga la in strucción*/ archivo = new DataO utputStream( FileOutputStream("c:\\pfacil\\archivo1.dat",true) ); System.out.println("dame clave: "); clave = Integer.parseInt(teclado.readLine()); System.out.println("dame nom bre: "); nombre=teclado.readLine(); System.out.println("dame edad: "); edad = Integer.par seInt(teclado.readLine()); //grabando al archivo archivo.writeInt(clave); archivo.writeUTF(nombre);
new
archivo.writeInt(edad); archivo.close(); } catch(FileNotFoundException fnfe) { /* Archivo no e ncontrado */ } catch (IOException ioe) { /* Error al e scribir */ } } // cierra main } // cierra cla se
Lectura de archivos secuenciales en Java: El proceso de lectura de los registros de un archivo secuencial es realmente sencillo, como lo muestra el siguiente código ejemplo: import java.lang.*; import java.io.*; class prog23 { public static void main(String[] arg s) { // crear un objeto de tipo archivo DataInputStream archivo = n ull; // creando e inicializando lo s campos del registro // observar que se debe usar clases numericas apropiadas int clave=0; String nombre=new String(""); int edad=0; try{ //* abriendo archivo para lect ura */ archivo = new DataInp utStream( new FileInp utStream("c:\\pfacil\\archivo1 tStream("c:\\pfacil\\archivo1.dat") .dat") ); //leyendo archivo while (true) { clave=archivo.readInt();
System.out.println(clave+" "); nombre=archivo.readUTF(); System.out.println(nombre+" "); edad=archivo.readInt(); System.out.println(edad+" "); System.out.println('\n'); } } catch(FileNotFoundException fnfe) { /* Archivo no e ncontrado */ } catch (IOException ioe) { /* Error al e scribir */ } // cerrar archivo archivo.close(); } // cierra main } // cierra cla se
Búsqueda
de archivos secuenciales en Java:
El primer proceso para un archivo secuencial es agregar una cantidad indefinida de registros al archivo este proceso se resuelve o ejecutando una cantidad indeterminada de veces el programa de grabación ya hecho o incluir un ciclo while en el mismo programa. Un segundo proceso también común, llamado consulta es desplegar todos los registros del archivo a la vez problema también resuelto en el programa de lectura. El tercer Proceso que ³resolvemos´ en este tema es la búsqueda de un registro determinado, en este proceso el usuario del programa quiere que se despliegue un y solo un registro de información, proporcionando un dato de búsqueda, generalmente la clave del registro. La solución es sencilla, solo tenemos que abrir el archivo para lectura, hacer un ciclo while (true) condicionar y solo desplegar el registro cuando se cumpla la condición. Código: import java.lang.*; import java.io.*; class prog24 {
public static void main(String[] arg s) { // crear un objeto de tipo archivo DataInputStream archivo = n ull; //variables int clave=0; int clavebuscar=0; String nombre=""; int edad=0; // capturando clave a buscar // creando un objeto llamado teclado e specializado en capturas BufferedReader teclado = new B ufferedReader(new Inp utStreamReader(System.in)); // capturando dato s try { System.out.println("dame Clave a buscar: "); clavebuscar = Integer.parseInt(teclado.readLine()); } catch(IOException varia blerror) {System.out.println("error de capt ura "); } //* abriendo archivo para lect ura */ try{ archivo = new DataInp utStream( new FileInp utStream("c:\\pfacil\\archivo1 tStream("c:\\pfacil\\archivo1.dat") .dat") ); //leyendo archiv while (true) { clave=archivo.readInt(); nombre=archivo.readUTF(); edad=archivo.readInt(); if (clavebuscar==clave){ System.out.println(clave+" "); System.out.println(nombre+" "); System.out.println(edad+" ");
System.out.println('\n');}; }; } catch(FileNotFoundException fnfe) { /* Archivo no e ncontrado */ } catch (IOException ioe) { /* Error al e scribir */ } // cerrar archivo archivo.close(); } // cierra main } // cierra cla se
Filtros
o condiciones de archivos secuenciales secuenciales en Java:
Como su nombre lo indica en este proceso se pretende desplegar todo un conjunto de renglones que cumplan con la condición por ejemplo se pide desplegar todos los alumnos de ³sistemas´ o todos los empleados que sean de ³Sinaloa´, etc. Filtros se usan para obtener información acerca de un subconjunto de renglones del archivo. Código: import java.lang.*; import java.io.*; class prog25 { public static void main(String[] arg s) { // crear un objeto de tipo archivo DataInputStream archivo = n ull; //variables int clave=0; String nombre=""; int edad=0; int edadfiltro=0; // capturando condicion // creando un objeto llamado teclado e specializado en capturas BufferedReader teclado = new B ufferedReader(new Inp utStreamReader(System.in));
// capturando dato s try { System.out.print("EDAD >= : "); edadfiltro = Integer.par seInt(teclado.readLine()); } catch(IOException varia blerror) {System.out.println("error de capt ura "); } //* abriendo archivo para lect ura */ try{ archivo = new DataInp utStream( new FileInp utStream("c:\\pfacil\\archivo1 tStream("c:\\pfacil\\archivo1.dat") .dat") ); //leyendo archivo while (true) { clave=archivo.readInt(); nombre=archivo.readUTF(); edad=archivo.readInt(); if (edad >= edadfiltro){ System.out.print(clave+" "); System.out.print(nombre+" "); System.out.print(edad+" "); System.out.print('\n');}; }; } catch(FileNotFoundException fnfe) { /* Archivo no e ncontrado */ } catch (IOException ioe) { /* Error al e scribir */ } // cerrar archivo archivo.close(); } // cierra main } // cierra cla se
Baja
o eliminación de un archivo archivo secuencial en Java:
Eliminar o dar de baja en un archivo secuencial, implica tener que estar procesando dos archivos a la vez, el segundo de ellos es un archivo temporal, un algoritmo de eliminación física quedaría como:
Procedimiento: 1.- Abrir el archivo original en modo lectura. 2.- Abrir un archivo llamado temporal en modo escritura. 3.- Iniciar un ciclo de lectura del archivo original. 3a.- Dentro del ciclo leer el primer registro. 3b.- Validar el registro si no es eliminable, se escribe al archivo temporal. 3c.- Fin de ciclo (cerrar el ciclo). 4.- Cerrar ambos archivos. 5.- eliminar el archivo original. 6.- renombrar el archivo temporal con el nombre de archivo original. Una segunda técnica, consiste en agregar un campo de estado (status ) al registro, tal como se vio en el curso anterior: Sin embargo el proceso de baja se tiene que realizar en un sistema de información, para resolver este problema la respuesta es agregar un campo especial llamado status que puede ser de tipo char, con algunos caracteres de control que se puedan cargar en el por ejemplo una 'a' significa que está en alta, una 'b' significa que está en baja, etc. Lo unico que se tiene que hacer, es que cuando se agrega o manda el registro por primera vez a disco, mandarlo cargado el campo de status con 'a' y estar validando con if siempre este campo en cualquier proceso de búsqueda o condición o despliegue, si se encuentra cargado con 'b' entonces solo avisar al usuario que está de baja dicho registro.´
Operaciones con campos Java: Solo usar los dos archivos el original y el temporal y antes de grabarse al temporal hacer la operación correspondiente, como lo muestra el siguiente ejemplo: import java.lang.*;
import java.io.*; class prog27 { public static void main(String[] arg s) { // crear un objeto de tipo archivo DataInputStream archivo = n ull; DataOutputStream archtemp = n ull; //variables int clave=0; String nombre=""; int edad=0; try { //creando archivo temporal archtemp = new DtaOutputStream( FileOutputStream("c:\\pfacil\\temporal.dat",true) );
new
archivo = new DataInp utStream( new FileInp utStream("c:\\pfacil\\archivo1 tStream("c:\\pfacil\\archivo1.dat") .dat") ); //leyendo archivo while (true) { clave=archivo.readInt(); nombre=archivo.readUTF(); edad=archivo.readInt(); // sumando +10 a la s edades edad=edad+10; //grabando al archivo temporal archtemp.writeInt(clave); archtemp.writeUTF(nombre); archtemp.writeInt(edad); } } catch(IOException varia blerror) { } try { // cerrar archivos
archivo.close(); archtemp.close(); // eliminando original renom brando temporal File file1 = new File("c:\\pfacil\\arch F ile("c:\\pfacil\\archivo1.dat"); ivo1.dat"); File file2 = new File("c:\\pfacil\\temp F ile("c:\\pfacil\\temporal.dat"); oral.dat"); if (file1.exists()) {file1.delete();}; file2.renameTo(file1); // avisando System.out.println("EDADES + 10"); } catch(IOException varia blerror) {System.out.println("ERROR "); } } // cierra main } // cierra cla se
Edición o modificación de archivos secuenciales secuenciales en Java: Editar registros significa cambiar el contenido de algunos de los campos o columnas por nueva información o para corregir algún error de captura original o para agregar alguna columna que no existía por modificación de la tabla o la base de datos. La solución es similar a los temas anterior, es decir se ocupan los dos archivos el original y el temporal y ya sea que se modifique una sola clave o se modifiquen todos los registros, el ejemplo que se construye va mostrando los registros del archivo y pregunta y modifica o edita el registro pedido. Código: import java.lang.*; import java.io.*; class prog28 { public static void main(String[] arg s) { // crear un objeto de tipo archivo DataInputStream archivo = n ull; DataOutputStream archtemp = n ull; //variables int clave=0;
String nombre=""; int edad=0; char opcion ='n'; // creando o bjeto teclado BufferedReader teclado = new B ufferedReader(new Inp utStreamReader(System.in)); try { //creando archivo temporal archtemp = new DataO utputStream( FileOutputStream("c:\\pfacil\\temporal.dat",true) );
new
archivo = new DataInp utStream( new FileInp utStream("c:\\pfacil\\archivo1 tStream("c:\\pfacil\\archivo1.dat") .dat") ); //leyendo archivo while (true) { clave=archivo.readInt(); System.out.print(clave+" "); nombre=archivo.readUTF(); System.out.print(nombre+" "); edad=archivo.readInt(); System.out.print(edad+" "); System.out.print('\n'); System.out.print("editar s/n :"); opcion=(teclado.readLine()).charAt(0); if(opcion=='s'){ System.out.print("dame n uevo nombre: "); nombre=teclado.readLine(); System.out.print("dame n ueva edad: "); edad = Integer.par seInt(teclado.readLine()); }; //grabando al archivo temporal archtemp.writeInt(clave);
archtemp.writeUTF(nombre); archtemp.writeInt(edad); } } catch(IOException varia blerror) { } try { // cerrar archivos archivo.close(); archtemp.close(); // eliminando original renom brando temporal File file1 = new File("c:\\pfacil\\arch F ile("c:\\pfacil\\archivo1.dat"); ivo1.dat"); File file2 = new File("c:\\pfacil\\temp F ile("c:\\pfacil\\temporal.dat"); oral.dat"); if (file1.exists()) {file1.delete();}; file2.renameTo(file1); // avisando System.out.println("YA SE EDITO"); } catch(IOException varia blerror) {System.out.println("ERROR "); } } // cierra main } // cierra cla se
Uso de archivos secuenciales en XML:
Se refiere al procesamiento de los registros, no importa el orden en que se haga, para eso los registros están organizados en forma de una lista y recuperarlos y procesarlos uno por uno de principio a fin.
Rudimentos de los archivos Secuenciales ; dependiendo del dispositivo de almacenamiento utilizado el archivo se puede mostrar el usuario como si fuera un sistema secuencial. Al finalizar un archivo secuencial se denota con una marca de fin de archivo. (End end-of-file) El usuario de un archivo secuancial puede ver los registros en un orden secuancial simple. La única forma de recuperar registros es comenzar al principio y extraerlos en el orden contemplado. < xml="true" ns="urn:schemas-microsoft-co ns="urn:schemas-microsoft-com:office:office" m:office:office" prefix="o" namespace="">
Los archivos secuenciales se denominan de esta manera por que la forma de escribir y leer los datos en un archivo es, desde el principio hasta el fin del archivo, es decir, si yo quisiera acceder a un determinado dato del archivo y este dato se encuentra en la mitad del archivo, para llegar a ese dato necesito pasar por todos los demás datos, de forma secuencial. Por lo general se suelen utilizar los archivos secuenciales, para trabajar con archivos que contengan una estructura de datos no muy compleja.
Append: esta sentencia se utiliza para agregar información a un archivo de texto. Input: la sentencia Input se utiliza para leer datos de un archivo de texto, lee todo el contenido del archivo de una sola ves. Output: esta sentencia se utiliaza para crear un archivo de texto y grabar datos. sentencia Write : escribe datos en un archivo separados por comas. Line Input: lee un archivo de texto línea por línea. Print : para escribir datos en archivos de texto.tos en archivos de texto. EJEMPLO: LO QUE HACE ESTE EJEMPLO ES LEER UN ARCHIVO DE TEXTO Y CUENTA LAS LINEAS DE EL MISMO TEXTO:
*Ponemos un command Button al formulario y a este le agregamos el código así:
*Le ponemos otro command Button que es el de salir con su respectivo código que es end Este es el código que ponemos en el command contar: Public Funtion Contar_Lineas Contar_Lineas (ByVal srtTextFile As string) As Long< xml="true" ns="urn:schemas-micro ns="urn:schemas-microsoft-com:office:offic soft-com:office:office" e" prefix="o" namespace=""> namespace="">
Dim f As Integer Dim lineas As Long Dim srt_Linea As String
Número de archivo libre F = FreeFile
Abre el archive de texto línea por línea hasta el final Do Lee una línea Line input #f, srt_linea
Incrementa Incrementa la cantidad de líneas leídas Lineas = lineas + 1 Leera hasta que llegue al fin de archivo Loop While not EOF(F) Cierra el archive de texto abierto Close #f Retorna a la función el número de líneas del fichero Contar_lineas Contar_lineas = lineas
End Function
Private Sub Command1_Click( )
Dim Path As String Path = InputBox(Ingrese InputBox(Ingrese la ruta de un archivo de texto,_contar texto,_contar lineas) If Path = vbNullString Then Exit sub
MsgBox cantidad de lineas : & contra_lineas(path)
End Sub
Uso de archivos secuenciales en Delphi XE
La creación de un archivo secuencial de transacciones incluye la tarea de recolectar datos, convertir los datos a una forma legible para la máquina, editar los datos, convertir los movimientos rechazados y ordenar los datos editados. Es un sencillo ejemplo que te ayudará a entender cómo se manejan los archivos secuenciales en Delphi. Aquí está el código fuente : DELPHI: 1. unit Unit1; 2.
3. interface 4. 5. uses 6.
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
7.
Dialogs, StdCtrls;
8. 9. type 10.
TForm1 = class(TForm)
11.
Memo: TMemo;
12.
archivo: TEdit;
13.
Button1: TButton;
14.
Button 2: TButton;
15.
Button3: TButton;
16.
Button4: TButton;
17.
Label1: TLabel;
18.
Label2: TLabel;
19.
Label3: TLabel;
20.
Label4: TLabel;
21.
Label5: TLabel;
22.
Label6: TLabel;
23.
letras: TLabel;
24.
digitos: TLabel;
25.
blancos: TLabel;
26.
caracteres: TLabel;
27.
consonantes: TLabel;
28.
vocales: TLabel;
29.
procedure Button4Click(Sender:
30.
procedure Button3Click(Sender:
31.
procedure Button1Click(Sender:
32.
procedure Button2Click(Sender:
33. 34. 35. 36. 37. 38.
private
{ Private declarations } public
{ Public declarations } end;
TObject ); TObject) TObject)); TObject TObject)); TObject TObject)); TObject
39. var 40.
Form1: TForm1;
41. 42. implementation 43. 44. {$R *.dfm} 45. 46. procedure TForm1.Button4Click (Sender:
TObject)); TObject
47. begin 48.
form1.close
49. end; 50. 51. procedure TForm1.Button3Click (Sender:
TObject)); TObject
52. begin 53.
archivo.Text:='';
54.
letras.caption :='';
55.
digitos.caption:='';
56.
blancos.caption:='';
57.
caracteres.caption :='';
58.
vocales.caption:='';
59.
consonantes.caption:='';
60.
memo.Text:='';
61.
memo.SetFocus;
62. end; 63. 64. procedure TForm1.Button1Click (Sender:
TObject)); TObject
65. begin 66.
oadFromFile((archivo.text text)); memo.Lines.LoadFromFile
67. end; 68. 69. procedure TForm1.Button2Click (Sender: 70. var 71.
l,d,b,v,c,ce,a,band:integer ;
72.
x:char ;
73. begin 74.
l:=0;
75.
d:=0;
76.
b:=0;
77.
v:=0;
78.
c:=0;
79.
ce:=0;
80.
a:=0;
81. 82. 83.
while
Text)) do a<>length(memo.Text
begin
84.
band:=0;
85.
a:=a+1;
86.
x:=memo.text text[[a];
TObject)); TObject
87. 88.
if x in
89.
begin
..'Z','a'..'z', 'ñ', 'Ñ','á','é', 'í','ó','ú', 'Á','É', 'Í','Ó', 'Ú' ['A'.. 'Ú']] then
90.
l:=l+1;
91.
band:=1;
end;
92. 93. 94.
if x in
95.
begin
['0'.. '9' '9']] then
96.
d:=d+1;
97.
band:=1;
end;
98. 99.
if x=' ' then
100.
begin
101. 102.
b:=b+1;
103.
band:=1;
end;
104. 105. 106.
if x in
107.
begin
['a','e','i','o','u','A','E','I','O','U','á','é','í','ó','ú','Á','É','Í','Ó','Ú' 'Ú']] then
108.
v:=v+1;
109.
band:=1;
end;
110. 111. 112.
if band=0 then
113.
ce:=ce+1;
114.
end;
115. 116. 117.
letras.caption :=inttostr (l);
118.
digitos.caption:=inttostr (d);
119.
blancos.caption:=inttostr (b);
120.
vocales.caption:=inttostr (v);
121.
consonantes.caption:=inttostr (l-v);
122.
caracteres.caption :=inttostr (ce);
123.
end;
124. 125.
end.
Bibliografía: http://www.mitecnologico.com/Main/EstructuraArchivosOrganizacionSecuencial
http://geneura.ugr.es/~jmerelo/tutoriales/csharp/ http://www.recursosdelweb.com/como-leer-archivos-secuenciales-en-delphi/ http://prograweb.com.mx/pweb/0310Archivos.html http://casidiablo.net/uso-del-objectoutputstream-java/ http://www.canalvisualbasic.net/manual/manual-visual-basic/acceso-datos/ http://www.monografias.com/trabajos28/ficheros-delphi/ficheros-delphi.shtml
