En este proyecto queremos dar un poco de conocimiento sobre variantes, lectura y grabación de los campos de un texto esperamos que les pueda servir de guía e aprendizaje. Gracias

1. UNIVERSIDAD DE PANAMÁ
FACULTAD DE INFORMÁTICA
LIC. En Gerencia de Comercio Electrónico
TEMA
Lectura y Grabación de los Campos de un Archivo
ESTUDIANTE
EDISON ALLARD
Manuel Rodriguez

2. Indice
 Variantes de Formato de un Texto.
 Formato Libre.
 Emcolumnado.
 Formato declimitado.
 Formato de un campo por línea.
 Leer archivos de campos de línea.
 Procedimiento
 Adición de información en un archivo ya existente.
 PROGRAMA ADECUADO PARA LEER REGUISTROS DE UN
ARCHIVO DE TEXTO.
 Leer un formato encolumnado.
 Leer archivos delimitados.
 Leer archivos de campos de línea.

3. ARCHIVOS
FORMATO DE
TEXTO

4. Variantes de un formato de texto
 El formato de texto se presta a una utilización arbitraria por parte
del usuario, ya que la única restricción que se impone es la
relativa a su composición. Un archivo con formato de texto
puede contener líneas de distintas longitudes, y la distribución
del contenido de la línea no está sometida a regla alguna. En
otras palabras, se admite cualquier forma de escritura... pero
esto puede hacer casi imposible la lectura. Si el archivo no sigue
unas pautas regulares, y más aún unas pautas implementables
con relativa facilidad, el problema de la lectura puede volverse
casi insoluble. Para evitar esta dificultad, se suelen utilizar
formatos de archivo como los descritos a continuación, que
hacen posible interpretar el contenido del archivo sin un esfuerzo
excesivo.

5. Formato Libre
 Mencionamos en primer lugar un formato "sin
formato", que suele hallarse en archivos de texto que
contienen, por ejemplo, libros o fragmentos de libros.
En muchos caso, estos archivos se tratan para
extraer léxicos, tecnicismos banales, concordancias y
otros datos de interés filológico. No hay unas reglas
generales para el tratamiento de archivos de este
tipo, más allá de los procedimientos universales de
lectura y escritura de archivos

6. Encolumnado
 Este tipo de archivos suele proceder de programas de cálculo numérico
o de instrumentos de medición. Un posible ejemplo es el que se ve a
continuación:
 1271972SEAT1100.0
 1241968SEAT 855.0
 8501966SEAT 670.0
 15001963SEAT 900.0
 En este archivo hay cuatro registros, uno en cada línea, y cuatro
campos en cada registro. Los tres primeros campos tienen cuatro
columnas de anchura, y el cuarto tiene seis, luego las líneas son de
longitud constante. No hay separador entre campos consecutivos, y es
evidente la necesidad de conocer el tamaño y tipo de los datos para
después efectuar una lectura correcta de los mismos. En este caso,
hemos empleado el formato de escritura %4s%4d%4s%6.1fn ;

7. Formato delimitado
 Se caracteriza por la inserción de un carácter delimitador entre campos
consecutivos del registro. En el ejemplo siguiente,
 127*1972*SEAT*1100.000000
 124*1968*SEAT*855.000000
 850*1966*SEAT*670.000000
 1500*1963*SEAT*900.000000
 Se observan los mismos campos que en el caso anterior, pero han
desaparecido las columnas. Los campos tienen distintas longitudes ("124"
es más corto que "1500") y las líneas, por tanto, no son de igual longitud.
Además, ha aparecido un asterisco (el delimitador) entre campos
consecutivos, aunque no al final de la línea. En este bloque de
información hay cuatro registros, uno en cada línea, al igual que en el
caso anterior (encolumnado). El formato empleado para crear este
archivo es %s*%d*%s*%fn .

8. Formato de un campo por línea.
Como su propio nombre indica, este formato consiste en escribir un campo en cada línea del archivo. La información contenida en
los dos ejemplos anteriores tiene el aspecto siguiente cuando se escribe con formato de un campo por línea:
 127
 1972
 SEAT
 1100.000000
 124
 1968
 SEAT
 855.000000
 850
 1966
 SEAT
 670.000000
 1500
 1963
 SEAT
 900.000000
 En cuanto la especificación de formato empleada para crear este resultado, se trata de %sn%dn%sn%fn , como
