viernes, 31 de octubre de 2014

Contar los elementos de un array en PHP

Para contar cuántos elementos tiene un array que hayamos creado tenemos dos funciones en PHP. Se trata de las funciones count() y sizeof(). La segunda de ellas es realmente un alias de la primera, con lo que la sintaxis y comportamiento es exactamente el mismo.

En algunos blogs he leído que sizeof() puede llegar a ser más rápido que count() pero mis pruebas siempre han sacado unos resultados prácticamente idénticos.

Sintaxis

count(array, modo);
sizeof(array, modo);

Parámetros

array: Obligatorio. Especifica el array del que queremos contar los elementos
modo: Opcional. Especifica el modo de contar. Los valores posibles son:
             0 - Valor por defecto. No hace falta especificarlo. Cuenta los elementos de primer nivel
             1 - Cuenta el array recursivamente y devuelve el total de elementos si es multidimensional
Veamos un par de ejemplos de funcionamiento:

$comida = array('frutas' => array('naranja', 'pera', 'manzana'),
                          'verduras' => array('tomate', 'pimiento'));

// Count normal
count($comida); // devuelve un 2

// Count recursivo
count($comida, 1); // devuelve un 7


jueves, 30 de octubre de 2014

Obtener el tamaño de las tablas de una base de datos MySQL

En el anterior post hablábamos sobre cómo obtener el tamaño de las base de datos. En esta ocasión nos centramos en el tamaño de las tablas de una base de datos.

Lo que haremos será una SQL que nos devuelva todas las tablas de la base de datos test ordenadas de la que ocupa más tamaño a la que ocupa menos, expresada la información en MB.

La SQL sería así:

mysql> SELECT  table_name, table_rows,
        ROUND(data_length / (1024 * 1024), 2) AS `data_size`,
        ROUND(index_length / (1024 * 1024), 2) AS `index_size`,
        ROUND((data_length + index_length) / (1024 * 1024), 2) AS `total_size`,
    FROM information_schema.TABLES
    WHERE table_schema = 'test'
    ORDER BY 5 DESC;

Obtener el tamaño de una base de datos MySQL

Hace unos días me pidieron en una aplicación web en la que estaba trabajando que mostrase el tamaño que tenía la base de datos MySQL.

Como no tenía ninguna función a mano se me ocurrió investigar un poco y con esta simple SQL pude obtener la información que solicitaban.


Los datos del tamaño los muestro en MB y en la consulta me devuelve la información de todas las bases de datos a las que tiene acceso el usuario con el que lanzamos la query.

mysql> SELECT table_schema AS `name_bd`, sum( data_length + index_length ) / 1024 / 1024 AS `size`
    ->   FROM information_schema.TABLES
    ->   GROUP BY table_schema;

Lo que devuelve esta función es lo siguiente:

+--------------------+--------------+
| name_bd            | size         |
+--------------------+--------------+
| information_schema |   0.00390625 |
| test               | 173.52998352 |
+--------------------+--------------+
2 rows in set (0.80 sec)

Si quisiéramos obtener únicamente una base de datos en concreto, deberíamos añadir a la consulta una condición WHERE.

mysql> SELECT table_schema AS `name_bd`, sum( data_length + index_length ) / 1024 / 1024 AS `size`
    ->   FROM information_schema.TABLES
    ->   WHERE table_schema='test'
    ->   GROUP BY table_schema;

Y el resultado es:

+----------------+--------------+
| name_bd        | size         |
+----------------+--------------+
| test           | 173.52998352 |
+----------------+--------------+
1 row in set (0.84 sec)

miércoles, 29 de octubre de 2014

Función GROUP_CONCAT de MySQL

En esta ocasión os presento una función muy útil para mostrar datos agrupados cuyo valor de agrupación no es un count() o un sum() o las típicas funciones agregadas. De lo que se trata es de concatenar todos los valores de un campo que cumplan el criterio de un GROUP BY pero separados por el separador que elijamos. Para entenderlo mejor veamos un ejemplo.

