jueves, 27 de noviembre de 2014

Acceder a las propiedades de un IFRAME mediante Javascript

Si necesitamos acceder a las propiedades de un iframe que esté incorporado en nuestra página lo podemos hacer de una forma muy sencilla con la siguiente función:

function getIframe(id){
  var myframe = document.getElementById(id);
  var content = (myframe.contentWindow || myframe.contentDocument);
  return content.document;
}

A esta función le pasamos el id del iframe y obtendremos un objeto que podremos manejar y cambiar por ejemplo el color de fondo. Para ponerle el fondo de color gris lo haríamos así:

  var myframe = getIframe('myframe');
  myframe.body.backgroundColor = '#CCC';
}

La propiedad contentDocument es soportada por los principales navegadores excepto Internet Explorer, que solamente la soporta a partir de la versión 8 si está especificado !DOCTYPE. Para las versiones anteriores de Internet Explorer hay que usar contentWindow.

miércoles, 26 de noviembre de 2014

Acortar urls con goo.gl desde PHP usando la API de Google

Acortar una url es algo bastante común hoy en día, sobretodo en las redes sociales como Twitter donde el número de caracteres es limitado.

Si lo queremos de hacer desde nuestra sitio web de PHP tenemos una forma muy sencilla con la API de Google.

Los pasos a dar serían los siguientes:

1. Lo primero que necesitaremos será darnos de alta una cuenta de Google Developer, que lo puedes hacer fácilmente si tienes una cuenta de Google.

2. Deberemos ir la la consola del desarrollador y dar de alta un nuevo proyecto. Le pondremos el nombre que deseemos y una vez creado iremos en el menú de la izquierda al ítem APIs & Auth (APIs y autenticación en español). Seleccionando APIs en el submenú veremos toda la lista de servicios que nos ofrece Google. Buscaremos URL Shortener API y lo activaremos desde la parte superior de la página. Hecho esto elegiremos en el submenú Credentials (Credenciales en español) y haremos clic en Crear clave nueva. Nos aparecerá una ventana emergente y seleccionaremos Clave de servidor. Ahí nos pedirá que pongamos una IP si queremos limitar desde donde se puede llamar al servicio. Con todo esto realizado ya nos dará la clave de la api que necesitaremos posteriormente para acortar la url.

3. El último paso será coger el código que os dejo a continuación y cambiar únicamente la clave de la api por la vuestra y la url por la que necesitéis.

Código PHP

Lo primero que veremos será la clase que implementa las funciones de acortar y expandir:

class GoogleShortUrl{
 
 // Constructor
 function __construct($key, $apiURL = 'https://www.googleapis.com/urlshortener/v1/url'){
  $this->apiURL = $apiURL.'?key='.$key;
 }
 
 // Acortar la URL
 function shorten($url) {
  $response = $this->send($url);
  return isset($response['id']) ? $response['id'] : false;
 }
 
 // Expandir la URL
 function expand($url) {
  $response = $this->send($url, false);
  return isset($response['longUrl']) ? $response['longUrl'] : false;
 }
 
 // Enviar información a Google
 function send($url, $shorten = true){

  // Inicializamos curl y definimos el objeto
  $curlObj = curl_init();
  if ($shorten){
   curl_setopt($curlObj, CURLOPT_URL, $this->apiURL);
   curl_setopt($curlObj, CURLOPT_POST, 1);
   curl_setopt($curlObj, CURLOPT_POSTFIELDS, json_encode(array("longUrl"=>$url)));
   curl_setopt($curlObj, CURLOPT_HTTPHEADER, array("Content-Type: application/json"));
  } else {
   curl_setopt($curlObj, CURLOPT_URL, $this->apiURL.'&shortUrl='.$url);
  }
  curl_setopt($curlObj, CURLOPT_RETURNTRANSFER, 1);
  curl_setopt($curlObj, CURLOPT_SSL_VERIFYPEER, 0);
  curl_setopt($curlObj, CURLOPT_HEADER, 0);
  
  // Ejecutamos el post
  $response = curl_exec($curlObj);

  // Cerramos la conexión
  curl_close($curlObj);
  
  // Devolvemos la respuesta
  return json_decode($response, true);
 }  
}

