Linux && PHP @ NomikOS – BLOG » PHP

Torpedos, chuletas y cheat-sheets para el desarrollador web cojonudo, bacancito y cool.

NomikOS — Thu, 01 Jul 2010 01:25:35 +0000

Aquí hay una buena muestra de las materias que debes conocer como desarrollador web. Imprímelas y pégalas en la puerta del baño, de manera que puedas estudiarlas mientras meditas en la levedad del ser. Ni se te ocurra linkear directamente a estas imágenes porque ando escaso de ancho de banda. Asi que si pasas por aquí de visita por favor entra sin comida ni mascotas –a menos que sean gatos. Cada una tiene una referencia para dar crédito a quien se lo merezca.

Expresiones regulares

http://www.addedbytes.com/cheat-sheets/regular-expressions-cheat-sheet/

mod_rewrite – Módulo Apache

http://www.addedbytes.com/cheat-sheets/mod_rewrite-cheat-sheet/

CSS – Hojas de estilo en cascadas

http://www.addedbytes.com/cheat-sheets/css-cheat-sheet/

Javascript – Lenguaje de programación para navegadores web

http://www.addedbytes.com/cheat-sheets/javascript-cheat-sheet/

Subversion (svn) – Sistema de control de versiones

http://www.addedbytes.com/cheat-sheets/subversion-cheat-sheet/

Git – Sistema de control de versiones distribuido

http://zrusin.blogspot.com/2007/09/git-cheat-sheet.html/

PHP – Lenguaje de programación web

http://www.addedbytes.com/cheat-sheets/php-cheat-sheet/

MySQL – Base de datos relacional

http://www.addedbytes.com/cheat-sheets/mysql-cheat-sheet/

Unix / Linux Shell Scripting Tutorial

http://gdf.tricon.hu/linux/segedanyag/SteveParker/sh.shtml

Bash – Shell para comunicarse con linux

http://weblog.topopardo.com/?p=1389

Bash Cheat Sheet por Tim Gurney
(Un resúmen en una sóla página.)

BASH Programming – Introduction HOW-TO por Mike G
(Un resúmen avanzado, excelente como primer tutorial.)

Advanced Bash-Scripting Guide por Mendel Cooper
(Este es el mejor, completísimo y entretenido)

vim (vi) – Editor de texto para consola

http://www.viemu.com/a_vi_vim_graphical_cheat_sheet_tutorial.html

vim – Carta de referencia rápida

http://tnerual.eriogerg.free.fr