cabía esperar. La idea es bien sencilla: se inserta un 'n' detrás de cada campo, sin especificar nada más.

9. Leer archivos de campos de línea
 En cuanto a los archivos de un campo por línea , no hay dificultad:
basta emplear en lectura el mismo formato empleado en escritura,
teniendo en cuenta el retorno de carro.
Lo expuesto servirá como base para la lectura y escritura de los
formatos de texto habituales.

10. procedimiento
 Procedimiento
 En MobileFirst Studio, abra el archivo app.xml para la aplicación que desea actualizar y añada el campo al que
desee aplicar la condición.
 En la sección UI del archivo app.xml, añada un tipo de inicializador de manejador de sucesos a los campos.
 En el elemento <text> del nuevo campo, añada un elemento hijo denominado <eventHandlers>.
 En el elemento <eventHandlers>, añada un elemento hijo denominado <eventHandler>.
 Especifique initialize como el atributo de suceso y añada los atributos de método y clase.
 Por ejemplo, para que el campo Priority sea de sólo lectura para los tipos de trabajo de emergencia, añada un tipo
de inicializador de manejador de sucesos a la vista a la que pertenecen los campos. El suceso que está asociado
con el manejador para la vista Detalles de orden de trabajo se denomina WODetailExtensionHandler.

11. Adición de información en un archivo
ya existente.
 Este proceso es tan sencillo como emplear la opción "a" en el modo de escritura.
Si se ha empleado un programa para crear el archivo al que se quiere añadir
información con formato de texto, todo debería ir bien, porque las reglas de
formación de los tres formatos estudiados (encolumnado, delimitado y de un
campo por línea) exigen que haya un carácter de fin de línea al final de todas las
líneas, y en particular al final de la última línea (registro) del archivo. Si se omite
este marcador de fin de línea, la próxima línea que se añada quedará unida al
último campo, y se habrá roto la regularidad del archivo, con lo cual el proceso de
lectura (que supone que todas las líneas son de un mismo formato) sufrirá un
error. Por tanto, procede comprobar la existencia de este último marcado de fin de
línea antes de realizar la adición de información. Téngase en cuenta que omitir el
fin de línea nno es un error y no será detectado cuando se efectúe la escritura.
Ejemplo .- Construir un programa que escriba en disco todos los registros de una
colección, empleando primero el formato encolumnado, después el delimitado y
finalmente el de un campo por línea.