Ahora solamente nos queda hacer la llamada a la clase anterior y acortar o expandir una url:

// Creamos una instancia de la clase
$key = 'miclave';
$shorter = new GoogleShortUrl($key);

// Acortamos la URL
$shortname = $shorter->shorten("http://softontherocks.blogspot.com");
echo $shortname; // devuelve http://goo.gl/VF1HJ

// Expandimos la URL
$longname = $shorter->expand($shortname);
echo $longname; // devuelve http://softontherocks.blogspot.com

Espero que os sirva en vuestros proyectos.

domingo, 23 de noviembre de 2014

Hacer drag and drop con jQuery

Una de las primeras cosas que aprendí a hacer cuando me inicié con jQuery fue hacer un ejercicio de drag and drop.

Os dejo los pasos que necesitamos para que funcione:

1. Incluir las librerías js de jQuery




2. Crear los divs que vamos a cambiar de posición

Item 1
Item 2
Item 3
Item 4
Item 5

3. Poner el código para que los divs puedan ejecutar el movimiento



4. Añadir CSS para que los divs tengan mejor aspecto



miércoles, 19 de noviembre de 2014

Listar los archivos de un directorio ordenados alfabéticamente con PHP

Hace pocos días tuve que crear una pequeña página en la que leía un directorio y mostraba los ficheros que contenía, usando PHP.

La primera función que os dejo utiliza el readdir() y me listó bien el contenido del directorio en mi servidor de desarrollo, sin embargo cuando lo subí al hosting no me mostró los archivos ordenados alfabéticamente.

function getFiles($dir){
 $files = array();
 // Abrimos el directorio
 if ($dh = opendir($dir)){
  // Recorremos los ficheros del directorio
  while (($file = readdir($dh))!==false){
   // Comprobamos que sea un fichero y no un subdirectorio
   if (is_file($dir.'/'.$file)){
    $files[] = $file;
   }
  }
  closedir($dh);
 }
 return $files;
}


Para mostrarlos de forma ordenada tuve que cambiar la función y usar scandir() que además es más simple ya que directamente nos devuelve un array con los archivos encontrados, ordenados ascendente o descendentemente, según queramos.

function getFiles($dir){
 $files = array();
 // Leemos el directorio ordenado ascendentemente
 $tmp = scandir($dir);
 // Recorremos los ficheros del directorio
 foreach ($tmp as $file){
  // Comprobamos que sea un fichero y no un subdirectorio
  if (is_file($dir.'/'.$file)){
   $files[] = $file;
  }
 }
 return $files;
}

Obtener el tamaño de un fichero y mostrarlo en un formato comprensible mediante PHP

En PHP tenemos la posibilidad de obtener el tamaño de un fichero mediante la función filesize. Esta función nos devuelve un entero con el número de bytes del archivo.

Este tamaño, en el caso de que el fichero sea grande, es posible que lo queramos representar en kilobytes, megabytes..., o simplemente dejar que la función decida la magnitud más adecuada.

En este caso hemos realizado una función que recoge esta posibilidad:


function convertFileSize($file, $size=null, $decimals=2, $dec_sep='.', $thousands_sep=','){
 if (!is_file($file)){
  return "El fichero no existe";
 }
 $bytes = filesize($file);
 $sizes = 'BKMGTP';
 if (isset($size)){
  $factor = strpos($sizes, $size[0]);
  if ($factor===false){
   return "El tamaño debe ser B, K, M, G, T o P";
  }
 } else {
  $factor = floor((strlen($bytes) - 1) / 3);
  $size = $sizes[$factor];
 }
 return number_format($bytes / pow(1024, $factor), $decimals, $dec_sep, $thousands_sep).' '.$size;
}

Los parámetros son:

$file: ruta completa del fichero
$size: magnitud en la que queremos obtener el resultado. Si lo dejamos a null hará el cálculo la propia función
$decimals: número de decimales que queremos que nos muestre. Por defecto nos mostrará 2.
$dec_sep: separador decimal. Por defecto coge el punto que es el que se usa en inglés.
$thousand_sep: separador de miles. Por defecto coge la coma que es el que se usa en inglés.

viernes, 14 de noviembre de 2014

Ordenar array UTF-8 con Javascript

Ordenar arrays con Javascript es una función muy habitual que ejecutamos los programadores web. Sin embargo, existen ocasiones en que lo que queremos ordenar lleva tildes, eñes o cualquier grafía de otro alfabeto.

Cuando ocurre esto, el método habitual de ordenación sort() no sirve ya que nos los ordena en último lugar. Veamos un ejemplo:

var myarray = ['Álex', 'Juan', 'José', 'Antonio', 'Carlos'];
myarray.sort(); // Queda ordenado como Antonio, Carlos, José, Juan, Álex


Para este tipo de caracteres necesitamos una función específica para ordenar, que podría convertirse en nuestro método sort() si nuestro alfabeto habitual lleva caracteres Unicode. Para realizar la ordenación UTF-8 tenemos que hacer lo siguiente:

var myarray = ['Álex', 'Juan', 'José', 'Antonio', 'Carlos'];
myarray.sort(function(a,b){return a.localeCompare(b);}); // Queda ordenado como Álex, Antonio, Carlos, José, Juan


miércoles, 12 de noviembre de 2014

Enviar tweets desde PHP

Hace pocos días me vi en la necesidad de buscar la forma de enviar tweets desde PHP. Empecé a buscar y encontré varias clases que implementaban lo que necesitaba, pero finalmente me decanté por una llamada Twitter for PHP.

Se trata de una pequeña librería de PHP con funciones muy interesantes para manejar una cuenta de Twitter y además lleva soporte para el protocolo OAuth. Si buscáis información en google encontraréis mucha información sobre este protocolo pero os dejo este enlace que lo explica bastante bien. La librería Twitter for PHP requiere como mínimo la versión PHP 5.0 y tener instalada la librería cURL.

Primeros pasos

Para utilizar esta librería lo primero que tendremos que hacer es descargarla desde su repositorio en GitHub. En el repositorio encontraremos ejemplos de lo que veremos en este mismo post.

A continuación deberemos dar de alta una cuenta de Twitter, si no la tenemos, e ir a http://dev.twitter.com/apps para registrar una aplicación. Una vez creada tienes que ir a la pestaña Key and Access Tokens y darle clic en la parte inferior de la ventana a Create my access token. Con esto ya tendremos los cuatro parámetros que necesitamos: consumer key, consumer secret, access token y access token secret.

Con todos estos datos ya estamos preparados para poder crear un objeto usando la librería:

$twitter = new Twitter($consumerKey, $consumerSecret, $accessToken, $accessTokenSecret);

Enviar

El envío de un tweet lo realizaremos con el método post(). El mensaje debe ir codificado en UTF-8 y además le podremos añadir una imagen al tweet:

$twitter->send('Mi primer tweet');
$twitter->send('Mi primer tweet con imagen', $imageFile);

Ejemplo completo

Veamos ahora un ejemplo completo para enviar un tweet:

// Incluimos la librería descargada
require_once 'src/twitter.class.php';

// Definimos cuatro constantes con nuestros datos de Twitter
define(CONSUMER_KEY, 'myconsumerkey');
define(CONSUMER_ACCESS, 'myconsumeraccess');
define(ACCESS_TOKEN, 'myaccesstoken');
define(ACCESS_TOKEN_SECRET, 'myaccesstokensecret');

// Creamos el objeto
$twitter = new Twitter(CONSUMER_KEY, CONSUMER_ACCESS, ACCESS_TOKEN, ACCESS_TOKEN_SECRET);

