funciones útiles para manejo de cadenas en JS

A continuación se muestran algunas de las funciones más útiles para el manejo de cadenas de texto:

length, calcula la longitud de una cadena de texto (el número de caracteres que la forman)

var mensaje = "Hola Mundo";
var numeroLetras = mensaje.length; // numeroLetras = 10

+, se emplea para concatenar varias cadenas de texto

var mensaje1 = "Hola";
var mensaje2 = " Mundo";
var mensaje = mensaje1 + mensaje2; // mensaje = "Hola Mundo"

Además del operador +, también se puede utilizar la función concat()

var mensaje1 = "Hola";
var mensaje2 = mensaje1.concat(" Mundo"); // mensaje2 = "Hola Mundo"

Las cadenas de texto también se pueden unir con variables numéricas:

var variable1 = "Hola ";
var variable2 = 3;
var mensaje = variable1 + variable2; // mensaje = "Hola 3"

Cuando se unen varias cadenas de texto es habitual olvidar añadir un espacio de separación entre las palabras:

var mensaje1 = "Hola";
var mensaje2 = "Mundo";
var mensaje = mensaje1 + mensaje2; // mensaje = "HolaMundo"

Los espacios en blanco se pueden añadir al final o al principio de las cadenas y también se pueden indicar forma explícita:

var mensaje1 = "Hola";
var mensaje2 = "Mundo";
var mensaje = mensaje1 + " " + mensaje2; // mensaje = "Hola Mundo"

toUpperCase(), transforma todos los caracteres de la cadena a sus correspondientes caracteres en mayúsculas:

var mensaje1 = "Hola";
var mensaje2 = mensaje1.toUpperCase(); // mensaje2 = "HOLA"

toLowerCase(), transforma todos los caracteres de la cadena a sus correspondientes caracteres en minúsculas:

var mensaje1 = "HolA";
var mensaje2 = mensaje1.toLowerCase(); // mensaje2 = "hola"

charAt(posicion), obtiene el carácter que se encuentra en la posición indicada:

var mensaje = "Hola";
var letra = mensaje.charAt(0); // letra = H
letra = mensaje.charAt(2);     // letra = l

indexOf(caracter), calcula la posición en la que se encuentra el carácter indicado dentro de la cadena de texto. Si el carácter se incluye varias veces dentro de la cadena de texto, se devuelve su primera posición empezando a buscar desde la izquierda. Si la cadena no contiene el carácter, la función devuelve el valor -1:

var mensaje = "Hola";
var posicion = mensaje.indexOf('a'); // posicion = 3
posicion = mensaje.indexOf('b');     // posicion = -1

Su función análoga es lastIndexOf():

lastIndexOf(caracter), calcula la última posición en la que se encuentra el carácter indicado dentro de la cadena de texto. Si la cadena no contiene el carácter, la función devuelve el valor -1:

var mensaje = "Hola";
var posicion = mensaje.lastIndexOf('a'); // posicion = 3
posicion = mensaje.lastIndexOf('b');     // posicion = -1

La función lastIndexOf() comienza su búsqueda desde el final de la cadena hacia el principio, aunque la posición devuelta es la correcta empezando a contar desde el principio de la palabra.

substring(inicio, final), extrae una porción de una cadena de texto. El segundo parámetro es opcional. Si sólo se indica el parámetro inicio, la función devuelve la parte de la cadena original correspondiente desde esa posición hasta el final:

var mensaje = "Hola Mundo";
var porcion = mensaje.substring(2); // porcion = "la Mundo"
porcion = mensaje.substring(5);     // porcion = "Mundo"
porcion = mensaje.substring(7);     // porcion = "ndo"

Si se indica un inicio negativo, se devuelve la misma cadena original:

var mensaje = "Hola Mundo";
var porcion = mensaje.substring(-2); // porcion = "Hola Mundo"