Tenemos una tabla llamada ESTUDIANTES con la siguiente estructura:

mysql> select * from estudiantes;
+--------+-------------+------+
| nombre | asignatura  | nota |
+--------+-------------+------+
| María  | Matemáticas |  5.5 |
| María  | Inglés      |    8 |
| María  | Física      | 3.75 |
| Carlos | Matemáticas | 4.25 |
| Carlos | Inglés      |   10 |
| Carlos | Física      |  7.5 |
+--------+-------------+------+
6 rows in set (0.00 sec)

Sobre estos registros queremos extraer por cada estudiante la lista de asignaturas que ha aprobado, es decir, en las que ha sacado más de un 5.

mysql> select nombre, group_concat(asignatura separator '-') from estudiantes where nota>=5 group by nombre;
+--------+----------------------------------------+
| nombre | group_concat(asignatura separator '-') |
+--------+----------------------------------------+
| Carlos | Inglés-Física                          |
| María  | Matemáticas-Inglés                     |
+--------+----------------------------------------+
2 rows in set (0.00 sec)

En este caso hemos indicado que el separador sería un guión pero podríamos haber indicado cualquier otro. Si no indicamos ningún separador nos lo va a devolver separado por comas.

mysql> select nombre, group_concat(asignatura) from estudiantes where nota>=5 group by nombre;
+--------+--------------------------+
| nombre | group_concat(asignatura) |
+--------+--------------------------+
| Carlos | Inglés,Física            |
| María  | Matemáticas,Inglés       |
+--------+--------------------------+
2 rows in set (0.01 sec)

Esto es muy útil y ahora simplemente si recorriésemos los resultados mediante PHP podrías crear fácilmente una tabla HTML

Esta función group_concat() puede devolver como máximo 1024 caracteres que es el límite por defecto tal y como explican en la documentación de MySQL. Sin embargo esto se puede cambiar editando el fichero my.cnf de configuración y modificando el valor de la variable.

group_concat_max_len=16386

Otra forma es ejecutando previamente la siguiente sentencia.

SET GLOBAL group_concat_max_len=4096

Fuentes:

Función sleep, delay, pause o wait en Javascript

Hoy mismo hemos necesitado realizar una función que nos permitiese de forma fácil hacer un sleep, delay, pause o wait mediante Javascript.

Esto es realmente sencillo si usamos un setTimeout() pero no quería tener que llamar a otra función al pasar el tiempo especificado así que he buscado un poco en google y he encontrado esta:

function sleep(milliseconds) {
  var start = new Date().getTime();
  for (var i = 0; i < 1e7; i++) {
    if ((new Date().getTime() - start) > milliseconds){
      break;
    }
  }
}


Fuente:

http://www.sitepoint.com/delay-sleep-pause-wait/

martes, 28 de octubre de 2014

Ejecutar proceso en background con PHP

Si necesitamos ejecutar algún proceso en segundo plano en algún script de PHP, podemos llamar a una función sencilla que nos diferenciará si lo estamos ejecutando desde Windows o Linux, ya que el comportamiento es diferente.

El código de esta función es el siguiente:

function execInBackground($cmd) { 
    if (substr(php_uname(), 0, 7) == "Windows"){ 
        pclose(popen("start /B ". $cmd, "r"));  
    } 
    else { 
        exec($cmd . " > /dev/null &");   
    } 
}

Espero que les sirva.

Añadir elementos a un array en PHP

Con PHP tenemos varias formas de añadir elementos a un array. El primero de ellos es la función nativa array_push().

La sintaxis y los parámetros que debemos utilizar son los siguientes:

int array_push ( array &$array , mixed $value1 [, mixed $... ] );

Lo que hacemos es pasarle un array por referencia como primer parámetro y a continuación los elementos a añadir. La función nos devolverá un valor entero con el número de elementos del array después de haber insertado lo que hayamos definido.

Un ejemplo lo podemos ver aquí:

<?php
$myarray = array('pera', 'manzana', 'naranja');
array_push($myarray, 'melón', 'sandía');
?>

Esto devolvería lo siguiente:

Array
(
    [0] => pera
    [1] => manzana
    [2] => naranja
    [3] => melón
    [4] => sandía
)

Otra forma mucho más sencilla para añadir un elemento al array sería:

<?php
$myarray[] = 'melón';
?>

Según la documentación oficial de PHP, deberíamos utilizar esta segunda forma si queremos únicamente añadir un elemento, ya que así evitamos la sobrecarga de llamar a una función. Además, esta segunda forma crea el array si no existe, mientras que con la función array_push() nos devolvería un warning.

Una comparativa sobre la velocidad de ejecución la podemos ver con una simple prueba que detallamos:

<?php
$myarray = array();
for ($i=0; $i<100000; $i++){
    array_push($myarray, $i);
} // tarda 1.5962453267801 segundos

$myarray = array();
for ($i=0; $i<100000; $i++){
    $myarray[] = $i;
} // tarda 0.0614528790371 segundos
?>

En este caso la mejora de rendimiento es del orden de 26 veces.

lunes, 20 de octubre de 2014

Tres formas de crear usuarios en MySQL

El sistema gestor de bases de datos MySQL posee una completa gestión y configuración de permisos y usuarios.

En este nuevo post vamos a ver tres posibilidades de creación de usuarios. El primero y el segundo son los más habituales. El tercero ya es algo extraño de utilizar.

1. Sentencia GRANT

La sentencia GRANT proporciona privilegios y permisos a los usuarios de MySQL. Para poder utilizar esta sentencia el usuario con el que accedas a MySQL debe ser el usuario root o un usuario con privilegios de GRANT OPTION.

Si queremos crear un usuario simplemente lanzamos la siguiente sentencia:

mysql> GRANT ALL ON test.* TO 'testuser'@'localhost' IDENTIFIED BY 'pass_testuser';
Query OK, 0 rows affected (0.05 sec)

Con esta sentencia lo que hemos conseguido es darle todos los permisos a un usuario llamado testuser sobre todas las tablas de la base de datos test, que solamente podrá conectarse a la base de datos desde el ámbito localhost y que tiene un password pass_testuser. Además, si el usuario no existe lo crea. Los privilegios ALL [PRIVILEGES] da todos los permisos excepto el GRANT.

La sentencia GRANT, si encuentra que el usuario no existe lo crea, siempre que el servidor MySQL tenga el parámetro NO_AUTO_CREATE_USER inactivo. Si estuviera activo solamente nos permitiría crear usuarios que no tengan password asignado.

La mayor utilidad de este método es que con una única sentencia creamos el usuario y le damos los permisos.

Si se necesita ampliar la información sobre los permisos lo podéis hacer desde la documentación oficial de MySQL sobre GRANT.

2. Sentencia CREATE USER

Con esta sentencia lo que haremos simplemente será crear un usuario, específicándole el ámbito en el que funcionará y su password.

mysql> CREATE USER 'testuser'@'localhost' IDENTIFIED BY 'pass_testuser';
Query OK, 0 rows affected (0.05 sec)

En esta ocasión no le estaremos dando permisos sobre ninguna base de datos. Lo que estamos haciendo es crear el usuario con permisos para conectarse desde localhost y con un password. Si queremos ahora darle permisos podríamos hacer lo siguiente para conseguir lo mismo que en la sentencia GRANT anterior:

mysql> GRANT ALL ON test.* TO 'testuser'@'localhost';
Query OK, 0 rows affected (0.00 sec)

3. Insert directo sobre la tabla user

Este último sería el método más complicado y que MySQL no recomienda. Se trata de realizar un insert sobre la tabla user de la base de datos mysql.

Lo primero que deberíamos conocer es la estructura de la tabla y para ello nos tenemos que conectar a la base de datos mysql:

mysql> use mysql;
Database changed