Movimiento básico
`h l k j`	caracter izq., derecha; línea arriba, abajo
`b w`	palabra/símbolo izquierda, derecha
`ge e`	fin de palabra/símbolo izquierda, derecha
`{ }`	principio del anterior, siguiente párrafo
`( )`	comienzo de anterior, siguiente oración
`0 gm`	principio, medio de la línea
`^ $`	primer, último caracter de la línea
`nG ngg`	línea n. por defecto la primera, última
`n%`	porcentaje n del archivo (n es obligatorio)
`n\|`	columna n de la línea actual
`%`	siguiente llave, paréntesis, comentario, `#define`
`nH nL`	línea n desde el principio, medio de la ventana
`M`	medio de la ventana
Inserción & sustitución → modo insertar
`i a`	insertar antes, después del cursor
`I A`	insertar al principio, fin de la línea
`gI`	insertar texto en la primera columna
`o O`	insertar nueva línea abajo, arriba de la actual
`rc`	sustituir caracter bajo el cursor por c
`grc`	como `r`, pero sin afectar el diseño
`R`	sustituir caracteres a partir del cursor
`gR`	como `R`, pero sin afectar el diseño
`cm`	cambiar texto del comando de deplazamiento m
`cc or S`	cambiar línea actual
`C`	cambiar hasta el fin de la línea
`s`	cambiar un caracter e insertar
`~`	invertir mayúscula/minúscula y avanzar el cursor
`g~m`	invertir mayús/minús del movimiento m
`gum gUm`	minúscula, mayúscula texto movimiento m
`<m >m`	desplazar izq., der. texto del movimiento m
`n<< n>>`	desplazar n líneas a la izquierda, derecha
Borrado
`x X`	eliminar caracter sobre, previo al cursor
`dm`	eliminar texto de comando de movimiento m
`dd D`	eliminar línea actual, hasta fin de línea actual
`J gJ`	juntar linea actual con la siguiente, sin espacio
`:rd↵`	eliminar rango r de líneas
`:rdx↵`	eliminar rango r de líneas al registro x
Modo insertar
`^Vc ^Vn`	insertar caracter c literal, con valor decimal n
`^A`	insertar último texto insertado
`^@`	igual que `^A` y detener inserción → modo comando
`^Rx ^R^Rx`	insertar contenido de registro x, literal
`^N ^P`	completar texto antes, luego del cursor
`^W`	eliminar palabra anterior al cursor
`^U`	eliminar todo el texto insertado en la línea actual
`^D ^T`	desplazar linea a la izquierda, derecha
`^Kc1c2 or c1←c2`	entrar dígrafo \c1,c2\
`^Oc`	ejecutar c en modo de temporal de comando
`^X^E ^X^Y`	scrollear arriba, abajo
`or ^[`	salir del modo edición → modo comando
Copiado
`"x`	usar registro x para la siguiente acción
`:reg↵`	mostrar contenido de todos los registros
`:reg x↵`	mostrar contenido de los registros x
`ym`	copiar texto del movimiento m
`yy or Y`	copiar línea actual al registro
`p P`	pegar registro antes, despues del cursor
`]p [p`	como `p`, `P` pero ajustando la sangría
`gp gP`	igual, pero cursor queda luego de texto nuevo
Inserción avanzada
`g?m`	realizar codificación rot13 en movimiento m
`n^A n^X`	incrementar/disminuir numero bajo el cursor
`gqm`	formatear línea de movimiento m a ancho fijo
`:rce w↵`	centrar líneas en rango r a ancho w
`:rle i↵`	alinear izq. lineas en rango r con sangría i
`:rri w↵`	alinear der. lineas en rango r con ancho w
`!mc↵`	aplicar comando c al movimiento m
`n!!c↵`	aplicar comando c a siguientes n lineas
`:r!c↵`	aplicar comando c a rango de líneas r
Modo visual
`v V ^V`	empezar/terminar marca caract, líneas, bloque
`o`	cursor de selección al principio/fin del marcado
`gv`	empezar a marcar utilizando última zona marcada
`aw as ap`	seleccionar una palabra, oración, párrafo
`ab aB`	seleccionar un bloque ( ), un bloque `{` `}`
Deshacer, repetir & registros
`u U`	deshacer último comando, restaurar última línea
`. ^R`	repetir últimos cambios, rehacer último deshacer
`n.`	repetir últimos cambios n veces
`qc qC`	grabar, agregar teclas tipeadas en registro c
`q`	detener grabación
`@c`	ejecutar el contenido del registro c
`@@`	repetir comando `@` anterior
`:@c↵`	ejecutar registro c como un comando Ex
`:rg/p/c↵`	ejecutar comando Ex c en rango r
	donde se cumpla el patrón p
Movimiento complejo
`- +`	línea arriba, abajo al primer caracter no blanco
`B W`	siguiente, anterior palabra separada por espacio
`gE E`	fin de anterior, siguiente palabra espaciada
`n_`	al primer caracter no blanco en linea n-1 debajo
`g0`	principio de la línea en pantalla
`g^ g$`	primer, último caracter de la línea en pantalla
`gk gj`	línea en pantalla arriba, abajo
`fc Fc`	siguiente, anterior ocurrencia del caracter c
`tc Tc`	antes de la siguiente, anterior occurencia de c
`; ,`	repetir última `fFtT`, en dirección opuesta
`[[ ]]`	comienzo de la sección hacia atrás, adelante
`[] ][`	fin de la sección hacia atrás, adelante
`[( ])`	seccion (, ) abierta hacia atrás, adelante
`[{ ]}`	seccion `{`, `}` abierta hacia atrás, adelante
`[m ]m`	comienzo de método Java hacia atrás, adelante
`[# ]#`	`#if`, `#else`, `#endif` abierto atrás, adelante
`[* ]*`	principio, fin de `/* */` hacia atrás, adelante
Búsqueda & sustitución
`/s↵ ?s↵`	buscar s hacia adelante, atrás
`/s/o↵ ?s?o↵`	buscar s adelante, atrás con desplaz. o
`n or /↵`	repetir última búsqueda hacia adelante
`N or ?↵`	repetir última búsqueda hacia atrás
`# *`	buscar adelante, atrás palabra sobre cursor
`g# g*`	igual, pero buscar tambien resultados parciales
`gd gD`	definición local, global de símbolo sobre cursor
`:rs/f/t/x↵`	sustituir f por t en rango r
	x: `g`-todas las ocurrencias, `c`-confirmar cambios