12. PROGRAMA ADECUADO PARA LEER REGUISTROS DE UN ARCHIVO DE TEXTO
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define NUM_REGISTROS 4
struct Registro {
char modelo[10];
int fecha;
char fabricante[20];
float peso;
};
int main(int argc, char * argv[])
{
struct Registro enc[NUM_REGISTROS] = {
{ "----", 0, "----", 0.0 },
{ "----", 0, "----", 0.0 },
{ "----", 0, "----", 0.0 },
{ "----", 0, "----", 0.0 },
},
del[NUM_REGISTROS] = {
{ "----", 0, "----", 0.0 },
{ "----", 0, "----", 0.0 },
{ "----", 0, "----", 0.0 },
{ "----", 0, "----", 0.0 },
},
uncampo[NUM_REGISTROS] = {
{ "----", 0, "----", 0.0 },
{ "----", 0, "----", 0.0 },
{ "----", 0, "----", 0.0 },
{ "----", 0, "----", 0.0 },
FILE * fp;
char nombre_por_defecto[] = "formatos.txt";
char * p = argc>1 ? argv[1] : nombre_por_defecto;
int i;
char t1[20], t2[20], t3[20], t4[20];
fp = fopen( p, "r");
if (fp == NULL)
{
printf("nnImposible abrir %s - Saliendo.nn", p);
exit(1);
}
else
{
/* Lectura de encolumnados */
for(i=0;i<NUM_REGISTROS;i++)
{
fscanf(fp,"%4c%4d%4c%6f%*c", enc[i].modelo,
&enc[i].fecha,
enc[i].fabricante,
&enc[i].peso);
}
printf("nEncolumnados leídos:nn");
for(i=0;i<NUM_REGISTROS;i++)
{
printf("%s----%d----%s----%fn",enc[i].modelo,
enc[i].fecha,
enc[i].fabricante,
enc[i].peso);
}
/* Lectura de delimitados */
for(i=0;i<NUM_REGISTROS;i++)
{
fscanf(fp,"%[^*]%*c%[^*]%*c%[^*]%*c%[^*n]n",t1, t2, t3,
t4);
/*
Se puede comprobar el contenido de las cadenas leídas.
printf("-->%s....%s....%s....%s<--n", t1, t2, t3, t4);
Es necesario efectuar una transformación al formato
numérico deseado. Obsérvese que se han descartado
los espacios iniciales.
*/
strcpy(del[i].modelo,t1);
del[i].fecha = strtol(t2, NULL, 10);
strcpy(del[i].fabricante, t3);
del[i].peso = strtof(t4, NULL);
}
printf("nDelimitados leídos:nn");
for(i=0;i<NUM_REGISTROS;i++)
{
printf("%s----%d----%s----%fn",del[i].modelo,
del[i].fecha,
del[i].fabricante,
del[i].peso);
}
/* Lectura de un campo por línea */
for(i=0;i<NUM_REGISTROS;i++)
{
fscanf(fp,"%sn%dn%sn%fn", uncampo[i].modelo,
&uncampo[i].fecha,
uncampo[i].fabricante,
&uncampo[i].peso);
}
printf("nUn campo por línea leídos:nn");
for(i=0;i<NUM_REGISTROS;i++)
{
printf("%sn%dn%sn%fn", uncampo[i].modelo,
uncampo[i].fecha,
uncampo[i].fabricante,
uncampo[i].peso);
}
}
return 0;
}
El resultado de ejecutar este programa es el siguiente:
1271972SEAT1100.0
1241968SEAT 855.0
8501966SEAT 670.0
15001963SEAT 900.0
127*1972*SEAT*1100.000000
124*1968*SEAT*855.000000
850*1966*SEAT*670.000000
1500*1963*SEAT*900.000000
127
1972
SEAT
1100.000000
124
1968
SEAT
855.000000
850
1966
SEAT
670.000000
1500
1963
SEAT
900.000000
*/

13. Explicación del ejemplo anterior
 Como puede apreciarse, ha bastado ir modificando la cadena de especificación de formato
empleada, para así obtener una salida encolumnada, delimitada (por asteriscos en este
caso) o de un campo por línea. El formato encolumnado requiere únicamente especificar el
número total de columnas deseado. El formato delimitado requiere especificar el carácter
empleado como separador, que es un asterisco ("*") en este caso. El formato de un campo
por línea, último de los utilizados y el más sencillo de construir, produce resultados de
interpretación menos clara que los anteriores (para un lector humano).
 Bien, ya se sabemos cómo se escribe. Leer es ligeramente más complicado, pero no reviste
especial dificultad.

14. Leer un formato encolumnado
La forma de leer archivos encolumnados es muy
simple: basta especificar, en el formato de lectura, el
número de caracteres que debe admitirse en cada
conversión. Nosotros habíamos empleado cuatro
columnas para todos los campos salvo el de tipo real,
situado en último lugar. Por tanto, especificamos 4
columnas después del signo de % en las tres primeras
conversiones; la última, correspondiente a un campo
float, se detiene automáticamente al llegar al fin de
línea y no precisaría más información, pero hemos
añadido la especificación 6 (en %6f ) para uniformizar
la forma de las especificaciones de acceso. Obsérvese
la necesidad de leer el 'n' final, mediante la
especificación %*c , que sirve precisamente para
descartar un carácter.

15. Leer archivos delimitados
 La forma de leer archivos delimitados (una de las muchas
posibles) es ligeramente distinta. Por poner un ejemplo,
emplearemos las las cadenas temporales t1 , t2 , t3 y t4 con
objeto de almacenar en ellas los resultados de las lecturas,
para después copiar estos valores (previa conversión a un
formato binario cuando se precisa) en los campos
correspondientes de la lista de estructuras. El método de
lectura pasa por utilizar la especificación de formato [] , que
permite leer un carácter tras otro, almacenándolos en la
cadena correspondiente, y se detiene cuando encuentra un
asterisco. También podría emplearse la función strtok() .

16. Leer archivos de campos de línea
 En cuanto a los archivos de un campo por línea , no
hay dificultad: basta emplear en lectura el mismo
formato empleado en escritura, teniendo en cuenta el
retorno de carro.
 Lo expuesto servirá como base para la lectura y
escritura de los formatos de texto habituales.
Considérense también los siguientes

17. Gracias