Java 101 -String y StringBuilder

JM Java 101 – Concatenacion (o como utilizar cadenas para hacer una gran cadena)

Hay una teoria bien difundida que dice no se debe de concatenar utilizando el simbolo de + pues este causa que varios objetos String temporales
sean creados. Se dice en algunos sitios que en su lugar se debe utilizar la clase StringBuilder.

¿Que tan cierto es esto?

He creido conveniente comprobarlo despues de yo mismo pensar esto durante algun tiempo. Utilizaremos para esto la fuente mas confiable que existe,
el codigo generado para la maquina virtual.

Hemos de investigar el fenomeno de concatenacion con un ejemplo creible, uno donde uno de los valores es una variable obtenida “de algun otro lado”,
pues en caso de que todos los valores son definidos, por ejemplo en:

public static void main(String[] args) {
String string4 = "Cadena 1" + "Cadena 2" + "Cadena 3";
}

Java genera codigo optimizado donde todas las cadenas realmente son convertidas a una sola en tiempo de compilacion, generando codigo para la JVM
como sigue:

public static void main(java.lang.String[]);
Code:
0:   ldc     #16; //String Cadena 1Cadena 2Cadena 3
2:   astore_1
3:   return

Podemos ver aqui que se carga la cadena indicada como #16, y tal cadena es la concatenacion de las 3 diferentes que realmente habiamos especificado.

Intentemos pues con variables de verdad, en los sigiuentes ejemplos, indicare con la variable “value” un valor supuestamente indefinido, aunque
en el siguiente ejemplo esto no tendra mucho sentido, en los sucesivos si lo tendra.

Caso de concatenacion 1.

Crear objetos String para todos las cadenas que deseamos concatenar y finalmente concatenarlas en una sola:

public static void main(String[] args) {
String value = "Valor";

String s1 = "Cadena 1";
String s2 = "Cadena 2";
String s3 = "Cadena 3";
String string1 = s1 + value + s2 + s3;
}

El codigo generado es mas largo pero no por eso mas complicado:

public static void main(java.lang.String[]);
Code:
0:   ldc     #16; //String Valor
2:   astore_1
3:   ldc     #18; //String Cadena 1
5:   astore_2
6:   ldc     #20; //String Cadena 2
8:   astore_3
9:   ldc     #22; //String Cadena 3
11:  astore  4
13:  new     #24; //class java/lang/StringBuilder
16:  dup
17:  aload_2
18:  invokestatic    #26; //Method java/lang/String.valueOf:(Ljava/lang/Object;)Ljava/lang/String;
21:  invokespecial   #32; //Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
24:  aload_1
25:  invokevirtual   #35; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
28:  aload_3
29:  invokevirtual   #35; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
32:  aload   4
34:  invokevirtual   #35; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
37:  invokevirtual   #39; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
40:  astore  5
42:  return

La primer sorpresa al ver el codigo es que el mito de concatenar con + no es menos efectivo que utilizar un StringBuilder, pues el compilador
nuevamente realiza algo de optimizacion y utiliza de forma interna un objeto StringBuilder para realizar la concatenacion. Ahorrando simplemente los store
del Caso 1, que no son otra cosa que la inicializacion de los String.

public static void main(String[] args) {
String value = "Valor";
String string2 = "Cadena1" + value + "Cadena2" + "Cadena3";
}

public static void main(java.lang.String[]);
Code:
0:   ldc     #16; //String Valor
2:   astore_1
3:   new     #18; //class java/lang/StringBuilder
6:   dup
7:   ldc     #20; //String Cadena1
9:   invokespecial   #22; //Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
12:  aload_1
13:  invokevirtual   #25; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
16:  ldc     #29; //String Cadena2
18:  invokevirtual   #25; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
21:  ldc     #31; //String Cadena3
23:  invokevirtual   #25; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
26:  invokevirtual   #33; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
29:  astore_2
30:  return

