archivos secuanciales con lenguajes

5/13/2018 archivos secuanciales con lenguajes - slidepdf.com

http://slidepdf.com/reader/full/archivos-secuanciales-con-lenguajes 1/27

Administración y organización de datos

Archivos secuenciales en diferentes lenguajes deprogramación

Diego Abraham Ramírez García 10231174



ARCHIVO SECUENCIAL EN C#

El tipo de acceso simple a un archivo de datos es el secuencial, un archivo que puede

almacenar registros de cualquier magnitud. Cuando la información se escribe registro a

registro, estos son colocados de uno en uno y cuando se leen se empieza por el primero y

se continúa hasta el último. Este acceso utiliza dos archivos de texto en los que se

escribe información desde el principio hasta el final y se lee igual que el secuencial. Encambio los archivos de texto no son los mas apropiados para almacenar grandes series

de números porque cada numero es almacenado como una secuencia byte.

Primero necesitamos saber que la clase Stream pertenece al namespace System.IO,

debemos importar dicho namespace antes de comenzar.

using System.IO;

static void Main(string[] args)

{

string ruta = "c:\\archivo.txt";

StreamWriter escritor = new StreamWriter(ruta);

escritor.WriteLine("Aquí ira el texto que nosotros queremos");

escritor.Close();

}

Este método crea el archivo de texto, y dentro de el podemos escribir.

StreamReader lector = new StreamReader(ruta);

Console.WriteLine(lector.ReadToEnd());

lector.Close();

Console.ReadLine();



Método StreamReader para leer un archivo de texto. Recuerden que siempre que utilizen

un stream deben cerrarlo con el método Close(); para que puedan ocupar dicho archivo y

no esté solo como solo lectura o que otro programa esté utilizandolo.

Pero si queremos añadir más cosas como:

private const string DIR_ARCHIVO = "c:\\archivo.txt";

Agregar una constante en donde irá la ruta del archivo.

if (File.Exists(DIR_ARCHIVO))

{}

Una condición que deterimine si el archivo existe o no.

if (File.Exists(DIR_ARCHIVO))