`:rs x↵`	repetir sustitución con nuevo r & x
Caracteres especiales en patrones de busqueda
`. ^ $`	caracter simple; comienzo, fin de línea
`\< \>`	comienzo, fin de palabra
`[c1-c2]`	caracter simple en el rango c1..c2
`[^c1-c2]`	caracter simple no en el rango c1..c2
`\i \k \I \K`	identificador, palabra clave; excl. dígitos
`\f \p \F \P`	nombre arch, car. imprim.; ign. dígitos
`\s \S`	espacio en blanco, no espacio en blanco
`\e \t \r \b`	, , <↵>, <←>
`\= * \+`	0..1, 0..∞, 1..∞ del átomo anterior
`\\|`	separar dos ramas ( ≡ o)
``	agrupa patrones en un átomo
`\& \n`	todo el patrón encontrado, grupo no `()`
`\u \l`	próximo caracter a mayúscula, minúscula
Desplazamientos en comandos de búsqueda
`n or +n`	n líneas hacia abajo en columna 1
`-n`	n líneas hacia arriba en columna 1
`e+n e-n`	n caract. der., izq de comienzo del matcheo
`s+n s-n`	n caract. der., izq. del final del matcheo
`;sc`	ejecutar comando de búsqueda sc a continuación
Marcas y movimiento
`mc`	marcar posición actual con marca c ∈[a..Z]
`c `C	ir a marca c en archivo actual, cualquier archivo
`0..9	ir a última posición de salida
`` `"	ir a posición antes del salto, de última edición
`[ `]	ir al principio, fin del último texto operado
`:marks↵`	mostrar lista de marcas activas
`:jumps↵`	mostrar lista de saltos
`n^O`	ir a la na posición más vieja de la lista de saltos
`n^I`	ir a la na posición más nueva de la lista de saltos
Mapeo de teclas & abreviaciones
`:map c e↵`	mapear c ↦ e. modo normal & visual
`:map! c e↵`	map. c ↦ e. modo insertar & comandos
`:unmap c↵ :unmap! c↵`	borrar mapeo c
`:mk f↵`	guardar mapeos actuales en archivo f
`:ab c e↵`	agregar abreviatura para c ↦ e
`:ab c↵`	mostrar abreviaturas que empiezan con c
`:una c↵`	borrar abreviatura c
Etiquetas
`:ta t↵`	saltar a etiqueta t
`:nta↵`	saltar a la na etiqueta mas nueva
`^] ^T`	saltar a etiqueta sobre cursor, volver de etiqueta
`:ts t↵`	listar etiquetas que matchean y elegir una
`:tj t↵`	saltar a etiqueta o elegir una si varias cumplen
`:tags↵`	mostrar lista de etiquetas
`:npo↵ :n^T↵`	saltar desde, hacia n^va etiqueta vieja
`:tl↵`	saltar a última etiqueta que matchea
`^W} :pt t↵`	vista previa etiqueta sobre cursor, etiq. t
`^W]`	separar ventana y mostrar etiqueta sobre el cursor
`^Wz or :pc↵`	cerrar vista previa de etiquetas
Scrolleo & ventanas
`^E ^Y`	scrollear una línea arriba, abajo
`^D ^U`	scrollear media página arriba, abajo
`^F ^B`	scrollear una página arriba, abajo
`zt or z↵`	poner línea actual al principio de la ventana
`zz or z.`	poner línea actual al centro de la ventana
`zb or z-`	poner línea actual al final de la ventana
`zh zl`	scrollear un caracter a la derecha, izquierda
`zH zL`	scrollear media pantalla a la derecha, izquierda
`^Ws or :split↵`	dividir ventana en dos
`^Wn or :new↵`	crear nueva ventana vacía
`^Wo or :on↵`	hacer ventana actual única en la pantalla
`^Wj ^Wk`	pasar a la ventana de abajo, arriba
`^Ww ^W^W`	pasar a la ventana de abajo, arriba (ciclíco)
Comandos Ex (↵)
`:e f`	editar archivo f, a menos que hayan cambios
`:e! f`	editar archivo f siempre (recargar el actual)
`:wn :wN`	guardar archivo y editar siguiente, anterior
`:n :N`	editar archivo siguiente, anterior de la lista
`:rw`	guardar rango r en archivo actual
`:rw f`	guardar rango r a archivo f
`:rw>>f`	agregar rango r al archivo f
`:q :q!`	salir y confirmar, salir e ignorar cambios
`:wq or :x or ZZ`	guardar archivo actual y salir
	recordar comandos anteriores (historial)