Caso 3:
Utilizando un objeto StringBuilder.
Curiosamente esta forma es mas lenta que utilizar el operador +, pues si bien, a primera vista pudiera parecer que no hace proceso extra, si tiene que
hacerlo, si vemos el codigo de la JVM encontramos unos misterioros pop y aload_2, el problema aqui es que StringBuilder.append devuelve un valor,
y una vez que el Thread principal vuelve de la subrutina los valores dejados en el stack tienen que ser removidos aun si no se estan utilizando. Es curioso
que no se optimice esto de la forma en que se hizo en el caso dos, donde no existen los pop, pues de alguna forma el compilador sabe que no se utilizan y
nunca existe un valor de retorno siquiera.

public static void main(String[] args) {
String value = "Valor";
StringBuilder sb = new StringBuilder();
sb.append("Cadena 1");
sb.append("Cadena 2");
sb.append("Cadena 3");
String string3 = sb.toString();
}

public static void main(java.lang.String[]);
Code:
0:   ldc     #16; //String Valor
2:   astore_1
3:   new     #18; //class java/lang/StringBuilder
6:   dup
7:   invokespecial   #20; //Method java/lang/StringBuilder."<init>":()V
10:  astore_2
11:  aload_2
12:  ldc     #21; //String Cadena 1
14:  invokevirtual   #23; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
17:  pop
18:  aload_2
19:  ldc     #27; //String Cadena 2
21:  invokevirtual   #23; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
24:  pop
25:  aload_2
26:  ldc     #29; //String Cadena 3
28:  invokevirtual   #23; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
31:  pop
32:  aload_2
33:  invokevirtual   #31; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
36:  astore_3
37:  return

No hace falta siquiera terminar de interpretar compilado para darse cuenta que la version mas corta es la producida por

String string2 = "Cadena1" + value + "Cadena2" + "Cadena3";

Esto resulta muy interesante, pues gracias a este tipo de optimizaciones no es necesario que java incluya un metodo para dividir una cadena en varias
lineas, incluso, no es necesario pues si solamente estuvieramos utilizando constantes, todos nuestros valores serian concatenados en una sola cadena
en tiempo de compilacion.

Wordpress Plugins – Widgets #2 – La conexión a la base de datos

Hay varias cosas que desearíamos hacer cuando el plugin es instalado, la que más rápido querremos descubrir es a mi parecer, como crear las tablas necesarias para nuestro plugin y aprender como interactuar con la base de datos.

Para crear una tabla para durante la activación de nuestro plugin vamos a agregar una nueva función, como sigue:

function i8b_untitled_install() {
	global $wpdb;
	$tableUntitled = $wpdb->prefix."im8bit_untitled";
	$structure = "CREATE TABLE $tableUntitled (
	  `i8d_id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
	  `i8d_date` DATETIME NOT NULL,
	  `i8d_text` VARCHAR(2048) NOT NULL,
	  PRIMARY KEY (`i8d_id`)
	)";
	$wpdb->query($structure);
}

Informamos a php que utilizaremos la variable global $wpdb y listo.

Nota: Si por alguna razón teclearan mal $wpdb obtendrán unos errores increíblemente crípticos y podrían pasar mucho tiempo tratando de encontrarlo… err… me dijeron.

Fuera del cuerpo de cualquier función debemos teclear:
register_activation_hook(__FILE__, ‘i8b_untitled_install’);
Que recibe como parámetro la ruta a nuestro archivo donde se encuentra la función de instalación (en nuestro caso el mismo archivo) y el nombre de la función.

Ahora, cuando activemos nuestro plugin la tabla wp_im8bit_untitled será creada, el wp ha resultado del llamado a la función $wpdb->prefix que deberíamos utilizar siempre como prefijo para nuestras tablas para mantener el estándar con el resto de las tablas de wordpress.

Una vez creada la tabla podemos cambiar la función que dibuja el widget a algo como lo siguiente:

function i8b_untitled_widget($args) {
	global $wpdb;

	extract($args);
	echo $before_widget;
	echo $before_title;

	echo "Title";

	echo $after_title;

	$tableUntitled = $wpdb->prefix."im8bit_untitled";

	$untitled_row = $wpdb->get_row("select i8d_text from " .
	" $tableUntitled order by rand() limit 1", ARRAY_N);

	echo $untitled_row[0];

	echo $after_widget;
}

Por supuesto no hay datos en nuestra tabla, así que ahora en lugar de ver el texto “Untitled” ahora no veremos nada hasta que insertemos algun dato. Estamos entonces realizando un query manual y trayendo un “tip del dia” aleatorio y exhibiendolo con los las lineas:

	$tableUntitled = $wpdb->prefix."im8bit_untitled";

	$untitled_row = $wpdb->get_row("select i8d_text " .
	" from $tableUntitled order by rand() limit 1", ARRAY_N);

	echo $untitled_row[0];

Construyendo como siempre el nombre de nuestra tabla ayudándonos con la función $wpdb->prefix pues esta puede cambiar de instalación a instalación de wordpress.

No debemos olvidar nuevamente indicar a php que $wpdb es una variable global.

Wordpress Plugins – Widgets #1 – El Widget Básico

Cuando empecé a desarrollar un plugin para wordpress, quería hacer un “¿Sabias que…?” muy básico, apenas un widget que pusiera un mensaje de forma aleatoria.

El primer problema no tardo en surgir rápidamente, la mayoría de los tutoriales básicos muestran como sustituir palabras en los post, o hacer algo de post-procesamiento con los post… ¡$%&&! Pero que pasa si lo que quiero es agregar un widget.

Después de buscar, llegue a:

<?php
/*
Plugin Name: Untitled
Plugin URI: http://www.im8bit.com/
Description: Shows a Untitled Widget
Author: Fernando Mora
Version: 0.1
Author URI: http://www.im8bit.com
*/

function i8b_untitled_init() {
register_sidebar_widget('Untitled', 'i8b_untitled_widget');
}

function i8b_untitled_widget($args) {
global $wpdb;

extract($args);
echo $before_widget;
echo $before_title;

echo "Title";

echo $after_title;

echo "Untitled";

echo $after_widget;
}

add_action('plugins_loaded', 'i8b_untitled_init');
?>

Guarda el script anterior en el directorio {instalacion_wordpress}/wp-content/plugins con el nombre untitled.php.

Si deseas tener mas orden puedes crear una carpeta dentro de la carpeta plugins, yo he llamado la mia im8bit, asi que he guardado el archivo en:

{instalacion_wordpress}/wp-content/plugins/im8bit/untitled.php

Este es un simple widget que muestra “Untitled” en el cuerpo y “Title” como su titulo, increíble como parezca el secreto es la función register_sidebar_widget una vez que un plugin “sabe” como dibujar un widget podemos encontrarlo disponible para activarse en “Design”->”Widgets”. Basta agregarlo a alguna de nuestras barras laterales “sidebars” y ya tenemos así un esqueleto básico con el cual comenzar a trabajar.

Cosas importantes a notar:

• Los plugins deben de encontrarse dentro de la carpeta plugins ya sea directamente en ella o en una carpeta bajo ella.
• Los nombres que demos a nuestras funciones deben ser unicos en la instalación de wordpress, es decir, no debe repetirse en ningun otro plugin, de ser asi seremos informados al momento de intentar activar dicho plugin. Por esta razón agrego las letras i8b (im8bit) al principio de la función para dificultar un poco el choque con una función en algun otro lugar.
• La instruccion add_action nos permite crear hooks para nuestro plugin dentro de wordpress, en este caso la funcion i8b_untitled_init será llamada cuando el plugin sea activado o inicializado en la sección plugins.
• Es importante hacer notar que el llamado a la función add_action debe encontrarse fuera del cuerpo de cualquier función para ser encontrada, mientras que el llamado función register_sidebar_widget debe encontrarse dentro del cuerpo de alguna función, en el ejemplo, como ya mencioné es nuestra función de inicialización del plugin.