Cuando se indica el inicio y el final, se devuelve la parte de la cadena original comprendida entre la posición inicial y la inmediatamente anterior a la posición final (es decir, la posición inicio está incluida y la posición final no):

var mensaje = "Hola Mundo";
var porcion = mensaje.substring(1, 8); // porcion = "ola Mun"
porcion = mensaje.substring(3, 4);     // porcion = "a"

Si se indica un final más pequeño que el inicio, JavaScript los considera de forma inversa, ya que automáticamente asigna el valor más pequeño al inicio y el más grande al final:

var mensaje = "Hola Mundo";
var porcion = mensaje.substring(5, 0); // porcion = "Hola "
porcion = mensaje.substring(0, 5);     // porcion = "Hola "

split(separador), convierte una cadena de texto en un array de cadenas de texto. La función parte la cadena de texto determinando sus trozos a partir del carácter separador indicado:

var mensaje = "Hola Mundo, soy una cadena de texto!";
var palabras = mensaje.split(" ");
// palabras = ["Hola", "Mundo,", "soy", "una", "cadena", "de", "texto!"];

Con esta función se pueden extraer fácilmente las letras que forman una palabra:

var palabra = "Hola";
var letras = palabra.split(""); // letras = ["H", "o", "l", "a"]

3.5.2. Funciones útiles para arrays

A continuación se muestran algunas de las funciones más útiles para el manejo de arrays:

length, calcula el número de elementos de un array

var vocales = ["a", "e", "i", "o", "u"];
var numeroVocales = vocales.length; // numeroVocales = 5

concat(), se emplea para concatenar los elementos de varios arrays

var array1 = [1, 2, 3];
array2 = array1.concat(4, 5, 6);   // array2 = [1, 2, 3, 4, 5, 6]
array3 = array1.concat([4, 5, 6]); // array3 = [1, 2, 3, 4, 5, 6]

join(separador), es la función contraria a split(). Une todos los elementos de un array para formar una cadena de texto. Para unir los elementos se utiliza el carácter separador indicado

var array = ["hola", "mundo"];
var mensaje = array.join(""); // mensaje = "holamundo"
mensaje = array.join(" ");    // mensaje = "hola mundo"

pop(), elimina el último elemento del array y lo devuelve. El array original se modifica y su longitud disminuye en 1 elemento.

var array = [1, 2, 3];
var ultimo = array.pop();
// ahora array = [1, 2], ultimo = 3

push(), añade un elemento al final del array. El array original se modifica y aumenta su longitud en 1 elemento. (También es posible añadir más de un elemento a la vez)

var array = [1, 2, 3];
array.push(4);
// ahora array = [1, 2, 3, 4]

shift(), elimina el primer elemento del array y lo devuelve. El array original se ve modificado y su longitud disminuida en 1 elemento.

var array = [1, 2, 3];
var primero = array.shift();
// ahora array = [2, 3], primero = 1

unshift(), añade un elemento al principio del array. El array original se modifica y aumenta su longitud en 1 elemento. (También es posible añadir más de un elemento a la vez)

var array = [1, 2, 3];
array.unshift(0);
// ahora array = [0, 1, 2, 3]

reverse(), modifica un array colocando sus elementos en el orden inverso a su posición original:

var array = [1, 2, 3];
array.reverse();
// ahora array = [3, 2, 1]

Funciones útiles para números

A continuación se muestran algunas de las funciones y propiedades más útiles para el manejo de números.

NaN, (del inglés, "Not a Number") JavaScript emplea el valor NaN para indicar un valor numérico no definido (por ejemplo, la división 0/0).

var numero1 = 0;
var numero2 = 0;
alert(numero1/numero2); // se muestra el valor NaN

isNaN(), permite proteger a la aplicación de posibles valores numéricos no definidos

var numero1 = 0;
var numero2 = 0;
if(isNaN(numero1/numero2)) {
  alert("La división no está definida para los números indicados");
}
else {
  alert("La división es igual a => " + numero1/numero2);
}

