Javascript cómo hacer un número a partir de una cadena. ¿Cómo convierte javascript una cadena en un número? Clasificación de conversión

JavaScript es un lenguaje escrito dinámicamente. Esto significa que se pueden escribir valores de diferentes tipos en la misma variable y el tipo de la variable en sí cambiará. Este comportamiento a menudo le permite olvidarse del comportamiento diferente de las variables con tipos diferentes, pero aún es necesario recordar esta característica. Demostremos esto con el siguiente ejemplo.

console.log (suma (1, 2)); // 3 (todo está bien aquí) console.log (sum (1, "2")); // 12 (no muy bien aquí)

Como puede ver en el ejemplo, la función suma se comporta incorrectamente si no se pasa un número como al menos uno de sus argumentos. El hecho es que al "agregar" un número a una cadena, el número se convierte en una cadena y se concatena (pega) con el segundo operando.

Para evitar tales complicaciones, puede averiguar el tipo de variable durante la ejecución del script y ajustar su comportamiento, o monitorear cuidadosamente los tipos de variables.

Tipo de operador

Este operador unario toma absolutamente cualquier valor como operando y devuelve su tipo en una variable de cadena.

Los siguientes tipos de datos existen en JavaScript:

// 1.) objeto console.log (typeof ()); // objeto var p = (x: 1, y: 3); console.log (tipo de p); // objeto // 2.) function function sayHello () (console.log ("¡Hola!");) console.log (typeof sayHello); // función // 3.) string console.log (tipo de "JavaScript"); // cadena // 4.) número console.log (tipo de 3.1415); // número // 5.) boolean console.log (typeof true); // booleano // 6.) indefinido var notExistsOne; console.log (tipo de notExistsOne); // indefinido console.log (typeof notExistsTwo); // indefinido

tenga en cuenta que indefinido también es un tipo de datos que consta de un solo valor.

Emitir

En programación, se entiende por encasillamiento convertir el valor de una variable de un tipo en un valor de otro tipo.
A menudo, esta conversión se produce sin el control del programador. Esto se puede ver en el ejemplo con la función suma... Un cambio de tipo ocurre cuando el resultado de una operación en una variable del tipo original no está claro. Por ejemplo, no puede decir con certeza qué resultará de agregar una cadena a un número, pero la operación de sumar dos números es obvia y, en este caso, es lógico convertir el número en una cadena.

Convertir cadena en número

A veces, el propio programador puede cambiar el tipo de una variable aplicándole determinadas operaciones. Por ejemplo, incrementar o disminuir una cadena la convertirá en un número.

var c = "no-un-número"; ++ c; console.log (tipo de c); // NaN

Vale la pena señalar que no es necesario recurrir a este método para convertir una cadena en un número debido a su escasa legibilidad y no obviedad. Hay funciones integradas para esta tarea en js parseInt y parseFloat... Como primer argumento, aceptan una cadena que debe convertirse en un número, y como segundo opcional, la base del sistema numérico, en el que el número se escribe en la cadena que se pasa como primer argumento. Si no se especifica el segundo argumento, se considerará que la cadena contiene un número decimal.

Función parseInt se utiliza para convertir una cadena en un número entero, y la función parseFloat convertir a fraccionario.

var a = parseInt ("10"); console.log (["a =", a, "; tipo de a:", tipo de a] .join ("")); // a = 10; typeof a: number var pi = parseInt ("3.1415"); console.log ("pi =" + pi); // pi = 3 pi = parseFloat ("3.1415"); console.log ("pi =" + pi); // pi = 3,1415

Tenga en cuenta que la cadena puede contener cualquier valor numérico literal, incluidos hexadecimal, octal o exponencial.

a = parseInt ("010"); console.log ("a =" + a); // a = 8 a = parseInt ("0xAA"); console.log ("a =" + a); // a = 170 a = parseFloat ("1e-10"); console.log ("a =" + a); // a = 1e-10 (1e-10 = 1 * 10 ^ -10 = 0.0000000001)

Como segundo parámetro de las funciones parseInt y parseFloat puede especificar la base.

a = parseInt ("10", 8); console.log ("a =" + a); // a = 8 a = parseInt ("010", 10); console.log ("a =" + a); // a = 10 a = parseInt ("ff", 16); console.log ("a =" + a); // a = 255