mysql> describe user;
+-----------------------+-----------------------------------+------+-----+---------+-------+
| Field                 | Type                              | Null | Key | Default | Extra |
+-----------------------+-----------------------------------+------+-----+---------+-------+
| Host                  | char(60)                          | NO   | PRI |         |       |
| User                  | char(16)                          | NO   | PRI |         |       |
| Password              | varchar(41)                       | NO   |     |         |       |
| Select_priv           | enum('N','Y')                     | NO   |     | N       |       |
| Insert_priv           | enum('N','Y')                     | NO   |     | N       |       |
| Update_priv           | enum('N','Y')                     | NO   |     | N       |       |
| Delete_priv           | enum('N','Y')                     | NO   |     | N       |       |
| Create_priv           | enum('N','Y')                     | NO   |     | N       |       |
| Drop_priv             | enum('N','Y')                     | NO   |     | N       |       |
| Reload_priv           | enum('N','Y')                     | NO   |     | N       |       |
| Shutdown_priv         | enum('N','Y')                     | NO   |     | N       |       |
| Process_priv          | enum('N','Y')                     | NO   |     | N       |       |
| File_priv             | enum('N','Y')                     | NO   |     | N       |       |
| Grant_priv            | enum('N','Y')                     | NO   |     | N       |       |
| References_priv       | enum('N','Y')                     | NO   |     | N       |       |
| Index_priv            | enum('N','Y')                     | NO   |     | N       |       |
| Alter_priv            | enum('N','Y')                     | NO   |     | N       |       |
| Show_db_priv          | enum('N','Y')                     | NO   |     | N       |       |
| Super_priv            | enum('N','Y')                     | NO   |     | N       |       |
| Create_tmp_table_priv | enum('N','Y')                     | NO   |     | N       |       |
| Lock_tables_priv      | enum('N','Y')                     | NO   |     | N       |       |
| Execute_priv          | enum('N','Y')                     | NO   |     | N       |       |
| Repl_slave_priv       | enum('N','Y')                     | NO   |     | N       |       |
| Repl_client_priv      | enum('N','Y')                     | NO   |     | N       |       |
| Create_view_priv      | enum('N','Y')                     | NO   |     | N       |       |
| Show_view_priv        | enum('N','Y')                     | NO   |     | N       |       |
| Create_routine_priv   | enum('N','Y')                     | NO   |     | N       |       |
| Alter_routine_priv    | enum('N','Y')                     | NO   |     | N       |       |
| Create_user_priv      | enum('N','Y')                     | NO   |     | N       |       |
| ssl_type              | enum('','ANY','X509','SPECIFIED') | NO   |     |         |       |
| ssl_cipher            | blob                              | NO   |     | NULL    |       |
| x509_issuer           | blob                              | NO   |     | NULL    |       |
| x509_subject          | blob                              | NO   |     | NULL    |       |
| max_questions         | int(11) unsigned                  | NO   |     | 0       |       |
| max_updates           | int(11) unsigned                  | NO   |     | 0       |       |
| max_connections       | int(11) unsigned                  | NO   |     | 0       |       |
| max_user_connections  | int(11) unsigned                  | NO   |     | 0       |       |
+-----------------------+-----------------------------------+------+-----+---------+-------+
37 rows in set (0.00 sec)

Para a continuación poder realizar el insert de la siguiente forma:

mysql> INSERT INTO user VALUES('localhost','testuser',PASSWORD('pass_testuser'),'Y','Y', 'Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','','','','',0,0,0,0);
Query OK, 1 row affected (0.01 sec)

El último paso que nos falta es refrescar las tablas de permisos de la siguiente forma:

mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)

Al igual que en el método anterior de CREATE USER, con esto únicamente creamos el usuario, pero no le estamos dando permisos sobre ninguna base de datos. Deberíamos hacerlo igual que en el punto anterior:

mysql> GRANT ALL ON test.* TO 'testuser'@'localhost';
Query OK, 0 rows affected (0.00 sec)