// Enviamos manejando el posible error
try {
 $tweet = $twitter->send('Mi primer tweet');
} catch (TwitterException $e){
 echo $e->getMessage());
}


martes, 11 de noviembre de 2014

Obtener los links que vienen en el contenido de una URL usando DOMDocument de PHP

En un post anterior vimos la forma de obtener un array con los enlaces que nos venían en el contenido de una URL. Este contenido lo obteníamos mediante una función que utilizaba la librería cURL (Client URL) de PHP.

En esta ocasión vamos a simplificar el método ya que utilizaremos para ello la clase DOMDocument.

La función que nos va a descargar y leer las etiquetas de tipo enlace será esta:

function getUrls($url){
 $doc = new DOMDocument;
 $doc->preserveWhiteSpace = false;
 
 // cargamos la url
 @$doc->loadHTMLFile($url);
 
 // buscamos todos los tags del tipo < a >
 $links = $doc->getElementsByTagName("a");
 
 // recorremos cada uno de los tags encontrados
 foreach ($links as $link){
  // obtenemos la parte href de la etiqueta
  $href = $link->getAttribute("href");
  
  if (strlen($href)>=4 && substr($href,0,4)=="http"){
   // url entera
   $urls[] = $href;
  } else if (strlen($href)>0 && substr($href, 0, 1)=="/"){
   // url empieza por / le añadimos el dominio por delante
   $urls[] = $url.$href;
  }else{
   // arhivo
   $urls[] = $url.'/'.$href;
  }
 }

 // eliminamos duplicados
 $urls = array_unique($urls);
 
 // ordenamos alfabéticamente
 sort($urls);
 
 return $urls;
}


La llamada se realizará de esta forma tan sencilla, en la que además mostraremos el resultado del array devuelto por la anterior función:

// especificamos la url
$url = "http://softontherocks.blogspot.com.es";

// obtenemos las url
$urls = getUrls($url);

// mostramos el resultado
echo nl2br(implode($urls, "\n"));


Descargar el contenido de una URL usando DOMDocument de PHP

Un un post anterior hemos visto un ejemplo de cómo descargar el contenido de una web mediante la librería cURL. En este caso, lo haremos más simple si cabe con una función que únicamente utiliza el DOMDocument para ello.

La función os la dejo a continuación:

function getURLContent($url){
    $doc = new DOMDocument;
    $doc->preserveWhiteSpace = FALSE;
    @$doc->loadHTMLFile($url);
    return $doc->saveHTML();
}

Obtener los links que vienen en el contenido de una URL usando cURL de PHP

En el anterior post hemos explicado cómo podemos obtener el contenido de una URL usando la librería cURL de PHP.

En esta ocasión, a partir de lo que nos devuelva dicha función, y mediante el objeto DOMDocument, recorreremos el contenido y buscaremos todos los enlaces que existan.

Lo primero que necesitaremos será la función con la que obtener el contenido de la URL:

function getUrlContent($url){
 $ch = curl_init();
 curl_setopt($ch, CURLOPT_URL, $url);
 curl_setopt($ch, CURLOPT_USERAGENT, 'Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; .NET CLR 1.1.4322)');
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
 curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 5);
 curl_setopt($ch, CURLOPT_TIMEOUT, 5);
 $data = curl_exec($ch);
 $httpcode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 curl_close($ch);
 return ($httpcode>=200 && $httpcode<300) ? $data : false;
}