`:r f`	insertar contenido archivo f debajo del cursor
`:r! c`	insertar salida del comando c debajo del cursor
`:all`	abrir una vent. por cada arch. pasado en los arg.
`:args`	mostrar lista de argumentos
Rangos Ex
`, ;`	separa dos números de línea, primera linea
`n`	número de linea absoluto n
`. $`	línea actual, última linea del archivo
`% *`	todo el archivo, toda el área visual
`'t`	posición de la marca t
`/p/ ?p?`	la próxima, anterior línea que cumple con p
`+n -n`	+n, -n al numero de línea predecesor
Pliegues (folding)
`zfm`	crear pliegue del movimiento m
`:rfo`	crear pliegue para el rango r
`zd zE`	borrar pliegue activo, todos los de la ventana
`zo zc zO zC`	abrir, cerrar un pliegue; recursivamente
`[z ]z`	ir al comienzo, fin del pliegue actual
`zj zk`	ir abajo, arriba del comienzo, fin de sig. pliegue
Misceláneas
`:sh↵ :!c↵`	correr shell, ejecutar comando c
`K`	buscar palabra sobre el cursor con `man`
`:make↵`	correr `make`, leer errores y saltar al primero
`:cn↵ :cp↵`	mostrar el siguiente, anterior error
`:cl↵ :cf↵`	listar errores, leer errores de archivo
`^L ^G`	redibujar pant., mostrar nombre archivo y pos.
`g^G`	mostrar columna, línea, palabra, byte actual
`ga`	mostrar código ASCII del caracter actual
`gf`	abrir archivo con nombre debajo del cursor
`:redir>f↵`	redirigir salida al archivo f
`:mkview [f]`	guardar config. de vista [en archivo f]
`:loadview [f]`	cargar config. de vista [de archivo f]
`^@ ^K ^_ \ Fn ^Fn`	teclas no mapeadas

jQuery 1.4 – Biblioteca y framework javascript

http://www.scribd.com/doc/32981686/jQuery-Visual-Cheat-Sheet-1-4-2

jQuery 1.4 API Cheat Sheet

Ext – Framework javascript para aplicaciones web (RIA)

http://devcheatsheet.com/tag/ext-js/

Cloud computing – Servicios web sobre demanda

http://www.scribd.com/doc/25033275/DZone-Refcard-82-Getting-Started-with-Cloud-Computing

Escabilidad y alta disponibilidad

http://www.scribd.com/doc/12910002/Refcard-43-Scalability-High-Availability

Primeros pasos con AJAX

http://www.scribd.com/doc/7470987/Refcardz-02-Getting-Started-With-Ajax

Selectores jQuery

http://www.scribd.com/doc/7471024/Refcardz-07-jQuery-Selectors

Patrones de diseño

http://www.scribd.com/doc/7471031/Refcardz-08-Design-Patterns

CSS Core 1

http://www.scribd.com/doc/7407101/Refcardz-19-Core-CSS-Part-1

CSS Core 2

http://www.scribd.com/doc/7407114/Refcardz-25-Core-CSS-Part-2

Posts relacionados:

phpMyAdmin – Mostrar todos los registros y otras configuraciones ocultas.

phpMyAdmin – Mostrar todos los registros y otras configuraciones ocultas.

NomikOS — Wed, 09 Jun 2010 17:55:19 +0000

phpmyadmin es muy mezquino al momento de listar registros de tablas, por defecto muestra sólo de a 30. Hay una manera de mostrar todos los registros apretando un botón.

En el archivo de configuración de phpmyadmin config.inc.php puedes agregar este valor:

1	$cfg['ShowAll'] = true;

Ahora tienes el botón [Show all] o [Mostrar todo]:

Puedes usarlo con confianza con hasta 3000 registros (dependiendo de la cantidad de columnas) –con demasiados puedes quedarte esperando eternamente.

Otros valores interesantes:

1
2
3
4
5
6

# Máximo de registros al listar tablas
$cfg['MaxRows'] = 300;
# Guardar en un log todas las consultas hechas
$cfg['QueryHistoryDB'] = TRUE;
# Si usas lo anterior conviene limitar el largo del log
$cfg['QueryHistoryMax'] = 100;

