Obtener dirname y basename de un fichero en Javascript

Si necesitamos con Javascript obtener el nombre del directorio padre o el nombre del fichero de una ruta a fichero completa lo podemos conseguir con estas dos funciones que utilizan una expresión regular para conseguirlo:

function basename(path) {
    return path.replace(/\\/g,'/').replace( /.*\//, '' );
}

function dirname(path) {
    return path.replace(/\\/g,'/').replace(/\/[^\/]*$/, '');
}

Aleatorizar un array en Javascript

Con esta sencilla función conseguimos ordenar de forma aleatoria los elementos de un array:

function shuffle(arr) {
 for (var j, x, i = arr.length; i; j = parseInt(Math.random() * i,10), x = arr[--i], arr[i] = arr[j], arr[j] = x) {}
 return arr;
}

Quitar espacios con ltrim, rtrim y trim en Javascript

La función trim es una función muy utilizada en cualquier lenguaje de programación. En Javascript estas funciones no están implementadas aunque son unas funciones muy sencillas de programar.

LTRIM (Quitar espacios por la izquierda)

function ltrim(s) {
   return s.replace(/^\s+/, "");
}

RTRIM (Quitar espacios por la derecha)

function rtrim(s) {
   return s.replace(/\s+$/, "");
}

TRIM (Quitar espacios por la derecha e izquierda)

function trim(s) {
   return rtrim(ltrim(s));
}

Obtener la extensión de un fichero con PHP

Para obtener la extensión de un archivo en PHP tenemos varias posibilidades. Os dejo una muy sencilla a continuación:

function getExtension($file) {
  $pos = strrpos($file, '.');
  if($pos===false){
    return false;
  } else {  
    return substr($file, $pos+1);
  }
}

Web Services JSON con PHP

En este ejemplo vamos a intentar explicar cómo realizar un simple web service que utiliza JSON como formato de intercambio, en lugar del clásico XML que utilizan los web services SOAP. Con JSON además de su sencillez para manejarlo con Javascript y PHP tenemos un formato ligero y muy simple de notación literal.

Lo primero que tendremos en cuenta es que el formato de intercambio será JSON, por lo que la información enviada y recibida será de tipo application/json.

El código de la clase del web service y la implementación de una función básica para obtener la hora del servidor sería este:

class JSON_WebService {
    private $methods, $args, $strcall;
    public function __construct($rawData) {
        $this->strcall = str_replace($_SERVER["SCRIPT_NAME"]."/", "", $_SERVER["REQUEST_URI"]);
        $this->args = $rawData;
        $this->methods = array();
        header('Access-Control-Allow-Origin: *');
        header('Access-Control-Allow-Methods', 'PUT, GET, POST, DELETE, OPTIONS');
        header('Cache-Control: no-cache, must-revalidate');
        header('Content-type: application/json; charset=utf-8');
    }

    public function Register($name) {
        $this->methods[$name] = true;
    }

    public function Remove($name) {
        $this->methods[$name] = false;
    }

    private function call($name, $args) {
        if ($this->methods[$name] == true) {
            $result = call_user_func_array($name, $args);
           return json_encode($result);
        }
    }

    function start() {
        try{
            if(!function_exists($this->strcall))
                throw new Exception("Function '".$this->strcall."' does not exist.");
            if (!$this->methods[$this->strcall])
                throw new Exception("Access denied for function '".$this->strcall."'.");

            header("HTTP/1.0 200 OK");
            print $this->call($this->strcall, json_decode($this->args));
        }
        catch(Exception $e){
            header("HTTP/1.0 500 Internal server error");
            print json_encode(
                array(
                    "message" => $e->getMessage(),
                    "code" => $e->getCode(),
                    "file" => $e->getFile(),
                    "line" => $e->getLine(),
                    "stackTrace" => $e->getTrace(),
                    "status" => array("message" => "Internal server error", "code" => "500")
                )
            );
        }
    }
}

//Obtiene el contenido de la solicitud POST
$HTTP_RAW_POST_DATA = isset($HTTP_RAW_POST_DATA) ? $HTTP_RAW_POST_DATA : ''; 
 
//Instancia de la clase JSON_WebService
$server = new JSON_WebService($HTTP_RAW_POST_DATA);
 
//Registra los metodos del servicio web
$server->register("getServerTime");
 
//Inicializa el servicio
$server->start();
 
//Define los metodos del servicio web
function getServerTime($format){
     return date($format);
}

Para la llamada al web service implementamos una clase cliente. Realmente lo que hacemos es utilizar las funciones de la librería libcurl pasándole por POST los parámetros a la página PHP que hace de servidor. El código lo tenemos a continuación:

class JSON_WebClient{
    private $URL;
    public function __construct($url){
        $this->URL = $url;
    }

    public function call($method, $args, $successCallback = false, $errorCallback = false){
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_HTTPHEADER, Array("Content-Type: application/json"));
        curl_setopt($ch, CURLOPT_URL, $this->URL."/".$method);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER,1);
        curl_setopt($ch, CURLOPT_TIMEOUT, 30);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($args));
        $resposeText = curl_exec($ch);
        $resposeInfo = curl_getinfo($ch);
        
        if($resposeInfo["http_code"] == 200){
            if($successCallback)
                call_user_func($successCallback, json_decode($resposeText));
        } else {
            if($errorCallback)
                call_user_func($errorCallback, json_decode($resposeText));
        }
    }
}

Y la llamada la tendríamos con este código:

    $client = new JSON_WebClient("http://localhost/service.php");
    $client->call("getServerTime", array("format"=>"d/m/o H:i:s"), "onSucceededCallback", "onErrorCallback");
    
    function onSucceededCallback($result){
        print $result;
    }
    
    function onErrorCallback($error){
        print "Error: ".$error->{"message"};
    }

Leer variables GET de una URL mediante Javascript

Es posible que necesitemos obtener los valores de una serie de parámetros que nos llegan por GET en una URL mediante Javascript. Con una sencilla función en la que utilizamos una expresión regular sobre el location.href obtendremos un array asociativo con el resultado. La página de la que queremos extraer los valores podría ser example.html?param1=value1¶m2=value2. Código

function getUrlVars() {
 var map = {};
 var parts = window.location.href.replace(/[?&]+([^=&]+)=([^&]*)/gi, function(m,key,value) {
  map[key] = value;
 });
 return map;
}

Llamada a la función

var params = getUrlVars();
var first = params["param1"];
var second = params["param2"];
 
alert(first);
alert(second);