Infinity, hace referencia a un valor numérico infinito y positivo (también existe el valor –Infinitypara los infinitos negativos)

var numero1 = 10;
var numero2 = 0;
alert(numero1/numero2); // se muestra el valor Infinity

toFixed(digitos), devuelve el número original con tantos decimales como los indicados por el parámetro digitos y realiza los redondeos necesarios. Se trata de una función muy útil por ejemplo para mostrar precios.

var numero1 = 4564.34567;
numero1.toFixed(2); // 4564.35
numero1.toFixed(6); // 4564.345670
numero1.toFixed(); // 4564

Nueva extensión OPcache con PHP

La nueva extensión OPcache de PHP 5.5

PHP es un lenguaje de programación interpretado, lo que significa que cada vez que se ejecuta un archivo PHP, primero debe compilarse. Si un archivo no cambia con frecuencia, resulta absurdo perder el tiempo compilando una y otra vez un archivo que no ha cambiado.

Por ese motivo, hace muchos años surgieron sistemas de caché como APC que guardan los archivos compilados y los utilizan mientras el archivo original no cambie. Si activas APC es fácil multiplicar el rendimiento de la aplicación entre 2 y 10 veces sin tocar una sola línea de código.

La versión 5.5 de PHP introduce una nueva caché llamada OPcache y que está destinada a reemplazar a APC. En realidad, OPcache es el nuevo nombre del producto Zend Optimizer+ que la empresa Zend lleva años utilizando en sus servicios. Esto significa que OPcache es un producto maduro y probado en miles de servidores de todo tipo. Además, OPcache es hasta un 20% más rápido que APC en muchas pruebas de rendimiento con aplicaciones PHP típicas (ver pruebas de rendimiento).

Instalando la extensión OPcache

Si utilizas PHP 5.5, OPcache ya está instalado y configurado. Si utilizas PHP 5.2, 5.3 o 5.4, puedes emplear el paquete ZendOpcache de PECL correspondiente a tu versión.

Si ya la tienes instalada y no te aparece dentro de las extensiones activadas, puede que tengas que añadir o descomentar la siguiente línea en tu archivo php.ini:

; en servidores Linux y Mac
zend_extension=/ruta/hasta/la/librería/opcache.so
 
; en servidores Windows
zend_extension=C:\ruta\hasta\el\archivo\php_opcache.dll

Si además de OPcache utilizas la extensión Xdebug, asegúrate de cargar primero la extensión OPcache dentro de tu archivo de configuración.

Configurando la extensión OPcache

El manual oficial de PHP recomienda la siguiente configuración para la extensión OPcache:

opcache.enable=1
opcache.enable_cli=1
opcache.memory_consumption=128
opcache.interned_strings_buffer=8
opcache.max_accelerated_files=4000
opcache.revalidate_freq=60
opcache.fast_shutdown=1

La siguiente tabla explica cada una de estas opciones y también indica su valor por defecto:

Opción	Valor inicial	Descripción
`opcache.enable`	`1`	Activa la extensión. Cambia su valor a `0` para desactivar OPcache
`opcache.enable_cli`	`0`	Activa OPcache cuando se ejecuta PHP en la línea de comandos
`opcache.memory_consumption`	`64`	Cantidad de memoria en MB que puede consumir la caché de OPcache
`opcache.interned_strings_buffer`	`4`	Cantidad de memoria en MB utilizada para guardar cadenas de texto que se pueden calcular en tiempo de compilación en vez de ejecución
`opcache.max_accelerated_files`	`2000`	Número máximo de archivos que se compilan. El valor debe estar entre 200 y 100.000
`opcache.revalidate_freq`	`2`	Cada cuantos segundos se comprueba si un archivo compilado ha cambiado. Si el valor es `0`, se comprueba en cada petición. Para desactivar esta comprobación, utiliza la opción`opcache.validate_timestamps`
`opcache.fast_shutdown`	`0`	Si se activa, la extensión OPcache no libera la memoria ocupada, sino que delega esa tarea en el gestor de memoria del motor Zend de PHP. Activar esta opción mejora el rendimiento, pero la memoria se reserva durante más tiempo