A continuación desarrollamos la función que recorre el contenido y guarda en un array las direcciones de todos los enlaces que se encuentre:
function getUrls($url){
 // obtenemos el contenido de la url
 $content = getUrlContent($url);

 if ($content==false){
  return false;
 }

 // creamos el array de resultados
 $urls = array();

 // creamos una instanacia a DOMDocument
 $doc = new DOMDocument;
 $doc->preserveWhiteSpace = false;
 
 // cargamos la pagina web desdecargada desde la función getUrlContent()
 @$doc->loadHTML($content);

 // buscamos todos los tags del tipo < a >
 $links = $doc->getElementsByTagName("a");
 
 // recorremos cada uno de los tags encontrados
 foreach ($links as $link){
  // obtenemos la parte href de la etiqueta
  $href = $link->getAttribute("href");
  
  if (strlen($href)>=4 && substr($href,0,4)=="http"){
   // url entera
   $urls[] = $href;
  } else if (strlen($href)>0 && substr($href, 0, 1)=="/"){
   // url empieza por / le añadimos el dominio por delante
   $urls[] = $url.$href;
  }else{
   // arhivo
   $urls[] = $url.'/'.$href;
  }
 }

 // eliminamos duplicados
 $urls = array_unique($urls);
 
 // ordenamos alfabéticamente
 sort($urls);
 
 return $urls;
}
Una vez hecho esto ya solamente nos quedará la llamada a la función y el mostrar en pantalla el resultado:
// especificamos la url
$url = "http://softontherocks.blogspot.com.es";

// obtenemos las url
$urls = getUrls($url);

// mostramos los resultados
if ($urls==false){
 echo "La página no es correcta, o es una redirección.";
} else {
 echo nl2br(implode($urls, "\n"));
}

Descargar el contenido de una URL usando cURL de PHP

Descargar el contenido de una URL es algo que puede ser bastante común para un programador web. Con PHP y la librería cURL (Client URL) podemos conseguirlo con una función bastante simple.

La librería cURL suele venir activa en la configuración de la mayoría de hosting que hay en el mercado. Además, para activarla, si somos nosotros los que configuramos PHP, simplemente debemos descomentar la línea que viene en el php.ini que hace referencia a php_curl.

La función en cuestión es la siguiente:

function getUrlContent($url){
 $ch = curl_init();
 curl_setopt($ch, CURLOPT_URL, $url);
 curl_setopt($ch, CURLOPT_USERAGENT, 'Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; .NET CLR 1.1.4322)');
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
 curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 5);
 curl_setopt($ch, CURLOPT_TIMEOUT, 5);
 $data = curl_exec($ch);
 $httpcode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 curl_close($ch);
 return ($httpcode>=200 && $httpcode<300) ? $data : false;
}


Función para escribir en un fichero log con PHP

Es habitual que cuando realizamos cualquier aplicación queramos guardar un log en fichero de texto plano de ciertas funciones o partes de nuestro código, bien sea para solucionar posibles errores, detectarlos o cualquier otra funcionalidad que le queramos aplicar. En nuestro caso lo usamos para llevar un registro de las consultas SQL que lanzamos sobre la base de datos y ver posibles problemas.

Desde hace tiempo utilizo esta sencilla función que os dejo aquí:

function writeLog($data) {
 list($usec, $sec) = explode(' ', microtime());
 $datetime = strftime("%Y%m%d %H:%M:%S",time());
 $msg = "$datetime'". sprintf("%06s",intval($usec*1000000)).": $data";
 $save_path = 'foo.txt';
 $fp = @fopen($save_path, 'a'); // open or create the file for writing and append info
 fputs($fp, "$msg\n"); // write the data in the opened file
 fclose($fp); // close the file
}

Después, la llamada a esta función se haría de una forma muy simple:

writeLog('Este es el primer log');

Y el resultado que nos aparecería en el fichero foo.txt sería este:

20141111 07:26:14'914062: Este es el primer log


domingo, 9 de noviembre de 2014

Ranking de lenguajes de programación más usados. Índice TIOBE noviembre 2014

El lenguaje estadístico R va en camino del top 10

Los lenguajes estadísticos están ganando importancia en los últimos tiempos. Prueba de ello es el aumento progresivo que están experimentando mes a mes muchos de ellos en el ranking TIOBE. Encontramos ejemplos con Julia (posición 126), LabView (63), Mathematica (80), MATLAB (24), S (84), SAS (21), SPSS (104) o Stata (110). Pero entre todos ellos destaca el lenguaje de programación R que ha subido desde la posición 15 a la 12 en tan solo un mes.