Espero que les pueda servir de ayuda.

Función row_count de MySQL

La función row_count() de MySQL es una función que devuelve el número de filas afectadas de una serie de sentencias SQL tal y como veremos a continuación. Tiene una funcionalidad similar a mysql_affected_rows() de la API de C.

Según el tipo de sentencias devolverá un valor u otro:
  • Sentencias DDL: devuelve un 0. Esto es aplicable a sentencias como CREATE TABLE o DROP TABLE.
  • Sentencias DML diferentes del SELECT: devuelve el número de filas afectadas. Esto se aplica a las sentencias clásicas de INSERT, UPDATE o DELETE, así como a ALTER TABLE LOAD DATA INFILE.
  • Sentencias SELECT: devuelve un -1 si la sentencia devuelve un conjunto de registros. En caso contrario devuelve el número de registros afectados. Por ejemplo SELECT * FROM tabla devuelve -1, pero si hacemos SELECT * FROM tabla INTO OUTFILE 'fichero' devuelve el número de registros que se han volcado al fichero.
  • En las sentencias REPLACE: devuelve un 2 si el nuevo registro reemplaza el anterior. En este caso devuelve un 2 por la fila eliminada y la nueva.

Os presentamos un ejemplo de uso de esta función:

mysql> INSERT INTO tabla VALUES(1),(2),(3);
Query OK, 3 rows affected (0.00 sec)
Records: 3  Duplicates: 0  Warnings: 0

mysql> SELECT ROW_COUNT();
+-------------+
| ROW_COUNT() |
+-------------+
|           3 |
+-------------+
1 row in set (0.00 sec)

mysql> DELETE FROM tabla WHERE i IN(1,2);
Query OK, 2 rows affected (0.00 sec)

mysql> SELECT ROW_COUNT();
+-------------+
| ROW_COUNT() |
+-------------+
|           2 |
+-------------+
1 row in set (0.00 sec)

Función in_array en Javascript

La función in_array() de PHP comprueba si existe un valor dentro del array y nos devuelve true o false. Esta función no existe en Javascript pero la podemos crear fácilmente.

Tenemos el siguiente array en Javascript:

var arrCiudades = ['Londres', 'París', 'Roma', 'Madrid', 'Moscú'];


Si usásemos el framework JQuery no habría problema ya que ya la lleva implementada y simplemente tendríamos que hacer lo siguiente:

if ($.inArray('Madrid', arrCiudades)){ 
  alert('Encontrada'); 
} else { 
  alert('No encontrada'); 
}


En Javascript lo que hacemos es añadírsela al objeto Array de la siguiente forma:

Array.prototype.in_array = function(){ 
  for (var i in this) { 
    if (this[i] == arguments[0]){ 
      return true; 
    }
  } 
  return false; 
}


Podríamos haber buscado simplemente con el método indexOf() que nos devuelve un -1 si no existe o el índice si sí que encuentra el elemento, pero no funciona con el navegador Internet Explorer 8 y anteriores.

Una vez tenemos esto ya podemos buscar si el elemento existe en el array con la siguiente llamada:

if (arrCiudades.in_array('Madrid')){ 
  alert('Encontrada'); 
} else { 
  alert('No encontrada'); 
}


Espero que les pueda servir.

domingo, 19 de octubre de 2014

Obtener el último registro insertado en una tabla en MySQL

En MySQL tenemos una característica muy común en los campos que hacen de clave primaria que es el AUTO_INCREMENT. Al insertar un registro en una tabla que tenga una clave numérica autoincrementable, es habitual necesitar dicho valor.

Para esto tenemos la función last_insert_id() de MySQL que nos devolverá dicho valor, siempre que estemos en la misma sesión en la que hayamos hecho la inserción.

Veamos un ejemplo claro de su uso con la creación de una tabla vehiculos, otra de conductores y la última que relaciona ambas llamada alquiler_vehiculos.