Si el valor de la cadena, que funciona parseInt y parseFloat tomar como primer parámetro, no es un literal numérico, entonces el resultado de estas funciones será el valor Yaya.

a = parseInt ("no es un número"); console.log ("a =" + a); // a = NaN a = parseFloat ("no es un número"); console.log ("a =" + a); // a = NaN

Conversión de cadenas

En JavaScript, un valor de cualquier tipo se puede convertir en una cadena. Ya se mencionó anteriormente que al concatenar una cadena con un número, el número se convierte en una cadena y solo entonces ocurre la concatenación. Esto sucederá con un valor de cualquier tipo.

var str = "Objeto:" + (); console.log (str); // Objeto: str = "Matriz:" + [1, 2, 3]; console.log (str); // Array: 1,2,3 function sum (a, b) (return a + b;) str = "Función:" + sum; console.log (str); / * Función: función suma (a, b) (return a + b;) * /

var str = "Objeto:" + (); console.log (str); // Objeto: str = "Matriz:" +; console.log (str); // Array: 1,2,3 function sum (a, b) (return a + b;) str = "Función:" + sum; console.log (str); / * Función: función suma (a, b) (return a + b;) * /

De hecho, al convertir un objeto en una cadena, el método se llama implícitamente Encadenar que también se puede llamar explícitamente.

var p = (x: 2, y: 4), str; str = p.toString (); console.log (tipo de str); // string console.log (str); // str = [1, 2, 3] .toString (); console.log (tipo de str); // string console.log (str); // 1,2,3

var p = (x: 2, y: 4), str; str = p.toString (); console.log (tipo de str); // cadena console.log (str); // str = .toString (); console.log (tipo de str); // cadena console.log (str); // 1,2,3

Conversión numérica

La conversión a un número se produce al realizar operaciones matemáticas y al realizar una operación de comparación con conversión de tipo (== ,! =), mientras que el valor falso y una matriz vacía se convierte en un valor de tipo 0 número.

var a = verdadero + verdadero + verdadero; // 1 + 1 + 1 console.log (a); // 3

Una matriz, un objeto y una función no vacíos se convierten en una cadena cuando se utilizan en expresiones aritméticas.

var arr = [1, 2, 3]; console.log (arr + 4); // 1,2,34 función sum (a, b) (return a + b;) console.log (sum + 5); // función sum (a, b) (return a + b;) 5

var arr =; console.log (arr + 4); // 1,2,34 función sum (a, b) (return a + b;) console.log (sum + 5); // función sum (a, b) (return a + b;) 5

Como puede ver, la conversión de tipo implícita en js está lejos de ser siempre obvia, por lo que debe evitarla utilizando funciones para la conversión de tipo explícita, como parseInt, parseFloat y Encadenar.

Eso es todo. Como siempre, ¡buena suerte!

Última modificación: 1.11.2015

A menudo es necesario transformar un dato en otro. Por ejemplo:

Var número1 = "46"; var number2 = "4"; var resultado = número1 + número2; console.log (resultado); // 464

Ambas variables representan cadenas, o más bien representaciones de cadenas de números. Y al final no obtenemos el número 50, sino la cadena 464. Pero sería bueno si también se pudieran sumar, restar, en general, funcionan como con números ordinarios.

En este caso, podemos utilizar operaciones de transformación. Para convertir una cadena en un número, use la función parseInt ():

Var número1 = "46"; var number2 = "4"; var resultado = parseInt (número1) + parseInt (número2); console.log (resultado); // 50

Para convertir cadenas en números fraccionarios, use la función parseFloat ():

Var número1 = "46.07"; var number2 = "4.98"; var resultado = parseFloat (número1) + parseFloat (número2); console.log (resultado); //51.05

En este caso, la cadena puede tener contenido mixto, por ejemplo, "123hello", es decir, en este caso hay números, pero también hay caracteres ordinarios. Pero el método parseInt () seguirá intentando realizar la conversión:

Var num1 = "123hello"; var num2 = parseInt (num1); console.log (num2); // 123

Si el método no se convierte, devuelve NaN (no es un número), lo que indica que la cadena no representa un número y no se puede convertir.

Con una función especial isNaN () puede comprobar si la cadena representa un número. Si la cadena no es un número, la función devuelve verdadero, si este número es falso:

Var num1 = "javascript"; var num2 = "22"; var result = isNaN (num1); console.log (resultado); // verdadero - num1 no es un número result = isNaN (num2); console.log (resultado); // falso - num2 es un número