Si comparas la tabla anterior (que muestra los valores por defecto de OPcache) con la configuración que recomiendan en el manual oficial de PHP (mostrada anteriormente), verás que la configuración recomendada es más apropiada para aplicaciones PHP complejas, como por ejemplo las que utilizan frameworks como Symfony y Zend.

Al margen de las recomendaciones anteriores, la mejor configuración siempre es la que se ajusta mejor a tu servidor y tus aplicaciones. No olvides probar diferentes valores para cada opción de configuración y analiza las mejoras o pérdidas de rendimiento que consigues con cada cambio. Así conseguirás llegar a la configuración ideal para tu servidor.

Configuración avanzada

La extensión OPcache tiene muchas otras opciones que puedes configurar. Para aquellos programadores que utilizan frameworks como Symfony y Zend o librerías como Doctrine2, la opciónopcache.save_comments es realmente importante.

El valor por defecto de esta opción es 1, lo que significa que se mantienen todos los comentarios del código fuente de los archivos que se compilan. Si cambias su valor a 0, todos los comentarios se eliminan, lo que mejora el rendimiento y reduce significativamente el tamaño de los archivos compilados.

El problema es que si eliminas los comentarios, es posible que estés rompiendo el código de Symfony, Doctrine, PHPUnit y muchas otras aplicaciones que utilizan unos comentarios especiales llamados anotaciones para modificar el comportamiento del código.

Así que si utilizas Symfony, Doctrine, Zend Framework o PHPUnit, asegúrate de tener la opción opcache.save_comments=1 o tu aplicación dejará de funcionar.

Otra opción muy importante es opcache.enable_file_override, cuyo valor inicial es 0. Si cambias su valor a 1, cada vez que en tu aplicación ejecutes las funciones file_exists(), is_file() yis_readable(), se comprueba primero si el archivo que pasas como argumento a las funciones anteriores ha sido cacheado. Esta comprobación puede mejorar el rendimiento, pero a cambio corres el riesgo de estar comprobando archivos cacheados que ya no existen o han cambiado.

La siguiente tabla recoge el resto de opciones disponibles en OPcache. A menos que sepas muy bien lo que estás haciendo, es mejor que no modifiques el valor de estas opciones:

Opción	Valor inicial	Descripción
`opcache.max_wasted_percentage`	`5`	Porcentaje máximo de memoria desperdiciada que se tolera antes de forzar un reinicio de OPcache
`opcache.use_cwd`	`1`	Si se activa, OPcache añade el directorio al nombre de cada archivo que cachea, por lo que se reducen las posibles colisiones entre archivos con el mismo nombre
`opcache.validate_timestamps`	`1`	Si se activa, los archivos cacheados se comprueban periódicamente para ver si han cambiado. Si se desactiva el rendimiento aumenta muchísmo, pero a cambio debes reiniciar el servidor web o borrar la caché a mano cada vez que cambies un archivo
`opcache.revalidate_path`	`0`	Los archivos cacheados con el mismo nombre y el mismo `include_path` se reutilizan (puede haber problemas con archivos con el mismo nombre pero distinta localización)
`opcache.load_comments`	`1`	Si se desactiva, los comentarios del código fuente no se cargan, aunque los archivos cacheados mantengan esos comentarios
`opcache.optimization_level`	`0xffffffff`	Su formato es el de una máscara de bits que indica cuáles de las diferentes pasadas de OPcache se ejecutan
`opcache.inherited_hack`	`1`	Opción válida sólo para PHP 5.2 y qu evita un bug relacionado con la herencia de clases
`opcache.dups_fix`	`0`	Activa esta opción si se producen errores de tipo "Cannot redeclare class"
`opcache.blacklist_filename`	`''`	Ruta donde se encuentra el archivo que indica qué archivos no se deben cachear (puedes indicar directorios enteros e incluso nombres de archivos con asteriscos. Ej:`*Repositroy.php`)
`opcache.max_file_size`	`0`	Máximo tamaño de archivo en bytes que se puede guardar en la caché. El valor `0` indica que no hay límites
`opcache.consistency_checks`	`0`	Si es distinto de `0` la consistencia de la caché se comprueba cada `N` peticiones, donde `N` es el valor de esta opción
`opcache.force_restart_timeout`	`180`	Duranción en segundos del tiempo que se espera hasta reiniciar OPcache en caso de que la caché no responda
`opcache.error_log`	`''`	Ruta del archivo donde se registrarán los errores que se produzcan
`opcache.log_verbosity_level`	`1`	Máximo nivel de errores que se guardan en el log. Por defecto, solamente los errores de tipo`fatal` y `error`
`opcache.preferred_memory_model`	`''`	No toques esta opción si no sabes lo que estás haciendo. Esta opción te permite elegir el tipo de memoria a utilizar entre los siguientes valores: `mmap`, `shm`, `posix` y `win32`
`opcache.protect_memory`	`0`	Opción reservada para la depuración interna de OPcache
`opcache.mmap_base`	`null`	Utilizada solamente para indicar la base de los segmentos de memoria compartida en Windows