CREATE TABLE vehiculos(
  id_vehiculo INT NOT NULL AUTO_INCREMENT,
  marca VARCHAR(50) NOT NULL,
  modelo VARCHAR(50) NOT NULL,
  color VARCHAR(50) NOT NULL,
  PRIMARY KEY(id_vehiculo)
);

CREATE TABLE conductores(
  id_conductor INT NOT NULL AUTO_INCREMENT,
  nombre VARCHAR(50) NOT NULL,
  apellidos VARCHAR(50) NOT NULL,
  PRIMARY KEY(id_conductor)
);

CREATE TABLE alquiler_vehiculos(
  id_vehiculo INT NOT NULL,
  id_conductor INT NOT NULL,
  PRIMARY KEY(id_vehiculo, id_conductor)
);


Ahora vamos a insertar registros en la tabla vehiculos. El insert lo podemos hacer de dos formas diferentes obteniendo el mismo resultado. En la primera ponemos un null al campo AUTO_INCREMENT y en la segunda enumeramos los campos omitiendo el primero.

mysql> INSERT INTO vehiculos VALUES (null, 'Ford', 'Focus', 'Negro');
Query OK, 1 row affected (0.28 sec)

mysql> INSERT INTO vehiculos (marca, modelo, color) VALUES ('Ford', 'Focus', 'Negro');
Query OK, 1 row affected (0.28 sec)

En ambos casos podemos recuperar el valor de id_vehiculo con last_insert_id().

mysql> SELECT last_insert_id();
+------------------+
| last_insert_id() |
+------------------+
|                1 |
+------------------+
1 row in set (0.01 sec)

Ahora lo que haremos será lo mismo para los conductores y en ese momento aprovecharemos el resultado de last_insert_id() para insertar el registro del alquiler.

mysql> INSERT INTO conductores (nombre, apellidos) VALUES ('Carlos', 'Martín');
Query OK, 1 row affected (0.00 sec)

mysql> INSERT INTO alquiler_vehiculos VALUES (1, last_insert_id());
Query OK, 1 row affected (0.23 sec)


Si obtenemos los registros de la tabla veremos que nos ha insertado un 1 en el id_conductor.

mysql> SELECT * FROM alquiler_vehiculos;
+-------------+--------------+
| id_vehiculo | id_conductor |
+-------------+--------------+
|           1 |            1 |
+-------------+--------------+
1 row in set (0.00 sec)

Sin embargo, si hacemos un insert múltiple, la función last_insert_id nos dará el id del primer registro insertado.

mysql> INSERT INTO vehiculos (marca, modelo, color) VALUES ('Ford', 'Focus', 'Blanco'), ('BMW', '330D', 'Gris'), ('Honda', 'Accord', 'Negro');
Query OK, 3 rows affected (0.04 sec)
Registros: 3  Duplicados: 0  Peligros: 0

mysql> SELECT last_insert_id();
+------------------+
| last_insert_id() |
+------------------+
|                2 |
+------------------+
1 row in set (0.00 sec)

En este caso, si quisiéramos saber el id del último registro deberíamos combinarlo con la función num_rows() de esta forma.

mysql> SELECT row_count()+last_insert_id()-1;
+--------------------------------+
| row_count()+last_insert_id()-1 |
+--------------------------------+
|                             4 |
+--------------------------------+
1 row in set (0.00 sec)

Espero que os pueda servir de ayuda.

jueves, 16 de octubre de 2014

Convertir la primera letra de un string en mayúsculas en PHP y Javascript

Si necesitamos convertir la primera letra de un string a mayúsculas tenemos una forma muy sencilla en PHP mediante la función directa ucfirst.

$str = 'micadena';
echo ucfirst($str); // Micadena


En cambio con Javascript no tenemos ninguna función directa y la tenemos que crear nosotros.

var str = 'micadena';
str = str[0].toUpperCase() + str.slice(1);
alert(str); // Micadena

Espero que les sirva.

Función nl2br en Javascript