Estos y otros valores por defecto están definidos en libraries/config.default.php. Para cambiarlos copialos a config.inc.php.

Y dónde está config.inc.php?:

Sí los has instalado automáticamente, como por ejemplo con apt-get:

1	$ find /etc -name config.inc.php

Si no, busca donde lo instalaste (¬_¬), debiera estar en el directorio raíz de phpmyadmin. Si sólo encuentras config.sample.inc.php, cópialo a config.inc.php y ponle bueno.

Más info en http://wiki.phpmyadmin.net/pma/Config

Posts relacionados:

Función PHP para obtener IP del cliente.

NomikOS — Wed, 02 Jun 2010 16:47:09 +0000

Obtener la dirección IP del cliente sirve para muchas cosas, por ejemplo para guardarla en logs de acceso.

1
2
3
4
5

function getIp()
{
$hostip = @gethostbyname($_SERVER['REMOTE_ADDR']);
return long2ip(ip2long($hostip));
}

Pero también es muy útil para realizar depuración remota:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# anotar mi IP
$ip = 'xxx.xxx.xxx.xxx';

# si no estoy en localhost
if ($_SERVER['REMOTE_ADDR'] != '127.0.0.1')
# comparar con mi IP
if ($this->getIp() != $ip)
{
# si no coincide matar ejecucuón
die('x_x morí en la línea ' . __line__ . ' del archivo ' . __file__);

# o más grácilmente
return;
}

Como obtener IP propia

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# en linux
$ ifconfig
eth1 Link encap:Ethernet HWaddr e0:cb:4e:d4:e0:10
# aqui está
inet addr:xxx.xxx.xxx.xxx Bcast:190.100.123.255 Mask:x.x.x.x
inet6 addr: xxxx::xxxx:xxxx:xxxx:xxxx/xx Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:809347 errors:0 dropped:0 overruns:0 frame:0
TX packets:25086 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:75990540 (75.9 MB) TX bytes:2637607 (2.6 MB)
Interrupt:27 Base address:0x2000
lo Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
inet6 addr: ::1/128 Scope:Host
UP LOOPBACK RUNNING MTU:16436 Metric:1
RX packets:25 errors:0 dropped:0 overruns:0 frame:0
TX packets:25 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:2411 (2.4 KB) TX bytes:2411 (2.4 KB)

1
2
3
4
5

# En MS-Windows usar línea de comando
ipconfig

# O usar algún sitio web como
http://www.ip-adress.com/

Posts relacionados:

Función PHP para depurar.

NomikOS — Wed, 02 Jun 2010 09:09:12 +0000

Tal vez haya una mejor manera, pero este método lo uso hace mucho tiempo.

1
2
3
4
5
6

function d($var, $exit = 0)
{
echo '

' . var_export($var, 1) . '

';
if ($exit)
exit;
}

Y dices:

1
2
3
4
5
6
7
8
9

# la puedes aplicar sobre cualquier tipo de variable:
# enteros, cadenas, objetos, etc...
d($objeto);

# resultado de ejemplo:
stdClass::__set_state(array(
'user_login' => 'admin',
'user_email' => 'direccion@email.com',
))

Más adelante me gustaría referirme a firephp que usa la consola de mensajes de firebug. La ventaja que tiene es no interrumpir el flujo del script, especialmente en depuración remota y en sitios online pero yo le veo un par de desventajas cruciales… Para depuración de verdad: xdebug…

Posts relacionados:

MOC – music on console. Edición de playlist.

NomikOS — Mon, 31 May 2010 23:21:17 +0000

PHP tiene una sintaxis basada en C. Así que si sabes PHP no debiera costarte mucho leer código C estructurado (C++es orientado a objetos y es muy diferente) Así que estudiando el playlist_file.c sabemos como moc lee y escribe sus playlists en formato m3u.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