Arriba, consideramos convertir cadenas en números en el sistema decimal. Sin embargo, podemos traducir números a cualquier sistema. De forma predeterminada, el propio intérprete de JavaScript adivina a qué sistema numérico queremos convertir la cadena (como regla, se elige el sistema decimal). Pero podemos usar el segundo parámetro para indicar explícitamente que queremos convertir una cadena en un número en un sistema específico. Por ejemplo, convertir a un número en binario:

Var num1 = "110"; var num2 = parseInt (num1, 2); console.log (num2); // 6

El resultado es 6, ya que 110 en binario es 6 en decimal.

Ahora escribamos un pequeño programa en el que usamos operaciones con variables:

JavaScript

Al usar la función prompt (), el navegador muestra un cuadro de diálogo que le solicita que ingrese algún valor. El segundo argumento de esta función indica el valor predeterminado.

Sin embargo, la función prompt () devuelve una cadena. Por lo tanto, necesitamos convertir esta cadena en un número para poder realizar operaciones con ella.

Después de abrir la página en el navegador, veremos una invitación para ingresar el monto del depósito:

A continuación, se mostrará un mensaje similar para la entrada de porcentaje. Y al final, el programa recibirá los datos, los convertirá en números y realizará el conteo.

los parseInt () La función analiza un argumento de cadena y devuelve un número entero de la base especificada (la base en los sistemas numéricos matemáticos).

La fuente de este ejemplo interactivo se almacena en un repositorio de GitHub. Si desea contribuir al proyecto de ejemplos interactivos, clone https://github.com/mdn/interactive-examples y envíenos una solicitud de extracción.

Sintaxis

parseInt (cadena, base)

Parámetros

cadena El valor para analizar. Si este argumento no es una cadena, entonces se convierte en uno usando la operación abstracta ToString. Se ignoran los espacios en blanco iniciales en este argumento. radix Opcional Un número entero entre 2 y 36 que representa la raíz (la base en los sistemas numéricos matemáticos) de la cadena. Ten cuidado, esto hace no por defecto a 10! Explica con más detalle lo que sucede cuando no se proporciona radix.

Valor devuelto

Un entero analizado a partir de la cadena dada.

Si la base es menor que 11 y el primer carácter que no es un espacio en blanco no se puede convertir en un número, se devuelve NaN.

Descripción

La función parseInt convierte su primer argumento en una cadena, analiza esa cadena y luego devuelve un número entero o NaN.

Si no es NaN, el valor de retorno será el número entero que es el primer argumento tomado como un número en la base especificada. (Por ejemplo, una base de 10 convierte de un número decimal, 8 convierte de octal, 16 de hexadecimal, etc.)

Para radices superiores a 10, las letras del alfabeto inglés indican números superiores a 9. Por ejemplo, para números hexadecimales (base 16), se utilizan de la A a la F.

Si parseInt encuentra un carácter que no es un número en la base especificada, lo ignora y todos los caracteres siguientes y devuelve el valor entero analizado hasta ese punto. parseInt trunca números a valores enteros. Se permiten espacios al principio y al final.

Debido a que algunos números usan el carácter e en su representación de cadena (p. Ej. 6.022e23 para 6.022 × 10 23), el uso de parseInt para truncar números producirá resultados inesperados cuando se use en números muy grandes o muy pequeños. parseInt debería no utilizarse como sustituto de Math.floor ().

parseInt entiende exactamente dos signos: + para positivo y - para negativo (desde ECMAScript 1). Se realiza como un paso inicial en el análisis después de eliminar los espacios en blanco. Si no se encuentran signos, el algoritmo pasa al siguiente paso; de lo contrario, elimina el signo y ejecuta el análisis de números en el resto de la cadena.

Si radix no está definido, 0 o no está especificado, JavaScript asume lo siguiente:

Si la cadena de entrada comienza con "0x" o "0X" (un cero, seguido de una X minúscula o mayúscula), se supone que la raíz es 16 y el resto de la cadena se analiza como un número hexadecimal.
Si la cadena de entrada comienza con "0" (un cero), se supone que la base es 8 (octal) o 10 (decimal). Exactamente qué base se elige depende de la implementación. ECMAScript 5 aclara que 10 (decimal) deberían ser utilizado, pero no todos los navegadores lo admiten todavía. Por esta razón, siempre especifique una base cuando use parseInt.
Si la cadena de entrada comienza con cualquier otro valor, la base es 10 (decimal).

