<script type="text/javascript" src="js/jquery-1.3.2.min.js"></script>

Sin embargo un artículo que leí hace algún tiempo [Encosia.com] recomienda evitar esa práctica, y utilizar el jQuery que Google cuelga de sus servidores y usa para sus propios sitios web. De esta manera:

<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js"></script>

Dave Ward, el autor, lo razonaba con tres sólidos argumentos:

• Tu página cargará antes. jQuery es una librería pesada y, asúmelo, siempre se cargará antes desde un servidor de Google (un señor servidor) que desde el tuyo.
• ¿He dicho ya que tu página cargará antes? Mientras el navegador lee jQuery desde el servidor de Google, puede ir cargando el resto de la web que sí están en tu servidor. Simultáneamente. Eso es un gran ahorro de tiempo.
• Tu página (y todas nuestras páginas) cargarán antes. Cuando forzamos la carga de un jQuery nuevo en cada web, estamos llenando la caché de los navegadores de material redundante. Pero si en vez de eso llamamos siempre al mismo jQuery de Google, si todos los hiciéramos, los navegadores no necesitarían cargar jQuery porque ya lo tienen.

Me convenció aquel artículo así que de un tiempo a esta parte procuro no apuntar hacia un jQuery en mi servidor, sino al que alberga Google en sus servidor de APIs.

No obstante, con un proyecto web en el que uso esta técnica me pasó una cosa curiosa el otro día. Durante un viaje en tren aproveché para programar un rato y al no tener acceso a Internet el jQuery de Google, claro, no cargaba y por consiguiente no podía trabajar.

La solución fue obvia: Temporalmente cambié esa línea, dejando de apuntar al servidor de Google para apuntar a un jQuery local.
Y viendo que esto podía sucederme de nuevo en el futuro, opté por algo también obvio, que es mantener ambas líneas en el código de la página y comentar la que sobra según la situación. Nada del otro mundo.

Pero luego me empeñé en perfeccionar un poco la cosa y salió esto:

<script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js"></script>
<script type="text/javascript">if(typeof jQuery==='undefined'){document.write(unescape("<scri"+"pt src='js/jquery-1.3.2.min.js' type='text/javascript'></scri"+"pt>"));}</script>

Utilizando este código me despreocupo totalmente del tema. ¿Que encuentra el jQuery de Google? Lo usa. ¿Que no? Pues usa el jQuery local.

Checkbox múltiple

…del siguiente modo:

Tabla en la base de datos

Nomalmente uso comas para separarlos pero cuando esto es un problema tiro de caracteres menos frecuentes como la barra vertical |, por ejemplo.

Para convertir el contenido de un campo checkbox múltiple en una lista separada por comas utilizo esta función:

function chkd2lst(frm,fld)
	{
	var t="";var s=",";
	for(var i=0;i<document[frm].elements["_"+fld].length;i++)
		{
		if(document[frm].elements["_"+fld][i].checked)
			{
			t+=document[frm].elements["_"+fld][i].value+s;
			}
		}
	document[frm].elements[fld].value=t;
	alert(document[frm].elements[fld].value);
	}

La función chkd2lst espera el nombre del formulario y el nombre del campo checkbox múltiple. También define que la coma será el separador de los elementos de la lista (variable s) pero esto es fácilmente editable. Al final de la función hay un alert que puede ser eliminado, por supuesto. Está ahí simplemente para comprobar que la función funciona.

Supongamos que, como en el ejemplo de las imágenes, el campo se llama diasClase. El formulario ha de llamar entonces al javaScript de esta manera:

<form
	name="ficha"
	method="post"
	onSubmit="chkd2lst(this.name,'diasClase');return;"
>

Dentro del formulario, divido el tema del checkbox múltiple en dos partes. Por un lado la sucesión de checkboxes:

<input name="_diasClase" value="1" type="checkbox">Lunes
<input name="_diasClase" value="2" type="checkbox">Martes
<input name="_diasClase" value="3" type="checkbox">Miércoles
<input name="_diasClase" value="4" type="checkbox">Jueves
<input name="_diasClase" value="5" type="checkbox">Viernes
<input name="_diasClase" value="6" type="checkbox">Sábado

Y a continuación un campo hidden en el que guardaré la lista generada a partir de los checkboxes.

<input name="diasClase" value="" type="hidden">

La función espera que el nombre de los campos checkbox y hidden sean el mismo, pero que el nombre de cada input del checkbox múltiple vaya precedido de un guión bajo _ y que el nombre del campo hidden no lo lleve.

Y ya está: antes de enviar el formulario, chkd2lst convierte las opciones seleccionadas en _diasclase en una lista separada por comas y la lleva a diasclase. He colgado un ejemplo aquí en el que sustituyo el campo hidden por un campo text sólo para que se vea el resultado.