...
/* Save plist in m3u format. Strip pathes by strip_path bytes.
* If save_serial is not 0, the playlist serial is saved in a
* comment. */
static int plist_save_m3u (struct plist *plist,
const char *fname,
const int strip_path,
const int save_serial)
{
FILE *file;
int i;

debug ("Saving playlist to '%s'", fname);

if (!(file = fopen(fname, "w"))) {
error ("Can't save playlist: %s", strerror(errno));
return 0;
}

if (flock(fileno(file), LOCK_EX) == -1)
logit ("Can't flock() the playlist file: %s", strerror(errno));

if (fprintf(file, "#EXTM3U\r\n") < 0) {
error ("Error writing playlist: %s", strerror(errno));
fclose (file);
return 0;
}

if (save_serial && fprintf(file, "#MOCSERIAL: %d\r\n",
plist_get_serial(plist)) < 0) {
error ("Error writing playlist: %s", strerror(errno));
fclose (file);
return 0;
}

for (i = 0; i < plist->num; i++)
if (!plist_deleted(plist, i)) {
int ret;

/* EXTM3U */
if (plist->items[i].tags)
ret = fprintf (file, "#EXTINF:%d,%s\r\n",
plist->items[i].tags->time,
plist->items[i].title_tags ?
plist->items[i].title_tags
: plist->items[i].title_file);
else
ret = fprintf (file, "#EXTINF:%d,%s\r\n", 0,
plist->items[i].title_file);

if (ret < 0) {
error ("Error writing playlist: %s",
strerror(errno));
fclose (file);
return 0;
}

/* file */
if (fprintf(file, "%s\r\n", plist->items[i].file
+ strip_path) < 0) {
error ("Error writing playlist: %s",
strerror(errno));
fclose (file);
return 0;
}
}

if (flock(fileno(file), LOCK_UN) == -1)
logit ("Can't flock() (unlock) the playlist file: %s",
strerror(errno));

if (fclose(file)) {
error ("Error writing playlist: %s", strerror(errno));
return 0;
}

return 1;
}
...

Básicamente:

1
2
3
4

# La línea 42 escribe duración (radios online: -1) y título:
fprintf (file, "#EXTINF: %d, %s", time, tags ? tags : title);
# La línea 59 escribe nombre archivo
fprintf (file, "%s", file);

Ejemplo:
archivo: ~/.moc/playlist.m3u

/**

#EXTM3U
#MOCSERIAL: 512
#EXTINF:-1,Groove Salad (Soma FM)
http://streamer-mtc-aa01.somafm.com:80/stream/1018
#EXTINF:258,Groove Armada - groove is on (Love Box)
/home/nomikos/Music/Groove Armada - Love Box/groove_is_on.mp3

**/

Posts relacionados:

La función explode es sensible a mayúsculas y minúsculas.

NomikOS — Mon, 31 May 2010 04:40:58 +0000

explode es sensible a mayúsculas y minúsculas… Y me acabo de dar cuenta! Después de re-tantos años de usarlo. Cierto es que el uso más común de explode es trozar pizzas, como lo ejemplifica el manual de PHP:

1
2
3
4
5

# Example 1
$pizza = "piece1 piece2 piece3 piece4 piece5 piece6";
$pieces = explode(" ", $pizza);
echo $pieces[0]; // piece1
echo $pieces[1]; // piece2

Pero no siempre se aplica así. Estaba recién cortando cadenas de texto con la desfachatez que dan años de circo:

1
2
3
4

$name = 'Audi A4 1.9 TDI 130 Quattro Sport 5dr';
$tok = 'AUDI';
$model = explode($tok, $name);
$model = strtok($model[1], ' ');

Lo anterior debe dar el modelo: “A4″. O debiera, si explode no fuera a sensible a mayúsculas y minúsculas. Pero como lo es me quedo sin poder determinar el modelo del autazo.

Tuve que ir al manual de PHP http://php.net/manual/en/function.explode.php para convencerme. Y sorpresa, no dice nada al respecto! Ya podría echarle la culpa a alguien si se perdía plata

Hay una página de manual de PHP alternativa en que un usuario lo comenta y propone una función explodei, que es case-insensitive:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

/**
siavash79_99 at yahoo dot com
19-Nov-2003 05:24
here is a tested case-insensitive explode I named it explodei()
works cool :-)
**/

function explodei($separator, $string, $limit = false )
{
$len = strlen($separator);
for ($i = 0; ; $i++)
{
if (($pos = stripos($string, $separator )) === false
||
($limit !== false && $i > $limit - 2 ))
{
$result[$i] = $string;
break;
}
$result[$i] = substr($string, 0, $pos);
$string = substr($string, $pos + $len);
}
return $result;
}

/**
If your php version is < 5, you'll need to add stripos() to your script.
See http://php.net/function.stripos
**/
?>

Fuente: http://theserverpages.com/php/manual/en/function.explode.php#37563