Si el primer carácter no se puede convertir en un número, parseInt devuelve NaN a menos que la base sea mayor que 10.

Para fines aritméticos, el valor de NaN no es un número en ninguna base. Puede llamar a la función isNaN para determinar si el resultado de parseInt es NaN. Si NaN se pasa a operaciones aritméticas, el resultado de la operación también será NaN.

Para convertir un número a su literal de cadena en una base particular, use thatNumber .toString (base).

Ejemplos de

Usando parseInt

Todos los ejemplos siguientes devuelven 15:

ParseInt ("0xF", 16) parseInt ("F", 16) parseInt ("17", 8) parseInt (021, 8) parseInt ("015", 10) // pero `parseInt (015, 10)` return 13 parseInt (15.99, 10) parseInt ("15.123", 10) parseInt ("FXX123", 16) parseInt ("1111", 2) parseInt ("15 * 3", 10) parseInt ("15e2", 10) parseInt ("15px", 10) parseInt ("12", 13)

Todos los ejemplos siguientes devuelven NaN:

ParseInt ("Hola", 8) // No es un número en absoluto parseInt ("546", 2) // Los dígitos distintos de 0 o 1 no son válidos para la base binaria

Todos los ejemplos siguientes devuelven -15:

ParseInt ("- F", 16) parseInt ("- 0F", 16) parseInt ("- 0XF", 16) parseInt (-15.1, 10) parseInt ("- 17", 8) parseInt ("- 15", 10) parseInt ("- 1111", 2) parseInt ("- 15e1", 10) parseInt ("- 12", 13)

Todos los ejemplos siguientes devuelven 4:

ParseInt (4.7, 10) parseInt (4.7 * 1e22, 10) // Un número muy grande se convierte en 4 parseInt (0.00000000000434, 10) // Un número muy pequeño se convierte en 4

El siguiente ejemplo devuelve 224:

ParseInt ("0e0", 16) parseInt ("123_456") // 123

Interpretaciones octales sin raíz

Aunque es desaconsejado por ECMAScript 3 y prohibido por ECMAScript 5, muchas implementaciones interpretan una cadena numérica que comienza con un 0 inicial como octal. Lo siguiente puede tener un resultado octal o puede tener un resultado decimal. Siempre especifique una base para evitar este comportamiento poco confiable.

ParseInt ("0e0") // 0 parseInt ("08") // 0, porque "8" no es un dígito octal.

ECMAScript 5 elimina la interpretación octal

La especificación ECMAScript 5 de la función parseInt ya no permite que las implementaciones traten las cadenas que comienzan con un carácter 0 como valores octales. ECMAScript 5 establece:

La función parseInt produce un valor entero dictado por la interpretación del contenido del argumento de cadena de acuerdo con la base especificada. Se ignora el espacio en blanco inicial en la cadena. Si la raíz no está definida o es 0, se supone que es 10, excepto cuando el número comienza con los pares de caracteres 0x o 0X, en cuyo caso se asume una raíz de 16.

Esto difiere de ECMAScript 3, que desalienta pero permite la interpretación octal.

Muchas implementaciones no han adoptado este comportamiento a partir de 2013, y debido a que los navegadores más antiguos deben ser compatibles, siempre especifique una base.

Una función de análisis más estricta

A veces es útil tener una forma más estricta de analizar números enteros.

Las expresiones regulares pueden ayudar:

Función filterInt (valor) (if (/ ^ [- +]? (\ D + | Infinity) $ /. Test (value)) (return Number (value)) else (return NaN)) console.log (filterInt ("421 ")) // 421 console.log (filterInt (" - 421 ")) // -421 console.log (filterInt (" + 421 ")) // 421 console.log (filterInt (" Infinity ")) // Infinity console.log (filterInt ("421e + 0")) // NaN console.log (filterInt ("421hop")) // NaN console.log (filterInt ("hop1.61803398875")) // NaN console.log (filterInt ("1.61803398875")) // NaN

Especificaciones

Especificación	Estado	Comentario
ECMAScript 1st Edition (ECMA-262)	Estándar	Definición inicial.
ECMAScript 5.1 (ECMA-262)	Estándar
ECMAScript 2015 (6.a edición, ECMA-262) La definición de "parseInt" en esa especificación.	Estándar
Borrador más reciente de ECMAScript (ECMA-262) La definición de "parseInt" en esa especificación.	Borrador