Utilizando la configuración de APC en OPcache

Si estás acostumbrado a utilizar la caché APC, la siguiente tabla muestra el equivalente en OPcache de las opciones de configuración más habituales de APC:

APC	OPcache
`apc.enabled=1`	`opcache.enable=1`
`apc.shm_segments=1` y`apc.shm_size=128M`	`opcache.memory_consumption=128`
`apc.num_files_hint=4000`	`opcache.max_accelerated_files=4000`
`apc.stat=1`	`opcache.validate_timestamps=1`
`apc.max_file_size=2M`	`opcache.max_file_size=2`
`apc.filters="/var/www/apc.php"`	`opcache.blacklist_filename="/var/www/opcache.txt"`

Funciones de OPcache

La extensión OPcache incluye dos funciones muy útiles cuando se utiliza la caché en el servidor de producción. La primera función es opcache_reset() que no admite parámetros y devuelve como resultado un valor booleano. El propósito de esta función es borrar toda la caché de OPcache(equivale a al función apc_clear_cache()).

Si utilizas la opción opcache.validate_timestamps=0 e instalas una nueva versión de tu aplicación en el servidor, los cambios no se tendrán en cuenta hasta que caduquen los archivos cacheados. La solución más drástica suele ser reiniciar el servidor, pero con la función opcache_reset() puedes obtener el mismo resultado de forma más elegante.

La otra opción definida por OPcache es opcache_invalidate(), que no borra toda la memoria caché sino un único archivo cacheado:

// borra el archivo 'index.php' de la caché solamente si es más
// nuevo que el archivo 'index.php' cacheado
opcache_invalidate('index.php');
 
// borra el archivo 'index.php' de la caché (sin importar
// su fecha de modificación)
opcache_invalidate('index.php', true);

Conectar a una BD mysql desde SQL SERVER con servidores vinculados

Escenario :

Tengo un servidor principal con SQL Server como manejador de base de datos. Adicionalmente, tengo un servidor Linux (con redhat) con un sistema en php que conecta a una base de datos MySQL instalada en dicho terminal. El problema : Necesito pasar información de SQL a Mysql de 2 a 4 veces por día. ¿Como hago para pasar toda la información y que se mantenga en la capa de Datos ?. Después de varios días de investigación y de haber encontrado 3 posibles soluciones sin salir de la capa de datos ( freetds era una muy buena opción, ejecuciones con procesos en segundo plano bajo en cron de linux) , he optado por solucionar el problema con lo que me parece la manera mas elegante y certera. servidores vinculados.

¿Qué es un servidor vinculado?