La función nl2br de PHP nos proporciona una utilidad a la hora de recuperar información de la base de datos que se ha guardado con caracteres de salto de línea o break line. Lo que realiza en definitiva es convertir los caracteres \r\n, \n\r, \r y \n por <br> o <br />.

Para realizar esto mismo en Javascript podemos usar la siguiente función:

function nl2br(str, is_xhtml) {
  var breakTag = (is_xhtml || typeof is_xhtml === 'undefined') ? '< br />' : '< br>'; // Eliminar el espacio antes del br

  return (str + '')
    .replace(/([^>\r\n]?)(\r\n|\n\r|\r|\n)/g, '$1' + breakTag + '$2');
}


Fuente:

http://phpjs.org/functions/nl2br/

Validar formularios con HTML5

Como muchos de vosotros ya sabréis, HTML5 ha aportado nuevas características de validación de formularios con el atributo required de los elementos <input>. Sin embargo sigue siendo necesario realizar la validación clásica ya que ciertos navegadores como Internet Explorer 9 y anteriores y Safari no soportan dicho atributo.

El primer paso que debemos dar sería indicar que un elemento es obligatorio de la siguiente forma:




Con esto conseguiremos que simplemente nos aparezca un mensaje genérico por parte del navegador. Si queremos personalizar dicho mensaje usaremos el atributo title:



Si queremos ir más allá y validar que lo que escribamos en el email tenga un formato correcto añadiremos el atributo pattern:



Con esto ya hemos conseguido validar el formato y mostrar un mensaje personlizado, pero podemos hacérselo un poco más fácil al usuario que debe introducir su email escribiéndole por defecto el formato dentro del mismo texto con el atributo placeholder:



Fuentes:

http://www.w3schools.com/tags/att_input_required.asp

martes, 14 de octubre de 2014

Samsung anuncia que está trabajando en un nuevo estándar de Wifi que multiplicará hasta por 5 la velocidad actual

El gigante surcoreano ha anunciado que está trabajando en un nuevo estándar Wifi, el llamado 802.11ad, que según indican, multiplicará hasta por cinco la velocidad de conexión del estándar actual.

Este nuevo estándar que está desarrollando Samsung utiliza ondas de 60 GHz para la transmisión en lugar de los 2.4 o 5 GHz que se utilizan actualmente. Para ello "Samsung ha superado satisfactoriamente las barreras para la comercialización de la tecnología WiFi de 60 GHz y está deseosa de poder empezar a comercializar esta nueva tecnología", ha explicado en el blog de la empresa, Samsung TomorrowKim Chang Yong, Director del Centro DMC R&D de Samsung Electronics.

Según explican en el mismo blog, a diferencia de las tecnologías Wifi actuales a 2.4GHz y 5GHz, el nuevo estándar 802.11ad de Samsung, mantiene la velocidad máxima eliminando las interferencias del canal de transmisión, independientemente del número de dispositivos que estén utilizando la misma red.

Con todo esto la velocidad de transmisión llegaría hasta los 4.6 Gbps o 575 MB por segundo, cinco veces más que los 866 Mbps o 108 MB por segundo, que es la máxima velocidad posible actualmente. Como resultado, un fichero de 1GB podría enviarse en menos de tres segundos entre dos dispositivos conectados a la misma red Wifi.

Los planes de Samsung Electronics pasan por empezar la comercialización de esta nueva tecnología a partir del 2015 o 2016 y pretenden implantarla en "dispositivos visuales y médicos" así como en el equipamiento de sistemas de telecomunicación, el desarrollo del hogar inteligente de Samsung y otras iniciativas relacionadas con el Internet de las cosas.


Fuentes:

http://global.samsungtomorrow.com/?p=43234
http://www.elmundo.es/tecnologia/2014/10/13/543ba783e2704e23238b457c.html

lunes, 13 de octubre de 2014

Eliminar elemento array Javascript

Si deseamos eliminar un elemento de un array en Javascript tenemos varios métodos que podemos utilizar:

Operador delete