A simple vista parece correcta, pero hay una manera más simple y rápida:

1
2
3
4

$name = 'Audi A4 1.9 TDI 130 Quattro Sport 5dr';
$tok = 'AUDI';
$model = explode(strtoupper($tok), strtoupper($name));
$model = strtok($model[1], ' ');

Sí, usando explode en cadenas con igual case debiera funcionar. Es un truco que se usa bastante en consultas a bases de datos cuando interesa considerar mayúsculas y minúsculas como iguales.

1	SELECT * FROM tabla WHERE UPPER(esto) = UPPER('Esto');

Ja! Lo comenté en php.net y ahora forma parte del manual en línea de PHP.
clap, clap, clap, gracias, clap, clap, clap, gracias, gracias.

Posts relacionados:

Codificación de caracteres: UTF-8 o ISO-8859-1.

NomikOS — Mon, 24 May 2010 01:19:01 +0000

photo credit: drewgstephens

Usar UTF-8 (Unicode) o ISO-8859-1 (Alfabetos usados en occidente) en la codificación de caracteres no es una decisión que deba hacerse a la ligera.

Consideraciones principales:

1.- Bytes requeridos: UTF-8 puede usar hasta 4 bytes para codificar en vez de uno solo (ISO-8859-1). Un byte alcanza para 256 combinaciones con sus ocho bits que son suficientes para todo el alfabeto latino usado en occidente. Con dos bytes abarca el cirílico (ruso) y griego (también usado en matemáticas). Más bytes pueden ser necesarios para alfabetos extremadamente complicados como el chino, árabe o hindi.
Esto debe ser considerado al definir campos en una base de datos.

2.- Funciones manejadoras: En PHP funciones para tratar cadenas de texto como substr(), strpos(), strlen() no están pensadas para ambientes multibytes. Esto fácilmente puede devenir en variados errores. También la función mail() y las para expresiones regulares pueden verse afectadas. Para estos casos existen funciones dedicadas cuyo sufijo es mb_ (de multibyte).
No es necesario reescribir el código para adaptar scripts a un ambiente multibyte. PHP puede realizar sobrecarga de funciones (Function Overloading Features) si se lo indicas en su archivo de configuración php.ini, con lo que automáticamente usará las funciones más adecuadas.

1
2
3
4
5

# usa 1 para sobrecargar mail()
# usa 2 para sobrecargar funciones de cadenas
# usa 4 para sobrecargar expresiones regulares
# usa la suma para varias opciones
mbstring.func_overload = 7

Averiguar si tienes la extensión mbstring necesaria para tener estas características:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

$ php -i|grep mbstring
# si la tienes debe responder algo como esto
mbstring
mbstring extension makes use of "streamable kanji code filter and converter", which is distributed under the GNU Lesser General Public License version 2.1.
mbstring.detect_order => no value => no value
mbstring.encoding_translation => Off => Off
mbstring.func_overload => 7 => 7
mbstring.http_input => pass => pass
mbstring.http_output => pass => pass
mbstring.internal_encoding => no value => no value
mbstring.language => neutral => neutral
mbstring.strict_detection => Off => Off
mbstring.substitute_character => no value => no value

# puedes ver todos los módulos (extensiones) cargados con la opción -m
$ php -m

$ php -m|grep mbstring
mbstring

Si no está puedes instalar esta extensión PHP fácilmente (phpMyAdmin siempre la pide a gritos):

1
2
3
4

# Ubuntu
sudo apt-get install php5-mbstring
# Red Hat y compañia
sudo yum install php-mbstring

Si puedes elegir prefiere UTF-8 que es un sobreconjunto de ISO-8859-1. Ambos funcionarán igual de bien para aplicaciones en español o inglés. Pero si se da el caso en que debas considerar idiomas no occidentales, entonces estos consejos te servirán.

Otros comandos útiles pueden ser los siguientes:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# codificación de caracteres interna en PHP
mb_internal_encoding('UTF-8');

# codificación de caracteres en la base de datos
# al iniciar una conexión con PHP
mysql_query("SET NAMES 'utf8';");
mysql_query("SET CHARACTER SET 'utf8';");

# codificación de caracteres enviada al cliente o
# navegador desde PHP
header('Content-type: text/html; charset=UTF-8');

# encabezado en documentos XML
<?xml version="1.0" encoding="utf-8" ?>

# META en documentos HTML/XHTML
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />

photo credit: Max Braun

SheBang (sharp bang) #!.