Compatibilidad del navegador

La tabla de compatibilidad de esta página se genera a partir de datos estructurados. Si desea contribuir con los datos, consulte https://github.com/mdn/browser-compat-data y envíenos una solicitud de extracción.

Actualizar datos de compatibilidad en GitHub

	Escritorio						Móvil						Servidor
	Cromo	Borde	Firefox	explorador de Internet	Ópera	Safari	Vista web de Android	Chrome para Android	Firefox para Android	Opera para Android	Safari en iOS	Internet de Samsung	Node.js
parseInt	Soporte completo de Chrome 1	Soporte completo de Edge 12	Soporte completo de Firefox 1	IE Soporte completo 3	Opera Soporte completo Sí	Safari Soporte completo Sí	WebView Android Soporte completo 1	Compatibilidad total con Chrome Android 18	Soporte completo para Firefox Android 4		Safari iOS Soporte completo Sí	Samsung Internet Android Soporte completo 1.0	Nodejs Soporte completo Sí
Analiza las cadenas de cero a la izquierda son decimales, no octales	Soporte completo de Chrome 23	Soporte completo de Edge 12	Soporte completo de Firefox 21	IE Soporte completo 9	Opera Soporte completo Sí	Safari Soporte completo 6	Soporte completo de WebView Android 4.4	Compatibilidad total con Chrome Android 25	Compatibilidad total con Firefox Android 21	Opera Android Soporte completo Sí	Safari iOS Soporte completo 6	Samsung Internet Android Soporte completo Sí	Nodejs Soporte completo Sí

JavaScript tiene 2 funciones integradas para convertir cadenas en números: parseFloat () y parseInt ().

parseFloat () toma como argumento una cadena para convertirla en un tipo numérico y devuelve un flotante. El número debe estar al principio de la línea. Si hay otros caracteres después del número en la cadena, se truncan. La parte fraccionaria del número debe escribirse separada por un punto (una coma no se percibe como un separador). Si parseFloat () no puede convertir la cadena, devuelve NaN.

Además, la función puede procesar "el número n multiplicado por 10 a la potencia de x", que generalmente se escribe en programación mediante la letra E, por ejemplo: 0.5E6 o 0.5E + 6. El grado también puede ser negativo: 0.5E-6, que es igual a 0.5 * 10 ^ -6 o 0.5 / 1,000,000.

ParseFloat ("" 3.78kg "") // 3.78 parseFloat ("" kg33 "") // NaN parseFloat ("" 0004.111 "") // 4.111 parseFloat ("" 0x66 "") // 0 parseFloat ("". 5 "") // 0.5 parseFloat ("" -. 5 "") // -0.5 parseFloat ("" 0.5e6 "") // 500000 parseFloat ("" 0.03E + 2 "") // 3 parseFloat (" "3E-4" ") // 0.0003 parseFloat (" "- 3E-4" ") // -0.0003

La función parseInt (string [, radix]) toma una cadena como primer argumento, la analiza y devuelve un número entero (tipo entero). La función intenta analizar el sistema numérico en el que se escribe el número en la cadena de origen (por ejemplo, decimal, octal o hexadecimal, pero no solo estos). Además, el sistema numérico se puede especificar explícitamente pasándolo como el segundo parámetro radix. El parámetro radix puede tomar cualquier número entre 2 y 36 (los sistemas superiores a 10 usan el alfabeto inglés, de la A a la Z).

La función no maneja números como 1.5e6 de la misma manera que parseFloat ().

Lea los ejemplos a continuación, para no quedarse atascado en las trampas ocultas en la función parseInt ().

ParseInt ("" 25 "") // 25 parseInt ("" - 25 "") // -25 parseInt ("" 45.12 "") // 45 parseInt ("" 045 "", 10) // 45 parseInt ( "" 70 "", 8) // 56 (70 en octal es 56 en decimal) parseInt ("" 070 "") // 56 (¡¡¡IMPORTANTE !!! el primer cero hará que la función analice la cadena como un número octal ) parseInt ("" 88 "", 8) // NaN (no hay 8 en el sistema octal) parseInt ("" a1 "") // NaN (¡¡¡IMPORTANTE !!! La función no trata el número como hexadecimal por predeterminado si no lo agrega al principio de las líneas 0x) parseInt ("" a1 "", 16) // 161 (el sistema numérico se especifica explícitamente aquí) parseInt ("" 0xa1 "") // 161 (formato hexadecimal correcto , puede omitir el segundo parámetro) parseInt ("" 099 "") // 0 (¡¡¡IMPORTANTE !!! El número se interpreta como octal, pero contiene caracteres no válidos) parseInt ("" 0.5e6 "") // 0 (IMPORTANTE !!! no funciona como parseFloat) parseInt ("" ZZ "", 36) // 1295 parseInt ("" - FF "") // NaN parseInt ("" - FF "", 16) // -255