{

Console.WriteLine("{0} ya existe." ,DIR_ARCHIVO);

Console.WriteLine("---------------------------");

using (StreamReader lector = new StreamReader(DIR_ARCHIVO))

{

Console.WriteLine(lector.ReadToEnd());

}

Console.ReadLine();

Si existe entonces leerá el archivo, de lo contrario, lo creará:

using (StreamWriter escritor = File.CreateText(DIR_ARCHIVO))

{



escritor.WriteLine("Ejemplo de StreamWriter");

escritor.WriteLine("{0} {1} {2}", 21, 31.1, 000.334445);

escritor.Close();

ARCHIVOS SECUANCIALES EN XML

Como primer paso debemos tener un archivo XML que nos sirva para probar nuestra aplicación.

Podemos crearlo con el código detallado abajo con el nombre de XMLPrueba.xml. Debemos crear

este archivo en un editor como el NotePad, ya que necesitamos un archivo sin caracteres extraños.

Texto Plano

VB.NET:

<?xml version="1.0" encoding="UTF-8"?>

<usuarios>

<name codigo="mtorres"><nombre>Maria </nombre>

<apellido>Torres </apellido>

</name>

<name codigo="cortiz">

<nombre>Carlos </nombre>

<apellido>Ortiz </apellido>

</name>

</usuarios>

Luego de tener nuestro archivo XML creado podremos crear nuestro código en VB.NET

Utilizando el XMLTextReader

Este formato es muy sencillo y para leer el achivo XML debemos hacerlo secuencialmente, línea

por línea.

Texto Plano

VB.NET:

Imports System.IO

Imports System.Xml

Module ParsingUsingXmlTextReader

Sub Main()

Dim m_xmlr As XmlTextReader

'Creamos el XML Reader

m_xmlr = New XmlTextReader("C:\XMLPrueba.xml")

'Desabilitamos las lineas en blanco,

'ya no las necesitamos

m_xmlr.WhiteSpaceHandling = WhiteSpaceHandling.NONE

http://empresario.mx/programacion/net/leer-un-archivo-en-xml-con-xml-xmltextreader-y-xmldocument/






'Leemos el archivo y avanzamos al tag de usuarios

m_xmlr.Read()

'Leemos el tag usuarios

m_xmlr.Read()

'Creamos la secuancia que nos permite

'leer el archivo

While Not m_xmlr.EOF

'Avanzamos al siguiente tag

m_xmlr.Read()

'si no tenemos el elemento inicial

'debemos salir del ciclo

If Not m_xmlr.IsStartElement() Then

Exit WhileEnd If

'Obtenemos el elemento codigo

Dim mCodigo = m_xmlr.GetAttribute("codigo")

'Read elements firstname and lastname

m_xmlr.Read()

'Obtenemos el elemento del Nombre del Usuario

Dim mNombre = m_xmlr.ReadElementString("nombre")

'Obtenemos el elemento del Apellido del Usuario

Dim mApellido = m_xmlr.ReadElementString("apellido")

'Escribimos el resultado en la consola,

'pero tambien podriamos utilizarlos en

'donde deseemos

Console.WriteLine("Codigo usuario: " & mCodigo _

& " Nombre: " & mNombre _

& " Apellido: " & mApellido)

Console.Write(vbCrLf)End While

'Cerramos la lactura del archivo

m_xmlr.Close()

End Sub

End Module



Utilizando el XmlDocument

Este formato es mas complejo y nos permite recorrer los nodos sin tener que utilizar una lectura

secuencial. Definitivamente este formato es más eficiente que el anterior principalmente para

documentos XML muy grandes.

Texto Plano

VB.NET:

Imports System.IO

Imports System.Xml

Module ParsingUsingXmlDocument

Sub Main()

Try

Dim m_xmld As XmlDocument

Dim m_nodelist As XmlNodeList

Dim m_node As XmlNode

'Creamos el "XML Document"

m_xmld = New XmlDocument()

'Cargamos el archivo

m_xmld.Load("C:\XMLPrueba.xml")

'Obtenemos la lista de los nodos "name"

m_nodelist = m_xmld.SelectNodes("/usuarios/name")

'Iniciamos el ciclo de lectura

For Each m_node In m_nodelist 'Obtenemos el atributo del codigo

Dim mCodigo = m_node.Attributes.GetNamedItem("codigo").Value

'Obtenemos el Elemento nombre

Dim mNombre = m_node.ChildNodes.Item(0).InnerText

'Obtenemos el Elemento apellido

Dim mApellido = m_node.ChildNodes.Item(1).InnerText

'Escribimos el resultado en la consola, 'pero tambien podriamos utilizarlos en

'donde deseemos

Console.Write("Codigo usuario: " & mCodigo _

& " Nombre: " & mNombre _

& " Apellido: " & mApellido)

Console.Write(vbCrLf)





Next

Catch ex As Exception

'Error trapping

Console.Write(ex.ToString())

End Try

End Sub

End Module

Enlaces que te pueden interesar:

ARCHIVOS SECUANCIALES EN JAVA

// Una clase que representa un registro de información.

import java.io.Serializable;

public class RegistroCuentas implements Serializable

{

private int cuenta;

private String primerNombre;

private String apellidoPaterno;

private double saldo;

// el constructor sin argumentos llama al otro constructor con valores predeterminados

public RegistroCuentas()

{

this( 0, "", "", 0.0 );

}

// inicializar un registro

public RegistroCuentas( int cta, String nombre, String apellido, double sald )



{

establecerCuenta( cta );

establecerPrimerNombre( nombre );

establecerApellidoPaterno( apellido );

establecerSaldo( sald );

}

// establecer número de cuenta

public void establecerCuenta( int cta )

{

cuenta = cta;

}

// obtener número de cuenta

public int obtenerCuenta()

{

return cuenta;

}

// establecer primer nombre

public void establecerPrimerNombre( String nombre )

{

primerNombre = nombre;

}

// obtener primer nombre

public String obtenerPrimerNombre()

{

return primerNombre;



}

// establecer apellido paterno

public void establecerApellidoPaterno( String apellido )

{

apellidoPaterno = apellido;

}

// obtener apellido paterno

public String obtenerApellidoPaterno()

{

return apellidoPaterno;

}

// establecer saldo

public void establecerSaldo( double sald )

{

saldo = sald;

}

// obtener saldo

public double obtenerSaldo()

{

return saldo;

}

} // fin de la clase RegistroCuentas

Existen ademas muchas 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.

98, /s, scandisk

4.-Altas en archivo.- En este proceso se carga una clase en memoria con sus datospertinentes 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 “sisJAVA TEMA s”,

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.

Delphi xe2



En Delphi los ficheros y archivos pueden ser de dos tipos: ficheros en formato ASCII o

ficheros en formato binario y pueden, a su vez, organizarse de dos formas diferentes: en

forma secuencial o en forma indexada. En un fichero secuencial todos los componentes

del fichero se almacenan secuencialmente uno después del otro.

En este trabajo se aborda cómo se crean y utilizan en Delhi tanto los ficheros en formato

ASCII como en formato binario organizados secuencialmente, ya que para almacenar

datos con estructura indexada es mucho más cómodo hacerlo usando bases de datos, las

cuales Delphi maneja a la perfección.

Ficheros en formato ASCII.

Los ficheros en formato ASCII son los más sencillos de todos. Se puedenvisualizar con el Bloc de Notas de Windows y suelen llevar extensión txt.

Un fichero de este tipo puede definirse fácilmente declarando al identificador quelo representa de tipo texto. Esta declaración puede expresarse como:

Var Nombre del fichero : TextFile

Para leer o escribir datos en un fichero con formato ASCII se deben dar lossiguientes pasos:

Indicarle a Delphi que se trata de un fichero de tipo texto.

Declarar las variables que se usarán para leer o escribir datos en el fichero.Estas variables deben ser de tipo String ya que se trata de un fichero enformato ASCII.

Indicarle a Delphi como se llama el fichero y con que nombre se conocerá en elprograma para lo cual se emplea la función AssignFile.

Se abre el fichero en el modo en el que se desea trabajar:

Modo lectura. Se indica con la orden Reset.

Modo escritura para añadir datos. Se indica con la orden Append.

Modo reescritura para crear el fichero y si este existía con anterioridadsobrescribirlo. Se indica con la orden Rewrite.

Cerrar el fichero una vez concluido el proceso de lectura o escritura. Se indicacon la orden CloseFile.

Ejemplo:Los siguientes procedimientos permiten crear el fichero Grupo,almacenar en él los nombres de los estudiantes que lo integran y recuperar luegoel listado.

Procedure CrearFichero;

Var

Datos : TextFile;begin

AssignFile (Datos, 'Grupo.txt');

Rewrite (Datos);

CloseFile (Datos);

end;

Procedure EscribirDatos (Nombre : String);

http://www.monografias.com/trabajos34/el-trabajo/el-trabajo.shtml

http://www.monografias.com/trabajos15/todorov/todorov.shtml

http://www.monografias.com/trabajos15/ms-windows/ms-windows.shtml


http://www.monografias.com/trabajos13/libapren/libapren.shtml

http://www.monografias.com/trabajos12/guiainf/guiainf.shtml

http://www.monografias.com/Computacion/Programacion/

http://www.monografias.com/trabajos7/mafu/mafu.shtml

http://www.monografias.com/trabajos14/textos-escrit/textos-escrit.shtml

http://www.monografias.com/trabajos16/metodo-lecto-escritura/metodo-lecto-escritura.shtml

http://www.monografias.com/trabajos14/administ-procesos/administ-procesos.shtml

http://www.monografias.com/trabajos13/mapro/mapro.shtml

http://www.monografias.com/trabajos14/dinamica-grupos/dinamica-grupos.shtml

http://www.monografias.com/trabajos34/el-trabajo/el-trabajo.shtml

http://www.monografias.com/trabajos15/todorov/todorov.shtml


http://www.monografias.com/trabajos13/libapren/libapren.shtml

http://www.monografias.com/trabajos12/guiainf/guiainf.shtml

http://www.monografias.com/Computacion/Programacion/


http://www.monografias.com/trabajos14/textos-escrit/textos-escrit.shtml

http://www.monografias.com/trabajos16/metodo-lecto-escritura/metodo-lecto-escritura.shtml

http://www.monografias.com/trabajos14/administ-procesos/administ-procesos.shtml


http://www.monografias.com/trabajos14/dinamica-grupos/dinamica-grupos.shtml



Var

Datos : TextFile;

begin


Append (Datos);

Writeln (Datos, Nombre);CloseFile (Datos);

end;

Procedure LeerDatos;

Var

Datos : TextFile;

I : Integer;

begin


Reset (Datos);

I := 1;While Not Eof (Datos) do

begin

Readln (Datos, Nombre[I]);

Inc (I);

end;

CloseFile (Datos);

end;

Antes de usarlos, declare el arreglo Nombre de tipo String.

La función Eof permite conocer si se llegó o no al final del fichero respondiendo

True en caso positivo y False en caso contrario.Para conocer el número de registros que existen en un fichero, se puede utilizar lasiguiente función:

Function ContarRegistros : Integer;

Var

Cantidad : Integer;

Datos : TextFile;

Linea : String;

begin

Cantidad := 0;

AssignFile (Datos, 'Grupo.txt');Reset (Datos);

While Not Eof (Datos) do

begin

Readln (Datos, Linea);

Inc (Cantidad);

end;

CloseFile (Datos);

http://www.monografias.com/trabajos7/regi/regi.shtml

http://www.monografias.com/trabajos7/regi/regi.shtml



ContarRegistros := Cantidad;

end;

Ficheros en formato binario.Los ficheros en formato binario solo pueden ser leídos por el programa que loscreó o por uno que se programe para leerlos. La manera más sencilla de definirloses incluir la definición del fichero como parte de una declaración de variable detipo fichero. La forma general de esta declaración es:

Var Nombre del fichero: File of tipo

donde tipo se refiere al tipo de dato de los componentes individuales del fichero.

La ventaja con respecto a los ficheros en formato ASCII es que se puede contar con dos funciones que no existían en estos: FileSize y FilePos.

La primera de ellas retorna el número de registros que existen en el fichero y lasegunda la posición actual del puntero dentro del fichero.

Los componentes individuales del fichero pueden ser de tipo simple o de tipoestructurado. En este último caso se debe declarar primero la estructura de datos

y luego indicarle al fichero que use esa estructura.Ejemplo: Los siguientes procedimientos permiten crear el fichero Información,almacenar en él el nombre y el número del carné de identidad de un grupo deestudiantes y luego recuperar esa información.

Procedure CrearFichero;

Var

Datos : File of TListado;

begin

AssignFile (Datos, ‘Informacion.fic’);

Rewrite (Datos);

CloseFile (Datos);end;

Procedure EscribirDatos (NuevaInformacion : TListado);

Var


begin

AssignFile (Datos, ‘Informacion. fic’);

Reset (Datos);

Seek (Datos,FileSize (Datos));

Write (Datos, NuevaInformacion);

CloseFile (Datos);end;

Procedure LeerDatos;

Var


I : Integer;

begin

AssignFile (Datos, ‘Informacion. fic’);


http://www.monografias.com/trabajos7/sisinf/sisinf.shtml

http://www.monografias.com/trabajos14/cambcult/cambcult.shtml


http://www.monografias.com/trabajos7/sisinf/sisinf.shtml

http://www.monografias.com/trabajos14/cambcult/cambcult.shtml



Reset (Datos);

For I := 1 to FileSize (Datos) do

Read (Datos, Listado [I]);

CloseFile (Datos);

end;

Antes de usarlos declare el tipo de dato TListado.Type

TListado = Record

Nombre : String [50];

NumeroIdentidad : Real;

end;

y la variable Listado como un arreglo de tipo Tlistado.

La función Seek permite recorrer el fichero avanzando el puntero dentro delmismo.

Para copiar el contenido de un fichero en otro, se puede utilizar el siguiente

procedimiento:Procedure CopiarFichero;

Var

FicheroOrigen, FicheroDestino : File of TListado;

Contenido : TListado;

begin

AssignFile (FicheroOrigen, ‘Informacion.fic');

Reset (FicheroOrigen);

AssignFile (FicheroDestino, 'Copia.fic');

Rewrite (FicheroDestino);

While Not Eof (FicheroOrigen) dobegin

Read (FicheroOrigen, Contenido);

Write (FicheroDestino, Contenido);

end;

CloseFile (FicheroOrigen);

CloseFile(FicheroDestino);

end;

Delphi XE.Declaración e inicialización de variables

Para la declaración de variables os valemos de las siguientes sintaxis:

var

<Nombre de variable> : <Tipo de variable>

<Nombre de variable 1>, <Nombre de variable 2>, … <Nombre de variable n> : <Tipo de variable>





Para inicializar las variables recién creadas:

<Nombre de Variable> := <Valor>

Tabla de Operadores con asociatividad y precedencia

Operadores

Asociatividad

+

Por la Izquierda

-

Por la Izquierda

*

Por la Izquierda

/

Por la Izquierda

divPor la Izquierda

mod

Por la Izquierda

Orden de

Precedencia

1

2

3

4

5

Estructurasdedecisión eiteraci

Significado



ón

Antes

de

iniciar

con las

estructu

ras de

decisión

e

iteración

, se

debe

conocer

los

operado

res delas

condicio

nes que

son la

base de

las dos

siguient

es

estructu

ras a

ver.

Hay que

tener

claro

que la

diferenci

a entre

‘=’ y “:=”

es, que

el

primerocompar

a dos

variable

s y el

segund

o es

una



asignaci

ón de

valores.

A

continuación se

present

a una

tabla

con los

operado

res para

cuando

hay más

de una

condición a

evaluar.

Operad

or

> Mayor que

< Menor que

>=Mayor o Igual

que

<=Menor o Igual

que= Igual

<> Distinto de

Operad

or

Significad

o

AND “y” lógico

OR “o” lógico

NOT negación



Decisión

Uso del If

If condición (es) then

Begin

Bloque de Instrucciones;

End

Else

Begin

Bloque de Instrucciones;

End



Uso del Case

Case <variable> of

Constante1: Begin

Instrucciones;

End;

Constante2: Begin

Instrucciones;

End;

Constante3: Begin

Instrucciones;

End;

Else

Begin

Instrucciones;

End;

Iteración

Ciclo For

For <variable> := valor inicial To valor final Do

Begin

Instrucciones;

End

Ciclo Repeat Until

Repeat

Instrucciones;

*Instrucción de salida del Ciclo;

Until (Condición);

Declaración, definición y uso de métodos y funciones



Delphi por supuesto tiene lo que es el uso de funciones y Procedimientos, ahora definiremos por

separado cada uno de estos módulos.

Procedimientos:

Es un modulo de un programa que realiza tareas especificas y que no puede regresar valores a la

parte principal del programa u otro procedimiento que lo esté invocando.

Declaración y Definición de los Procedimientos.

Procedure <Nombre del procedimiento>

Var

{Lista de variables locales}

Begin

{Bloque instrucciones}

End;

Este esquema de la definición y declaración se hace en la sección de ‘VAR’ del programa principal.

Uso.

Simplemente en el programa principal se copia el nombre del procedimiento previamente definido

en el lugar donde se le requiera.

Funciones:

Una función es un modulo de un programa separado del cuerpo principal, que realiza una tarea

específica y que puede regresar un valor a la parte principal del programa u otra función o

procedimiento que la invoque.

Declaración y Definición de las Funciones.

Function<Nombre de la Funcion> ( Parametros): <Tipo de Dato a retomar>;

Var

{Lista de variables locales}

Begin

{Bloque de instrucciones}

<Nombre de la Funcion> := Instrucción; Aquí ocurre el famoso ‘return’ de las funciones

End;

Este esquema de la definición y declaración se hace en la sección de ‘VAR’ del programa principal.

Uso.

Simplemente en el programa principal se hace el llamado a función.



Implementación y uso de la Programación Orientada aObjetos

Generalmente la POO se asocia rápidamente con lenguajes como C++, pero Object

Pascal, de ahí su nombre cuenta con todos los componentes básicos de un lenguaje

orientado a objetos con la encapsulación, la herencia y el polimorfismo.

Comenzando con el concepto de encapsulación de datos que trata básicamente de

encerrar un conjunto de datos dentro de un objeto que sólo los métodos del propio podrá

manipular. Para eso se hace uso de la palabra reservada ‘Type’.

type

{<Nombre del Objeto> = Object}

Persona = Object

{Atributos}

nombre:String[25];

private apellido:String[25];

{Procedimientos y Funciones}

procedure init(name:String;apell:String);

procedure nombreCompleto;

procedure setApellido(apell:String);

function getNombre:String;

{fin del type}

end;

Ahora solo falta definir las funciones y procedimientos del Object ‘Persona’, Observe que

un atributo tiene la palabra reservada de Private, esta palabra hace que el atributo solopueda ser accesado o modificado por medio de métodos del propio Objeto. El primer

atributo se asume que es un atributo público es decir que puede ser modificado y/o

accesado sin necesidad de métodos. A continuación se definen los procedimientos y

funciones del objeto.

var

procedure Persona.init;

begin

nombre:=name;

setApellido(apell);

end;

procedure Persona.nombreCompleto;

begin

writeln(Nombre,' ',getApellido);

end;



procedure setApellido;

begin

apellido := apel;

end;

function Persona.getApellido:String;

begin

getApellido:= apellido;

end;

La definición de las funciones y procedimientos se hace en la sección ‘var’ del ‘main’ y la

diferencia está en que el nombre de la función o del procedimiento siempre es precedido

por el Nombre del objeto más punto.

Ejemplo:

Persona.setApellido

Persona.nombreCompleto

Otro aspecto a destacar es que tanto las funciones como los procedimientos, en el

momento de definirlos no es necesario copiar la lista de parámetros que necesiten y en el

caso de las funciones no es necesario escribe ‘: <tipo que retornan>’ porque ya están

encapsulados en el type.

Ahora para las herencias sencillamente donde se crea es esqueleto en el Type se hace lo

siguiente:

Type

Padre = Object

{esqueleto de la clase Padre};

end;

Hijo = Object (Padre)

{esqueleto de la clase Hijo};

end;

Var

{definiciones de los procedimientos y funciones de Padre};

{definiciones de los procedimientos y funciones de Hijo};

Una recomendación es que los métodos comunes entre el padre y el hijo se debendeclarar y definir en el padre, porque esos métodos se heredan de manera implícita en el

hijo, dejando solamente la tarea de declarar y definir los métodos únicos del hijo.

Por último falta mencionar la declaración del polimorfismo, básicamente es una herencia

múltiple de un padre a varios hijos, acá se usa la palabra reservada ‘virtual’. Este hace

que los métodos (procedimientos y funciones) comunes entre el padre y el hijo puedan

sobrescribirse. Básicamente permite que si hay un padre que hereda a varios hijos un



método en común pero que cada método según el hijo funciona de manera diferente,

puedan ser definidos en cada hijo usando siempre el mismo nombre.

PHPLa API de Secuencias de PHP introduce un enfoque unificado a la gestión de archivos y

sockets en extensiones PHP. Usando una API única con funciones estándar para

operaciones comunes, la API de secuencias le permite a su extensión acceder a archivos,

sockets, URLs, memoria y objetos definidos por-script. Esta es una API extensible de

tiempo de ejecución que permite la carga dinámica de módulos (¡y scripts!) para registrar

nuevas secuencias.

El propósito de la API de secuencias es facilitar la apertura de archivos, URLs y otras

fuentes de datos secuenciables a los desarrolladores, mediante una API unificada que es

fácil de entender. La API se encuentra más o menos basada en la familia de funciones

ANSI C stdio (con una semántica idéntica para la mayoría de sus funciones principales),así que los progamadores de C tendrán una sensación de familiaridad con las secuencias.

La API de secuencias opera en un par de niveles diferentes: al nivel base, la API define

objetos php_stream para representar fuentes de datos secuenciables. En un nivel

ligeramente más alto, la API define objetos php_stream_wrapper que "envuelven" la API

de nivel más bajo para proveer soporte para la recuperación de datos y meta-datos desde

URLs. Un parámetro de contexto adicional, aceptado por la mayoría de funciones de

creación de secuencia, es pasado al método stream_opener de la envoltura para

configurar en detalle el comportamiento de la misma.

Cualquier secuencia, una vez abierta, puede tener también cualquier número de filtrosaplicados sobre ella, los cuales procesan datos en la medida en que éstos son leídos

desde/escritos hacia la secuencia.

Las secuencias pueden ser moldeadas (convertidas) a otros tipos de gestores de archivo,

de modo que puedan ser usadas con bibliotecas externas sin mucho problema. Esto

permite que aquellas bibliotecas accedan a datos directamente desde fuentes tipo URL. Si

su sistema tiene la función fopencookie() o funopen(), ¡puede pasar incluso cualquier

secuencia PHP a cualquier biblioteca que use stdio ANSI!

El uso de secuencias es bastante similar al uso de funciones stdio ANSI. La principal

diferencia está en el modo en que obtiene en un principo el gestor de la secuencia. En lamayoría de casos, usted usará php_stream_open_wrapper() para obtener el gestor de

secuencia. Esta función trabaja de forma muy similar a fopen, y puede apreciarse en el

siguiente ejemplo:

Secuencia que despliega la página de inicio de PHP



php_stream * stream = php_stream_open_wrapper("http://www.php.net", "rb",

REPORT_ERRORS, NULL);

if (stream) {

while(!php_stream_eof(stream)) {

char buf[1024];

if (php_stream_gets(stream, buf, sizeof(buf))) {

printf(buf);

} else {

break;

}

}

php_stream_close(stream);

}

Todas las secuencias son registradas como recursos cuando son creadas. Esto asegura

que sean limpiadas apropiadamente incluso si ocurre un error fatal. Todas las funciones

del sistema de archivos en PHP operan sobre recursos de secuencia - lo que quiere decir

que sus extensiones pueden aceptar apuntadores de archivo PHP normales como

parámetros también, y devolver secuencias desde sus funciones. La API de secuencias

hace este proceso tan simple como es posible:

Cómo aceptar una secuencia como parámetro

PHP_FUNCTION(ejemplo_escribir_hola)

{

zval *zstream;

php_stream *stream;



if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r",

&zstream))

return;

php_stream_from_zval(stream, &zstream);

/* ahora puede usar la secuencia. Sin embargo, usted no es el

"duenyo" de la secuencia, lo es el script. Eso quiere decir que

usted NO DEBE cerrar la secuencia, ya que producira un fallo en

PHP! */

php_stream_write(stream, "hola\n");

RETURN_TRUE();

}

Cómo devolver una secuencia desde una función

PHP_FUNCTION(ejemplo_abrir_pagina_php)

{

php_stream *stream;

stream = php_stream_open_wrapper("http://www.php.net", "rb", REPORT_ERRORS,

NULL);

php_stream_to_zval(stream, return_value);

/* despues de este punto, el duenyo de la secuencia es el



script. Si la cierra ahora, hara que PHP falle! */

}

En algunos casos, es útil mantener una secuencia abierta durante la duración de unapetición, para actuar como un registro o rastrear un archivo, por ejemplo. Escribir el

código necesario para limpiar de manera segura ese tipo de secuencia no es difícil, pero

se trata de varias líneas de código que no es estrictamente necesario. Para evitarse los

problemas de escribir aquél código, puede marcar una secuencia para que sea apta para

una auto-limpieza. Lo que quiere decir esto es que la API de secuencias no emitirá una

advertencia cuando sea momento de auto-limpiar una secuencia. Para hacer esto, puede

usar php_stream_auto_cleanup().

php_stream_stat_path -- Obtiene el status de un archivo o URL

php_stream_stat -- Obtiene el status del almacenamiento interno asociado con unasecuencia

php_stream_open_wrapper -- Abre una secuencia sobre un archivo o URL

php_stream_read -- Leer un número de bytes desde una secuencia a un búfer

php_stream_write -- Escribir un númedo de bytes desde un búfer a una secuencia

php_stream_eof -- Chequear por una condición de fin-de-archivo en una secuencia

php_stream_getc -- Leer un byte único desde una secuencia

php_stream_gets -- Leer una línea de datos desde una secuencia a un búfer

php_stream_close -- Cerrar una secuencia

php_stream_flush -- Volcar los búferes de secuencia a la unidad de almacenamiento

php_stream_seek -- Reubicar una secuencia

php_stream_tell -- Determinar la posición de una secuencia

php_stream_copy_to_stream -- Copiar datos de una secuencia a otra

php_stream_copy_to_mem -- Copiar datos de una secuencia en un búfer reservado

php_stream_make_seekable -- Convertir una secuencia a una secuencia reubicable

php_stream_cast -- Convertir una secuencia a otra forma, como un FILE* o un socket

php_stream_can_cast -- Determina si una secuencia puede ser convertida en otra forma,

como un FILE* o un socket



php_stream_is_persistent -- Determina si una secuencia es persistente

php_stream_is -- Determina si una secuencia es de un tipo particular

php_stream_passthru -- Imprime todos los datos restantes de una secuencia

php_register_url_stream_wrapper -- Registra una envoltura con la API de Secuencias

php_unregister_url_stream_wrapper -- Retira el registro de una envoltura de la API de

Secuencias

php_stream_open_wrapper_ex -- Abre una secuencia sobre un archivo o URL,

especificando el contexto

php_stream_open_wrapper_as_file -- Abre una secuencia sobre un archivo o URL, y lo

convierte a FILE*

php_stream_filter_register_factory -- Registra una fábrica de filtros con la API de

Secuencias

php_stream_filter_unregister_factory -- Retira el registro de una fábrica de filtros con la

API de secuencias

Documents

archivos secuanciales con lenguajes