El ranking de los 20 primeros clasificados queda este mes de la siguiente forma:

Nov 2014Nov 2013ChangeProgramming LanguageRatingsChange
11C17.469%-0.69%
22Java14.391%-2.13%
33Objective-C9.063%-0.34%
44C++6.098%-2.27%
55C#4.985%-1.04%
66PHP3.043%-2.34%
78changePython2.589%-0.52%
810changeJavaScript2.088%+0.04%
912changePerl2.073%+0.55%
1011changeVisual Basic .NET2.061%+0.09%
11-changeVisual Basic1.657%+1.66%
1231changeR1.548%+1.14%
139changeTransact-SQL1.408%-1.11%
1413changeRuby1.211%-0.09%
1517changeDelphi/Object Pascal0.957%+0.31%
1623changeF#0.892%+0.39%
1718changePL/SQL0.870%+0.27%
18-changeSwift0.834%+0.83%
1914changePascal0.831%+0.12%
2081changeDart0.816%+0.73%

viernes, 7 de noviembre de 2014

Función json_last_error y json_last_error_msg de PHP

En el anterior post vimos el funcionamiento de la función json_decode() que decodificaba una cadena JSON y la convertía a una variable PHP. Ahí provocamos un error estableciendo una profundidad de la recursividad menor de la que tenía el JSON.

Con las funciones json_last_error() y json_last_error_msg() obtenemos el error, si se produce, que ha ocurrido en la última codificación o decodificación JSON mediante las funciones json_encode() o json_decode().

La primera de las funciones, json_last_error() devuelve un valor entero con el ID del último error que se haya producido. Esta función está disponible a partir de PHP 5.3.0.

En cambio, json_last_error_msg() está disponible únicamente a partir de PHP 5.5.0 y devuelve un string con el error de la última llamada a json_encode() o a json_decode().

Ejemplo

Con este ejemplo lo que haremos será provocar el mismo error que en el anterior post y obtener el resultado. El ejemplo lo vamos a ejecutar en un PHP 5.3.29, con lo que la función json_last_error_msg() no estará disponible, con lo que nos devolverá el resultado la función que creemos nosotros:

$json = '{"users":[{ "user": "Carlos", "age": 30, "country": "Spain" }, { "user": "John", "age": 25, "country": "United States" }]}';

// Si existe la función json_last_error_msg devuelve su valor. En caso contrario si existe json_last_error devuelve el texto que tenemos asociado. Si usamos una versión anterior a PHP 5.3 nos devuelve el mensaje de que no se puede mostrar el error
function getJSONError(){
 return (function_exists('json_last_error_msg')) ? json_last_error_msg() : ((function_exists('json_last_error')) ? getJSONErrorMsg(json_last_error()) : 'This PHP cannot show the error');
}

// A partir del código de error nos muestra un mensaje
function getJSONErrorMsg($code){
 switch ($code) {
  case JSON_ERROR_NONE:
   $msg = 'No errors';
  break;
  case JSON_ERROR_DEPTH:
   $msg = 'Maximum stack depth exceeded';
  break;
  case JSON_ERROR_STATE_MISMATCH:
   $msg = 'Underflow or modes mismatch';
  break;
  case JSON_ERROR_CTRL_CHAR:
   $msg = 'Unexpected control character found';
  break;
  case JSON_ERROR_SYNTAX:
   $msg = 'Syntax error, malformed JSON';
  break;
  case JSON_ERROR_UTF8:
   $msg = 'Malformed UTF-8 characters, possibly incorrectly encoded';
  break;
  default:
   $msg = 'Unknown error';
  break;
 }
 return $code.' '.$msg;
}

// Limitamos la profundidad de la recursividad a 2
$obj = json_decode($json, true, 2);
var_dump($obj);
/* devuelve
NULL -> la profundidad es 4
*/

if ($obj==null){
 $error = getJSONError();
 echo $error;
 /* devuelve
 1 Maximum stack depth exceeded
 */
}

Función json_decode de PHP