Si está procesando datos de un campo de texto que ingresa el usuario, siempre use parseInt () con el segundo parámetro de base, esto mantendrá su código a salvo de resultados inesperados.

No importa qué tipo de variable se use en una expresión. Si la expresión es matemática, todas sus variables se interpretarán automáticamente como numéricas. Si se procesan cadenas, todos los "participantes" de la expresión se tratan como cadenas. Sin embargo, el problema de conversión de cadenas a números de JavaScript existe en un contexto mucho más amplio.

Métodos de JavaScript para convertir cadenas en números

El arsenal de métodos para convertir cadenas en números no es grande, pero es suficiente para todos los casos simples. Aquí JavaScript (especialmente para principiantes) es un camino de simple a complejo con ejemplos prácticos.

El ejemplo describe cuatro líneas diferentes. En el primer bloque de salida, el tipo de cada variable, el tipo de función se define como cadena. Luego, cada línea se convierte en un número muy fácilmente. En el segundo bloque de salida, puede ver los cambios en las variables después de la conversión, su tipo se ha convertido en un número. El ejemplo de la transformación parseFloat de JavaScript es especialmente revelador: era "12e + 3", ahora "12000".

¡Los cambios al convertir una cadena en un número pueden ser significativos! Pero solo importan los primeros caracteres: deben ser numéricos. Si no hay caracteres numéricos, el resultado es NaN.

La conversión inversa de una cadena que "se convirtió" en un número no siempre es la misma cadena. Este momento se puede utilizar para verificar la exactitud de la entrada de información numérica.

Métodos de conversión convencionales

Hay enteros y hay fraccionarios, respectivamente, JavaScript convierte una cadena en un número de la siguiente manera:

parseInt;
parseFloat.

El caso general se implementa mediante el uso de una cadena en una expresión matemática simple.

Basta con poner un signo "+" delante de la cadena de símbolos y, si contiene un número, el resultado de la expresión será un número. El valor de una variable puede cambiar, pero el tipo siempre cambiará: typeof mostrará un número, no una cadena. Es importante comprender que el uso de la variable convertida en una expresión de cadena puede producir resultados muy diferentes.

JavaScript para principiantes en este contexto es extremadamente simple. Es más difícil entender el trabajo de la conversión de enteros usando el método pasrseInt, ya que funciona automáticamente en el sistema numérico decimal, pero puede interpretar la cadena como octal o hexadecimal. Además, esta circunstancia no siempre depende del segundo parámetro, que indica el sistema numérico.

JavaScript siempre convertirá una cadena en un número, pero si la cadena no tiene un solo carácter numérico al principio de la cadena, el resultado será NaN.

Es necesario tener una idea sobre los sistemas numéricos, sobre cómo escribir números hexadecimales (el número comienza con "0x") y octales (el número comienza con "0").

Para comprender los matices del método parseFloat de JavaScript, basta con tener una idea de lo que es la notación matemática de un número real.

Clasificación de conversión

JavaScript es un idioma de navegador, porque más que otros idiomas es crítico con los caracteres fuera del conjunto principal del alfabeto latino y los números. La clasificación es una operación demandada. Pero no siempre tiene sentido enviar datos al servidor para fines de clasificación; es más fácil y práctico hacer el trabajo en el lugar, en el navegador.

Para resolver este problema, puede convertir los caracteres de una cadena a sus códigos numéricos o asignar letras y números a una secuencia ordenada de números. El método charCodeAt () aplicado a la cadena asignará el valor numérico 98 a la variable iB, es decir, el código de la letra "b". Teniendo en cuenta que el valor del código de la letra "a" es igual a 97, puede obtener los números de todas las letras del alfabeto latino en orden ascendente por conjuntos de minúsculas y mayúsculas. Lo mismo ocurre con las letras del alfabeto ruso.

