Permalink
Browse files

Merge branch 'master' of github.com:zipf/perldoc-es

  • Loading branch information...
2 parents 8039555 + 660528a commit ef417603ac162b5176d60af4484f1d6f8f59a5f5 @zipf committed Nov 17, 2012
Oops, something went wrong.
View
@@ -1,6 +1,6 @@
Perl is Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
-by Larry Wall and others. Reservados todos los derechos.
+by Larry Wall and others. Todos los derechos reservados.
@@ -9,69 +9,69 @@ Esta 'hoja resumen' es una referencia útil para programadores principiantes. No
=head2 La hoja
CONTEXTOS SIGILOS ref ARRAYS HASHES
- void $escalar ESCALAR @array %hash
- escalar @array ARRAY @array[0, 2] @hash{'a', 'b'}
- lista %hash HASH $array[0] $hash{'a'}
- &sub CÓDIGO
- *glob GLOB VALORES ESCALARES
- FORMATO número, cadena, ref, glob, undef
+ void $escalar SCALAR @array %hash
+ escalar @array ARRAY @array[0, 2] @hash{'a', 'b'}
+ lista %hash HASH $array[0] $hash{'a'}
+ &sub CODE
+ *glob GLOB VALORES ESCALARES
+ FORMAT número, cadena, ref, glob, undef
REFERENCIAS
- \ referencia $$foo[1] equiv. $foo->[1]
- $@%&* resolver referencia $$foo{bar} equivale a $foo->{bar}
- [] anon. anónimo ${$$foo[1]}[2] equivale a $foo->[1]->[2]
- {} anon. anónimo ${$$foo[1]}[2] equivale a $foo->[1][2]
+ \ referencia $$foo[1] equivale a $foo->[1]
+ $@%&* desreferenciar $$foo{bar} equivale a $foo->{bar}
+ [] ref. array anón. ${$$foo[1]}[2] equivale a $foo->[1]->[2]
+ {} ref. hash anón. ${$$foo[1]}[2] equivale a $foo->[1][2]
\() lista de refs
- NÚMEROS frente a CADENAS VÍNCULOS
- PRIORIDAD OPERADORES = = perldoc.perl.org
+ NÚMEROS CADENAS VÍNCULOS
+ PRECEDENCIA OP. = = perldoc.perl.org
-> + . search.cpan.org
++ -- == != eq ne cpan.org
** < > <= >= lt gt le ge pm.org
! ~ \ u+ u- <=> cmp p3rl.org
=~ !~ perlmonks.org
* / % x SINTAXIS
- + - . foreach (LISTA) { } for (a;b;c) { }
+ + - . foreach (LISTA) { } for (a;b;c) { }
<< >> while (e) { } until (e) { }
ops unarios con nombre if (e) { } elsif (e) { } else { }
< > <= >= lt gt le ge unless (e) { } elsif (e) { } else { }
== != <=> eq ne cmp ~~ given (e) { when (e) {} default {} }
&
- | ^ METACARACTERES EXP. REG. MODIFICADORES EXP. REG.
- && ^ principio cadena /i no distingue may./min.
- || // $ fin cadena (antes \n) /m basado en líneas ^$
- .. ... + una o más /s . incluye \n
- ?: * cero o más /x ignorar espacios
- = += -= *= etc ? cero o una /p preservar
- , => {3,7} repeticiones en rango /a ASCII /aa safe
- ops lista | alternancia /l config. regional /d dual
- not [] clase caracteres /u Unicode
- and \b límite de palabra /e evaluar /ee reevaluar
- or xor \z fin cadena /g global
- () capturar /o compilar patrón una vez
- DEPURACIÓN (?:p) sin captura
- -MO=Deparse (?#t) comentario CLASES CARACTERES EXP. REG.
- -MO=Terse (?=p) inspec. pos. hacia delante . [^\n]
- -D## (?!p) inspec. neg hacia delante \s espacio en blanco
- -d:Trace (?<=p) inspec. pos. hacia atrás \K \w caracteres palabra
- (?<!p) inspec. neg. hacia atrás \d dígitos
- CONFIGURACIÓN (?>p) sin vuelta atrás \pP propiedad con nombre
- perl -V:ivsize (?|p|p) reinicio bifurcación \h espacio en blanco horiz.
- (?<NM>) capturar en nombre \R salto de línea
- \S \W \D \H negar
+ | ^ METACARACTERES EXP. REG. MODIFICADORES EXP. REG.
+ && ^ principio cadena /i no distinguir may./min.
+ || // $ fin cadena (antes \n) /m basado en líneas ^$
+ .. ... + una o más /s . incluir \n
+ ?: * cero o más /x ignorar espacios
+ = += -= *= etc ? cero o una /p preservar
+ , => {3,7} repeticiones en rango /a ASCII /aa seguro
+ ops lista | alternancia /l config. reg. /d dual
+ not [] clase caracteres /u Unicode
+ and \b límite de palabra /e evaluar /ee reevaluar
+ or xor \z fin cadena /g global
+ () capturar /o compilar patrón una vez
+ DEPURACIÓN (?:p) sin captura
+ -MO=Deparse (?#t) comentario CLASES CARACTERES EXP. REG.
+ -MO=Terse (?=p) inspec. pos. delante . [^\n]
+ -D## (?!p) inspec. neg delante \s espacio en blanco
+ -d:Trace (?<=p) inspec. pos. atrás \K \w caracteres palabra
+ (?<!p) inspec. neg. atrás \d dígitos
+ CONFIGURACIÓN (?>p) sin vuelta atrás \pP propiedad con nombre
+ perl -V:ivsize (?|p|p) reinicio bifurcación \h espacio en blanco horiz.
+ (?<NM>) capturar en nombre \R salto de línea
+ \S \W \D \H negar
LISTAS RETORNO FUNCIONES
stat localtime caller VARIABLES ESPECIALES
0 dev 0 segundo 0 paquete $_ variable predeterminada
1 ino 1 minuto 1 nombre archivo $0 nombre programa
2 mode 2 hora 2 línea $/ separador entrada
- 3 nlink 3 día 3 subrutina $\ separador entrada
+ 3 nlink 3 día 3 subrutina $\ separador salida
4 uid 4 mes-1 4 hasargs $| volcado automático
5 gid 5 año-1900 5 wantarray $! error de sys/libcall
- 6 rdev 6 día semana 6 evaltext $@ error eval
- 7 size 7 día año 7 is_require $$ Id. proceso
- 8 atime 8 is_dst 8 hints $. número de línea
- 9 mtime 9 máscara bits @ARGV args línea comandos
- 10 ctime 10 hash de pistas @INC rutas de inclusión
- 11 blksz 3..10 solo @_ args subroutina
- 12 blcks con EXPR %ENV entorno
+ 6 rdev 6 día semana 6 evaltext $@ error eval
+ 7 size 7 día año 7 is_require $$ Id. proceso
+ 8 atime 8 is_dst 8 hints $. número de línea
+ 9 mtime 9 máscara bits @ARGV args línea comandos
+ 10 ctime 10 hash de pistas @INC rutas de inclusión
+ 11 blksz 3..10 solo @_ args subroutina
+ 12 blcks con EXPR %ENV entorno
=head1 AGRADECIMIENTOS
@@ -4,11 +4,11 @@ perlclib - Sustitutos internos de funciones de la biblioteca estándar de C
=head1 DESCRIPCIÓN
-Una cosa que los I<Perl porters> deben tener en cuenta es que F<perl> no tienden a utilizar internamente la mayor parte de la biblioteca estándar de C; verá muy poco uso de ella de, por ejemplo, las funciones F<ctype.h>. Esto se debe a que Perl tiende a reimplementar o abstraer funciones de la biblioteca estándar, y así sabemos exactamente cómo van a operar.
+Los miembros del equipo de desarrollo principal (I<Perl porters>) deben tener en cuenta que en F<perl> no se usa mucho la biblioteca estándar de C internamente; por ejemplo, F<ctype.h> se usa muy poco. Esto se debe a que en el desarrollo de Perl se ha seguido la tendencia de reimplementar o abstraer funciones de la biblioteca estándar, para controlar cómo van a funcionar exactamente.
-Esta es una tarjeta de referencia para las personas que están familiarizados con la biblioteca C y que quieren hacer cosas al estilo Perl; decirles qué funciones deben usar en lugar de las funciones de C más comunes.
+Este documento es una hoja de referencia para programadores que conocen la biblioteca de C y desean hacer las cosas al estilo de Perl. Indica las funciones que deben usar en lugar de las funciones de C de uso común.
-=head2 Congresos
+=head2 Convenciones
En las tablas siguientes:
@@ -36,9 +36,9 @@ C<sv>, C<av>, C<hv>, etc. representan variables de sus tipos respectivos.
=head2 Operaciones con archivos
-En lugar de las funciones de F<stdio.h> debe usar la capa de abstracción de Perl. En lugar de tipos C<FILE*> debe manipular tipos C<PerlIO*>. No hay que olvidar que con la nueva capa de abstracción PerlIO, los tipos C<FILE*> pueden incluso estar no disponibles. Vea también la documentación de C<perlapio> para obtener más información acerca de las siguientes funciones:
+En lugar de las funciones de F<stdio.h> debe usar la abstracción de capas de Perl. En lugar de tipos C<FILE*> debe manipular tipos C<PerlIO*>. No olvide que con PerlIO, la nueva abstracción de E/S en capas, los tipos C<FILE*> podrían no estar disponibles. Vea también la documentación de C<perlapio> para obtener más información acerca de las siguientes funciones:
- En lugar de: Use:
+ En lugar de: Use:
stdin PerlIO_stdin()
stdout PerlIO_stdout()
@@ -49,17 +49,17 @@ En lugar de las funciones de F<stdio.h> debe usar la capa de abstracción de Per
fflush(stream) PerlIO_flush(perlio)
fclose(stream) PerlIO_close(perlio)
-=head2 Entrada y salida de archivo
+=head2 Entrada/salida de archivo
- En lugar de: Use:
+ En lugar de: Use:
fprintf(stream, fmt, ...) PerlIO_printf(perlio, fmt, ...)
[f]getc(stream) PerlIO_getc(perlio)
[f]putc(stream, n) PerlIO_putc(perlio, n)
ungetc(n, stream) PerlIO_ungetc(perlio, n)
-Nótese que los equivalentes de PerlIO C<fread> y C<fwrite> son ligeramente diferentes de sus homólogos de la biblioteca de C:
+Tenga en cuenta que en PerlIO las funciones equivalentes a C<fread> y C<fwrite> son ligeramente distintas de sus homólogas de la biblioteca de C:
fread(p, size, n, stream) PerlIO_read(perlio, buf, numbytes)
fwrite(p, size, n, stream) PerlIO_write(perlio, buf, numbytes)
@@ -72,7 +72,7 @@ No existe nada equivalente a C<fgets>; en su lugar, debe usar C<sv_gets>:
=head2 Posición en archivo
- En lugar de: Use:
+ En lugar de: Use:
feof(stream) PerlIO_eof(perlio)
fseek(stream, n, whence) PerlIO_seek(perlio, n, whence)
@@ -86,28 +86,28 @@ No existe nada equivalente a C<fgets>; en su lugar, debe usar C<sv_gets>:
=head2 Administración de memoria y manipulación de cadenas
- En lugar de: Use:
+ En lugar de: Use:
- t* p = malloc(n) Newx(id, p, n, t)
- t* p = calloc(n, s) Newxz(id, p, n, t)
- p = realloc(p, n) Renew(p, n, t)
- memcpy(dst, src, n) Copy(src, dst, n, t)
- memmove(dst, src, n) Move(src, dst, n, t)
- memcpy(dst, src, sizeof(t)) StructCopy(src, dst, t)
- memset(dst, 0, n * sizeof(t)) Zero(dst, n, t)
- memzero(dst, 0) Zero(dst, n, char)
- free(p) Safefree(p)
+ t* p = malloc(n) Newx(id, p, n, t)
+ t* p = calloc(n, s) Newxz(id, p, n, t)
+ p = realloc(p, n) Renew(p, n, t)
+ memcpy(dst, src, n) Copy(src, dst, n, t)
+ memmove(dst, src, n) Move(src, dst, n, t)
+ memcpy(dst, src, sizeof(t)) StructCopy(src, dst, t)
+ memset(dst, 0, n * sizeof(t)) Zero(dst, n, t)
+ memzero(dst, 0) Zero(dst, n, char)
+ free(p) Safefree(p)
- strdup(p) savepv(p)
- strndup(p, n) savepvn(p, n) (¡Eh, strndup no existe!)
+ strdup(p) savepv(p)
+ strndup(p, n) savepvn(p, n) (Atención: strndup no existe)
- strstr(big, little) instr(big, little)
- strcmp(s1, s2) strLE(s1, s2) / strEQ(s1, s2) / strGT(s1,s2)
- strncmp(s1, s2, n) strnNE(s1, s2, n) / strnEQ(s1, s2, n)
+ strstr(big, little) instr(big, little)
+ strcmp(s1, s2) strLE(s1, s2) / strEQ(s1, s2) / strGT(s1,s2)
+ strncmp(s1, s2, n) strnNE(s1, s2, n) / strnEQ(s1, s2, n)
-Observe el diferente orden de los argumentos de C<Copy> y C<Move> de los que se usan en C<memcpy> y C<memmove>.
+Observe que el orden de los argumentos de C<Copy> y C<Move> es distinto del de los argumentos de C<memcpy> y C<memmove>.
-La mayoría de las veces, sin embargo, querrá estar tratando con SV internamente en lugar de con crudas cadenas de caracteres C<char *>:
+Sin embargo, generalmente deseará manipular valores SV internamente, en lugar de manipular cadenas C<char *> sin procesar:
strlen(s) sv_len(sv)
strcpy(dt, src) sv_setpv(sv, s)
@@ -116,20 +116,20 @@ La mayoría de las veces, sin embargo, querrá estar tratando con SV internament
strncat(dt, src) sv_catpvn(sv, s)
sprintf(s, fmt, ...) sv_setpvf(sv, fmt, ...)
-Tenga en cuenta también la existencia de C<sv_catpvf> y C<sv_vcatpvfn> , que combina la concatenación con el formateo.
+Tenga en cuenta que también están disponibles C<sv_catpvf> y C<sv_vcatpvfn>, que combinan la concatenación con la aplicación de formato.
-A veces, en lugar de poner a cero el montón asignado mediante el uso de Newxz() podría considerar el caso del "envenenamiento" de datos. Esto significa escribir un patrón de bits dentro de él, que debería formar punteros (y números de punto flotante) ilegales, y también esperamos algo lo suficientemente sorprendente, como números enteros, de modo que cualquier código de intente utilizar esos datos sin precaución se rompa lo más pronto posible. El envenenamiento puede hacerse utilizando las macros Poison(), que tienen argumentos similares a Zero():
+A veces, en lugar de inicializar en cero el montículo (I<heap>) asignado mediante Newxz(), podría preferir la opción de "envenenar" los datos. El envenenamiento de datos consiste en escribir en los datos un patrón de bits que no que sean válidos como punteros (ni como números de punto flotante), ni (esperamos que de forma sorprendente) como enteros, a fin de que todo código que intente usar los datos sin la preparación necesaria genere un error cuanto antes. El envenenamiento se puede realizar mediante las macros Poison(), que tienen argumentos similares a los de Zero():
- PoisonWith(dst, n, t, b) garabatea la memoria con el byte b
- PoisonNew(dst, n, t) igual a PoisonWith(dst, n, t, 0xAB)
- PoisonFree(dst, n, t) igual a PoisonWith(dst, n, t, 0xEF)
- Poison(dst, n, t) igual a PoisonFree(dst, n, t)
+ PoisonWith(dst, n, t, b) "garabatea" el byte b en la memoria
+ PoisonNew(dst, n, t) igual que PoisonWith(dst, n, t, 0xAB)
+ PoisonFree(dst, n, t) igual que PoisonWith(dst, n, t, 0xEF)
+ Poison(dst, n, t) igual que PoisonFree(dst, n, t)
=head2 Pruebas de clases de caracteres
-Hay dos tipos de pruebas de clases de caracteres que Perl implementa: un tipo maneja C<char> y por tanto B<no> son compatibles con Unicode (y por lo tanto, obsoletas a menos que B<sepa> que debe usarlas) y el otro tipo maneja los C<UV> y conoce las propiedades Unicode. En la tabla siguiente, C<c> es un C<char> y C<u> es un código de carácter Unicode.
+Perl implementa dos tipos de pruebas de clases de caracteres: las de un tipo usan variables C<char> y, por tanto, B<no> son compatibles con Unicode (y, en consecuencia, son obsoletas a menos que B<esté seguro> de que debe usarlas) y las del otro tipo usan variables C<UV> y saben lo que son las propiedades Unicode. En la tabla siguiente, C<c> es un C<char> y C<u> es un código de carácter Unicode.
- En lugar de: Use: O mejor:
+ En lugar de: Use: O mejor:
isalnum(c) isALNUM(c) isALNUM_uni(u)
isalpha(c) isALPHA(c) isALPHA_uni(u)
@@ -148,31 +148,31 @@ Hay dos tipos de pruebas de clases de caracteres que Perl implementa: un tipo ma
=head2 Funciones de F<stdlib.h>
- En lugar de: Use:
+ En lugar de: Use:
atof(s) Atof(s)
atol(s) Atol(s)
- strtod(s, &p) Ninguno. No la use.
+ strtod(s, &p) Ninguna. No la use.
strtol(s, &p, n) Strtol(s, &p, n)
strtoul(s, &p, n) Strtoul(s, &p, n)
-Tenga en cuenta también las funciones C<grok_bin>, C<grok_hex> y C<grok_oct> en F<numeric.c> para convertir cadenas que representan números en sus respectivas bases dentro de los C<NV>.
+También están disponibles las funciones C<grok_bin>, C<grok_hex> y C<grok_oct> de F<numeric.c> para convertir cadenas que representan números en sus respectivas bases en valores C<NV>.
-En teoría C<Strtol> y C<Strtoul> pueden no estar definidas si la máquina que contiene el perl compilado en realidad no tiene a strtol y strtoul. Pero como esas 2 funciones son parte de la especificación 1989 ANSI C, sospechamos que, por ahora, las encontrará en todas partes.
+En teoría, C<Strtol> y C<Strtoul> no se pueden definir si el equipo en el que se ha compilado perl no dispone de strtol y strtoul. Pero como estas dos funciones forman parte de la especificación de ANSI C del año 1989, sospechamos que actualmente estarán disponibles en todas partes.
int rand() double Drand01()
srand(n) { seedDrand01((Rand_seed_t)n);
PL_srand_called = TRUE; }
exit(n) my_exit(n)
- system(s) No. Mire pp_system o use my_popen
+ system(s) No la use. Vea pp_system o use my_popen
getenv(s) PerlEnv_getenv(s)
setenv(s, val) my_putenv(s, val)
=head2 Funciones varias
-Ni siquiera debería B<querer> usar las funciones F<setjmp.h>, pero si piensa hacerlo, utilice en su lugar la pila C<JMPENV> de F<scope.h>.
+B<Ni se le ocurra> usar las funciones de F<setjmp.h>. Si esto no le disuade de sus intenciones, al menos plantéese usar la pila C<JMPENV> de F<scope.h> en su lugar.
Para C<signal>/C<sigaction>, use C<rsignal(signo, handler)>.
@@ -43,7 +43,7 @@ Si todo funciona bien, la situación puede cambiar al actualizar perl (como mín
=item *
-Las versiones más recientes de Perl incorporan más correcciones de errores.
+Las versiones más recientes de perl incorporan más correcciones de errores.
=item *
@@ -189,7 +189,7 @@ Es posible que estos vínculos le resulten de utilidad:
=head1 AUTOR Y COPYRIGHT
-Copyright (c) 1997-2010 Tom Christiansen, Nathan Torkington y otros autores indicados. Reservados todos los derechos.
+Copyright (c) 1997-2010 Tom Christiansen, Nathan Torkington y otros autores indicados. Todos los derechos reservados.
Esta documentación es libre; puede redistribuirla o modificarla en los mismos términos que Perl.
Oops, something went wrong.

0 comments on commit ef41760

Please sign in to comment.