La función json_decode() convierte un string codificado en JSON a una variable de PHP apropiada. Si la cadena no puede ser decodificada o se alcanza el límite de profundidad de la recursividad, devuelve un NULL. En caso de error, se puede usar la función json_last_error() para conocer el motivo exacto.

Sintaxis

mixed json_decode ( string $json [, bool $assoc = false [, int $depth = 512 [, int $options = 0 ]]] )

Parámetros

json: cadena JSON que queremos decodificar. 

assoc: si lo ponemos a TRUE indicaremos que queremos convertir el objeto resultado en un array asociativo

depth: límite de profundidad de la recursividad. Por defecto está a 512. Si se supera el límite devolverá un error.

options: se trata de una máscara de bits de opciones de la decodificación. Actualmente está disponible únicamente JSON_BIGINT_AS_STRING que convertiría los enteros grandes a cadena, en lugar de a float como lo haría por defecto.

Ejemplo

Veamos con un ejemplo su funcionalidad y lo que devuelve en cada caso. Los nombres y valores de la cadena JSON siempre deben ir entre comillas dobles:


$json = '{"users":[{ "user": "Carlos", "age": 30, "country": "Spain" }, { "user": "John", "age": 25, "country": "United States" }]}';

// Decodificamos la cadena JSON
$obj = json_decode($json);
var_dump($obj);
/* devuelve
object(stdClass)#1 (1) { ["users"]=> array(2) { [0]=> object(stdClass)#2 (3) { ["user"]=> string(6) "Carlos" ["age"]=> int(30) ["country"]=> string(5) "Spain" } [1]=> object(stdClass)#3 (3) { ["user"]=> string(4) "John" ["age"]=> int(25) ["country"]=> string(13) "United States" } } }
*/

// Devolvemos el resultado como array
$obj = json_decode($json, true);
var_dump($obj);
/* devuelve
array(1) { ["users"]=> array(2) { [0]=> array(3) { ["user"]=> string(6) "Carlos" ["age"]=> int(30) ["country"]=> string(5) "Spain" } [1]=> array(3) { ["user"]=> string(4) "John" ["age"]=> int(25) ["country"]=> string(13) "United States" } } }
*/

// Limitamos la profundidad de la recursividad a 2
$obj = json_decode($json, true, 2);
var_dump($obj);
/* devuelve
NULL -> la profundidad es 4
*/


martes, 4 de noviembre de 2014

Buscar múltiples textos en un texto con PHP

A la hora de buscar si un texto aparece dentro de un texto más amplio mediante PHP tenemos una función muy conocida llamada strpos() que nos devuelve la posición de dicho texto en el otro.

Con la función estándar, si queremos buscar varios textos deberíamos repetir la llamada tantas veces como necesitemos. 

Para facilitar la tarea tenemos esta función en la que la lista de cadenas a buscar la pasaremos mediante un array y además le podremos decir si es una búsqueda sensible a mayúsculas/minúsculas o no.

La función es la siguiente:


function getMultiPos($haystack, $needles, $sensitive=true, $offset=0){
    foreach($needles as $needle) {
        $result[$needle] = ($sensitive) ? strpos($haystack, $needle, $offset) : stripos($haystack, $needle, $offset);
    }
    return $result;
}

La llamada a la función sería como veremos a continuación. La primera llamada es sensible a mayúsculas/minúsculas y la segunda no:


$haystack = "A cat in gloves catches no mice.";
$needles = array("glove", "mouse", ".", "cat", "No");

var_dump(getMultiPos($haystack, $needles));
/* output:
array(5) { ["glove"]=> int(9) ["mouse"]=> bool(false) ["."]=> int(31) ["cat"]=> int(2) ["No"]=> bool(false) }
*/

var_dump(getMultiPos($haystack, $needles, false));
/* output:
array(5) { ["glove"]=> int(9) ["mouse"]=> bool(false) ["."]=> int(31) ["cat"]=> int(2) ["No"]=> int(24) }
*/