Con el operador delete realmente no estamos eliminando. Si nos fijamos lo que realmente hemos conseguido es establecer el valor undefined al elemento del array.
var myArray = ["A", "B", "C"];
delete myArray[1];  // myArray -> ["A", undefined, "C"]

Método pop()


Si lo que necesitamos es eliminar un elemento al final de un array podemos utilizar este método pop().
var myArray = ["A", "B", "C"];
myArray.pop();  // myArray -> ["A", "B"]


Método shift()


Con este operador shift() lo que conseguimos hacer es eliminar el primer elemento del array.
var myArray = ["A", "B", "C"];
myArray.shift();  // myArray -> ["B", "C"]

Método splice(index, count)


A pesar de que el método splice() sirve también para añadir elementos a un array, si solamente usamos los dos primeros parámetros, lo que estaremos haciendo será eliminar elementos. Con este ejemplo podremos apreciar mejor qué sucede.
var myArray = ["A", "B", "C"];
myArray.splice(1, 1);  // myArray -> ["A", "C"]

Resumen


En resumen, si tenemos un array definido de la siguiente forma: myArray = ["A", "B", "C"] los métodos vistos anteriormente nos devolverán los siguientes resultados:
  • delete myArray[1] -> devuelve ["A", undefined, "C"]
  • myArray.pop() -> devuelve ["A", "B"]
  • myArray.shift() -> devuelve ["B", "C"]
  • myArray.splice(1, 1) -> devuelve ["A", "C"]
  • myArray.splice(0, 2) -> devuelve ["C"]
  • myArray.splice(1, 0, "D", "E") -> devuelve ["A", "D", "E", "B", "C"]


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

Dart accede por primera vez al top 20

Este mes tenemos como novedad más importante la irrupción del lenguaje de programación de código abierto Dart, de la empresa Google, entre los 20 primeros. El llamado sucesor de Javascript asciende concretamente hasta la posición número 17. Sin embargo sus mayores competidores como CoffeeScript o TypeScript siguen todavía muy lejos de las primeras posiciones, en los puestos 133 y 122 respectivamente.

Los ingenieros de Google desarrollaron este lenguaje en el año 2011 pero su mayor preocupación fue que los demás navegadores no fuesen compatibles, como finalmente así fue. Para ello crearon una herramienta que compila de Dart a ECMAScript 3 al instante. Además, también posee de una máquina virtual nativa en Google Chrome. La primera versión estable apareció en noviembre de 2013, tras más de dos años después de ser presentada.

Según los propios desarrolladores, Dart está pensado para resolver los problemas de Javascript y ofrecer mejores resultados. Además puede ser una herramienta sencilla para proyectos más grandes y ofrece una mejor seguridad. No obstante, si nos fijamos en el ránking, al mismo tiempo que Dart está subiendo, Javascript retrocede algunas posiciones.

Si queréis investigar un poco más sobre Dart os dejo un par de enlaces:

- Página oficial del proyecto: https://www.dartlang.org
- Blog sobre Google Dart en español: http://blogdart.es

El índice de este mes de octubre queda de la siguiente forma:

Oct 2014Oct 2013ChangeProgramming LanguageRatingsChange
11C17.655%+0.41%
22Java13.506%-2.60%
33Objective-C10.096%+1.10%
44C++4.868%-3.80%
56changeC#4.748%-0.97%
67changeBasic3.507%-1.31%
75changePHP2.942%-3.15%
88Python2.333%-0.77%
912changePerl2.116%+0.51%
109changeTransact-SQL2.102%-0.52%
1117changeDelphi/Object Pascal1.812%+1.11%
1210changeJavaScript1.771%-0.27%
1311changeVisual Basic .NET1.751%-0.18%
14-changeVisual Basic1.564%+1.56%
1521changeR1.523%+0.97%
1613changeRuby1.128%-0.12%
1781changeDart1.119%+1.03%
1824changeF#0.868%+0.37%
19-changeSwift0.761%+0.76%
2014changePascal0.726%-0.03%