Próximamente publicaré otro artículo en el que trataré el proceso inverso, es decir: traigo de la base de datos un campo conteniendo la lista separada por comas y marco como checked los elementos correspondientes del checkbox multiple. Imprescindible para poder editar, claro.

1. Dejarlo en manos del usuario, confiando en que use correctamente los tags <a href=”…”></a>
2. Dejarlo en manos del usuario, confiando en que use correctamente alguna herramienta web que le facilitemos para ello, como FCKEditor, TinyMCE o similares
3. Dejarlo en manos de una función.

Dejar el HTML en manos del usuario medio es habitualmente una fuente de problemas, así que suelo prescindir de la opción 1.

La opción 2 es muy tentadora pero sólo la utilizo cuando desarrollo paneles de control ya que sus usuarios tienen formación específica o han recibido algún cursillo, así que todo suele ir como la seda.

Así que cuando se trata de dejar formularios al alcance de usuarios desconocidos, me decanto siempre por la opción 3.

Ejemplo: Supongamos que el siguiente texto es introducido en un textarea de un formulario web.

Vemos que el mensaje incluye cuatro enlaces:

• http://www.cuatro.com es correcto.
• http://antena3.com es correcto aunque no incluya el subdominio ‘www’.
• http://rtve..es presenta una errata (dos puntos entre ‘rtve’ y ‘es’) y no es un enlace válido.
• www.lasexta.com sería correcto en la barra de direcciones del navegador pero en principio no es directamente reconocible como enlace al no ir precedido del indicador de protocolo ‘http://’.

La función que presento hoy es capaz de reconocer los enlaces y actuar en consecuencia:

<?php
function addLinks($str,$alt=false)
	{
	$com = "[enlace]";
	$pcl = "((ht|f)tps?:\/\/)";
	$hst = "([a-z\d][-a-z\d]*[a-z\d]\.)+".
		   "[a-z][-a-z\d]*[a-z]";
	$prt = "(:\d{1,})?";
	$pth = "(\/[^?<>\#\"\s]+)?";
	$qry = "(\?[^<>\#\"\s]+)?";
	$str = preg_replace(
			"#({$pcl}{$hst}{$prt}{$pth}{$qry})#",
			"<a href='$1'>".($alt?$com:'$1').
			"</a>",$str);
	$str = preg_replace(
			"#\s(www.{$hst}{$prt}{$pth}{$qry})#",
			" <a href='http://$1'>".($alt?$com:'$1').
			"</a>",$str);
	return $str;
	}

$txt = "Hola Juan. La web de Cuatro es http://www.cuatro.com, ".
	   "la de Antena 3 es http://antena3.com, la de RTVE es ".
	   "http://rtve..es y la de La Sexta creo que es ".
	   "www.lasexta.com. A ver si ahí puedes encontrar la info ".
	   "que buscas. Un saludo.";

echo addLinks($txt);
?>

Esta función devuelve el valor de $txt como sigue:

Vemos que los tres enlaces válidos son clicables. El enlace a RTVE no lo es porque la función no lo dio por bueno. Pero aparece como parte del texto con la esperanza de que quien lo lea detecte la errata, corrija el enlace y pueda utilizarlo.

¡Ah! Y si queremos que no aparezcan los enlaces escritos (a veces ocupan demasiado espacio), podemos sustituirlos por una palabra comodín simplemente añadiendo ‘true’ como segundo parámetro:

<?= addLinks($txt,true); ?>

Lo que nos devuelve:

Muy práctico, ¿verdad?.

<script type="text/javascript">
function rUSure(u,g)
	{
	if(!g){var g='o';}
	if(confirm("¿Estás segur"+g+"?")){document.location.href=u;}
	}
</script>

Nota: Esta función hace uso de la técnica Argumentos por defecto en funciones javaScript para ajustar el mensaje al género del usuario (¿Estás seguro?|¿Estás segura?)

<?php
function qq($a,$b=2)
	{
	return $a+$b;
	}

echo qq(3);		// Devuelve 5
echo qq(3,3);	// Devuelve 6
?>

Vemos que si no asignamos un valor a $b, la función tiene reservado para $b un valor por defecto.

Lamentablemente en javaScript no es posible declarar un argumento por defecto en una función de un modo tan directo. El siguiente ejemplo **no funciona**:

<script type="text/javascript">
function qq(a,b=2)	// Esto no va a funcionar
	{
	return a+b;
	}
</script>

¿Cómo podemos conseguirlo? Pues con un poco de ingenio es posible expresar la idea de «argumento por defecto en funciones javaScript» de la siguiente manera:

<script type="text/javascript">
function qq(a,b)
	{
	if(!b){var b=2;} // Si no hay b, b=2
	return a+b;
	}

document.write(qq(3));		// Devuelve 5
document.write(qq(3,3));	// Devuelve 6
</script>

¿Fácil, no?