NomikOS — Tue, 01 Dec 2009 15:27:20 +0000

Los símbolos #! (sharp bang) aparecen en la primera línea de muchos scripts, especialmente los de perl. Tambien podemos usarlos en PHP. SheBang es un alias geek de sharp bang.

Nota: El shell es el intérprete de comandos en tu terminal linux. Generalmente bash.

Lo que hace es indicarle al shell que cargue el programa descrito a continuación de ! (bang) y que le pase el nombre del archivo (del script en que está) como primer parámetro.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# en archivo hello-world.php:
#! /usr/bin/php
<?php
echo "Hello World!\n";
?>

# hacer archivo ejecutable
chmod a+x hello-world.php

# ahora si ejecutamos
./hello-world.php

# producirá
Hello World!

Como # inicia comentarios en PHP no será tomado en cuenta por el propio interprete PHP, sólo por el shell. Incluso no es necesaria la extensión .php.

Fuente: http://c2.com/cgi/wiki?SheBang

WordPress escapa automáticamente las comillas simples!.

NomikOS — Fri, 23 Oct 2009 05:17:06 +0000

En wp-settings.php alrededor de la línea 581 de wordpress 2.8 encontramos:

1
2
3
4
5
6
7
8
9
10
11
12

// If already slashed, strip.
if ( get_magic_quotes_gpc() ) {
$_GET = stripslashes_deep($_GET );
$_POST = stripslashes_deep($_POST );
$_COOKIE = stripslashes_deep($_COOKIE);
}

// Escape with wpdb.
$_GET = add_magic_quotes($_GET );
$_POST = add_magic_quotes($_POST );
$_COOKIE = add_magic_quotes($_COOKIE);
$_SERVER = add_magic_quotes($_SERVER);

O sea que independientemente de tu configuración en php.ini:

1 2	; Magic quotes for incoming GET/POST/Cookie data. magic_quotes_gpc = Off

WP siempre escapará las comillas.

Luego en teoría no sería necesario usar addslashes o addslashes_gpc:

1	$keyword = addslashes_gpc(trim($_POST['keyword']));

Y siempre deberíamos usar stripslashes al reescribir datos pasados por $_POST:

1	echo htmlspecialchars(stripslashes($_POST['keyword'])) ?>">

La verdad es que no me gusta nada. Pero no queda más que aceptarlo como una medida de seguridad adecuada para permitir la creación de tantos plugins para WP a la mayor cantidad de codificadores.

Como sea, es mejor no olvidar esta característica de WP.

Posts relacionados:

Actualizando php 5.2 en Centos 5.

NomikOS — Thu, 01 Oct 2009 17:33:39 +0000

Centos 5 viene con php 5.1.6.
Hay importantes paquetes que necesitan php 5.2+ como por ejemplo phpmyadmin 3.2.2. Encontré un repositorio dedicado a esto.

Haz un nuevo archivo:

1	vi /etc/yum.repos.d/centos-test.repo

Agrega estas líneas:

1
2
3
4
5
6

[c5-testing]
name=CentOS-5 Testing
baseurl=http://dev.centos.org/centos/5/testing/$basearch/
enabled=0
gpgcheck=1
gpgkey=http://dev.centos.org/centos/RPM-GPG-KEY-CentOS-testing

Ejecuta la actualización con yum

1	yum --enablerepo=c5-testing update php

Ahora lo tienes…

1
2
3
4

php -v
PHP 5.2.9 (cli) (built: Jul 8 2009 06:03:36)
Copyright (c) 1997-2009 The PHP Group
Zend Engine v2.2.0, Copyright (c) 1998-2009 Zend Technologies

Aprovecha de actualizar php-mcrypt para tranquilizar a phpmyadmin.

1	yum --enablerepo=c5-testing update php-mcrypt

Chequea que php-mcrypt sea de la misma version que php (5.2.9 en este caso).

1 2	rpm -qa \| grep php-mcrypt php-mcrypt-5.2.9-2.el5.centos.3

Ahora las extensiones para php son cargadas desde sus propios archivos .ini ubicados en /etc/php.d

1	vi /etc/php.d/mcrypt.ini

Para habilitar mcrypt asegúrate de remover ; en la segunda línea.

1 2	; Enable mcrypt extension module extension=mcrypt.so

Reinicia apache

1	service httpd restart

Posts relacionados:

Yum y repositorios centosplus y RPMforge/DAG en Centos.