La propia variante de clasificación por números le permite formar los juegos de caracteres deseados. Puede, por ejemplo, "reorganizar" el alfabeto cirílico y latino o mezclarlos para dejar solo letras que sean excelentes en escritura, agregar tabulación y caracteres de espacio a los conjuntos.

Formación de un número único de una cadena.

Si el código de la letra "a" es 97, entonces la diferencia entre la letra y el número 97 dará el número único de la letra en el alfabeto. Al sumar los números únicos para cada carácter en una cadena, es difícil obtener el número único para esa cadena.

Si a cada posición de una letra en una cadena se le asigna un peso, por ejemplo, posición:

0 peso 1;
1 peso 10;
2 peso 100;

Luego, al multiplicar el número único de cada carácter de la cadena por el peso de la posición en la que se encuentra y sumar todos los números, puede obtener un número único y usarlo como una coincidencia uno a uno con el original. cuerda.

Esta conversión de una cadena a un número es reversible, es decir, por el número, siempre se puede obtener la cadena original. Esta conversión es beneficiosa, porque cualquier operación se puede realizar con un número de forma segura en el contexto de la codificación, cirílico y otras características locales de la página del sitio, el alcance y el país del visitante.

Selectores de páginas de sitios "en crecimiento"

A menudo surge el problema de crear selectores en las páginas del sitio, cuyos valores no se pueden especificar de antemano, pero con el tiempo se complementan. En la primera aplicación, un selector vacío está disponible para que el primer visitante ingrese información.

Cada nueva entrada de una línea de información en el selector (por cualquier visitante) se transforma en un número que, junto con el original, se envía al servidor para su almacenamiento. Cuando se inicia una nueva sesión o llega un nuevo visitante, el selector ya no está vacío. La página cuando se carga llega al navegador con un selector no vacío.

Para cada nuevo valor del selector, se envía al servidor para su almacenamiento solo una vez, y solo una vez se le asigna un código numérico único.

No puede utilizar el método de cadena a número de JavaScript para resolver este problema. Los métodos habituales parseInt y parseFloat tienen usos diferentes, pero puede pensar en un algoritmo para convertir una cadena en un número sin ambigüedades y no necesariamente reversible. Es suficiente que el algoritmo de conversión no se repita en diferentes conjuntos de caracteres en la cadena.

Optimización y análisis del tráfico

Al formar una página, el desarrollador usa una cantidad significativa de información. Permitir que el visitante ingrese información es una buena manera de degradar la clasificación del sitio debido a su débil funcionalidad y frustrar al visitante.

Al asignar un controlador de eventos a las acciones de un visitante en forma de una función de JavaScript para ciertos bloques de información, puede formular un filtro que le permitirá al visitante establecer un objetivo con precisión, encontrar la información necesaria y obtener la solución deseada. .

La conversión de información de cadena aquí puede ser arbitrariamente amplia en la parte de la cadena y muy pequeña en la parte del número. En otras palabras, el desarrollador realiza la conversión de una cadena de JavaScript a un número de acuerdo con su propio algoritmo. El visitante manipula información comprensible y la cantidad mínima de datos se envía al servidor: un número.

La dinámica de un conjunto de números para todos los visitantes en el contexto de información conocida con precisión permite que otra función de JavaScript (no un controlador), llamada a una respuesta del servidor a través del mecanismo AJAX, proporcione rápidamente a todos los visitantes la información necesaria simultáneamente en tiempo real. . Así es como funciona el sistema.

Esta opción de convertir cadenas de JavaScript en números tiene mucha demanda en el desarrollo de juegos en línea, conferencias interactivas, mensajería instantánea, etc.

Aplicación instrumental de transformaciones

JavaScript y CSS en el contexto del procesamiento de información numérica le permiten controlar la visualización de una página sin la participación del servidor. Las reglas CSS se construyen como subcadenas, de forma recursiva. Por lo general, el parámetro es un número seguido de varias letras (por ejemplo, "px", "pt", "em", ...). Un parámetro es una subcadena en una regla y una regla es una subcadena en una clase o estilo de identificador.

Recursion de JavaScript.Substring.Substring ... va al número deseado, convierte de una cadena a un número, lo modifica y vuelve a escribir en el lugar deseado. La regla se cambia automáticamente. Es simple y conveniente, sin participación del servidor.