Su nombre lo dice todo, agrego una BD externa al SQL y la hago accesible, con esto puedo hacer todo tipo de consultas tipo transac sql.

EMPEZAMOS

1. Instala los driver que te permite manejar la base Mysql. Entonces bajar el conector ODBC para mysql

http://dev.mysql.com/downloads/connector/odbc/

2. Luego de instalarlo debemos configurarlo, creamos el odbc y lo configuramos:

Yo tengo el sql server 2005 :

Entra al "Panel de Control" y busca "Herramientas Administrativas". Entra en este y aparecerá "Orígenes de datosODBC".

Se abrirá la siguiente ventana. Busca el botón "Agregar".

Clic sobre Mysql ODBC 3.51 driver (que es lo que instalaste en el paso 1). Luego sobre finalizar.

Se abre el conector ODBC del MySQL. En este debes definir los parámetros de conexión a tu base de datos MySQL. Simplemente agrega el nombre de tu servidor, tu user y password. No olvides colocar el nombre de la conexión (DataSource Name). Lo vamos a usar en el Paso 3. Sugiero "MySQL_LINK".

3. Vincular Mysql con SQL Server 2005

En el administrador corporativo del SQL Server 2005 buscas la opción "Objetos del servidor". Dentro existe una subcarpeta llamada "Servidores vinculados".

clic derecho sobre Servidores vinculados y buscamos la opción "Nuevo servidor vinculado".

Se abre la ventana "Nuevo servidor vinculado" y colocas los parámetros para conectarse con la base MySQL.

Marcas la opción "Otro origen de datos" . Debes colocar los siguientes parámetros.

Servidor vinculado : LINKED_MYSQL (coloca el nombre que desees)

Proveedor : Microsoft OLE DB Provider for ODBC Drivers.

Nombre del Producto : MySQL

Origen de datos : MySQL_LINK (Ojo: Este es el nombre del ODBC que creaste en el paso 2, colocale el que tu hayas colocado.)

Cadena de proveedor : ODBC:DSN=MySQL_LINK::Table=aaa (el valor aaa es una tabla de la base MySQL, coloca cualquiera de las tablas de tu base. DSN es el nombre del ODBC que creaste en el paso 2)

Catálogo : pyp1 (nombre de la base de datos a la cuál quieras conectarte)

Dentro de la misma ventana, clic en la ficha "Seguridad" para que establecer con que user y password nos vamos a conectar. Clic en "Se establecerán usando este contexto de seguridad" y colocamos el user y password. Luego clicen el botón "Aceptar". Eso es todo, ya tenemos vinculado nuestro servidor MySQL con SQL 2005.

4. Hacer consultas SQL en el servidor vinculado.

Ubicación : En el servidor central donde esta la base SQL Server 2005

Vayamos a probar si podemos hacer consultas en MySQL.

Ejecutamos exec sp_Tables_Ex 'LINKED_MYSQL' (Devolvemos información acerca de las tablas de el servidor que hemos vinculado.LINKED_MYSQL es el nombre del servidor vinculado que hemos creado). Se deben mostrar las tablas del servidor vinculado.

Veamos algunos ejemplos de sentencias SQL con openquery.

¿Si quiero mostrar datos de las tablas?

select * from openquery (LINKED_MYSQL,'select * from aaa')

¿Si quiere eliminar los datos de un tabla?

Delete openquery (LINKED_MYSQL,'select * from aaa'). ¡Borramos todos los datos de la tabla 'aaa'!

¿Si quiero insertar datos en dicha tabla?

insert into openquery(LINKED_MYSQL,'select * FROM aaa')

(Field1, Field2,...)

SELECT Field1, Field2,...

FROM Tabla

¿Y para actualizar datos?

Update openquery(LINKED_MYSQL,'Select * from aaa') SET Cod_Ind = 7

WHERE Cod_Ind = 7.5

http://www.forosdelweb.com/f21/como-hacer-insert-liskserver-por-openquery-238208/