Conversión de cadenas Js. Conversión de tipos de datos en JavaScript. Conversión de valores a valores booleanos

Buen día a todos. Alexey Gulynin está en contacto. En el último artículo, aprendiste sobre los tipos de datos en Javascript. En este artículo me gustaría hablar de conversión de tipos en Javascript. Las conversiones de tipos en Javascript y, de hecho, en cualquier lenguaje de programación, se realizan con mucha frecuencia. Primero quería hablar sobre la conversión de tipos al comparar variables u otras condiciones que resultan en verdadero o falso. Al comparar variables de diferentes tipos, se realizan conversiones en segundo plano. El punto principal aquí es que durante dichas transformaciones en segundo plano, el valor almacenado en la variable no cambia. la variable se convierte al tipo de datos (se crea un valor temporal de la variable) que es necesario para realizar la operación. Te daré un ejemplo:

Se comparan variables de tipo cadena y tipo numérico. Al comparar, los valores de estas variables se reducen al mismo tipo de datos. Luego, la comparación devuelve un valor booleano y los valores temporales convertidos se eliminan. Todas las transformaciones dependen del contexto: los operadores que realizan acciones sobre ellas. Código de muestra:

Var a = 5; var b = "15"; si (un< b) alert("a < b"); else alert("a >b");

En este caso, la variable b se convertirá a un número (se realizó la conversión en segundo plano del tipo String al tipo Number, y se obtendrá el valor temporal de la variable b de tipo Number = 15, que se eliminará después se realiza la operación de comparación), y el resultado será que un .

A continuación se muestra una tabla que muestra cómo se convierte un tipo de datos en otro:

Tipo de valor	Contexto en el que se utiliza el valor.
	Cadena	Numérico	Lógico	Objeto
Valor indefinido	'indefinido'	Yaya	FALSO	Error
nulo	'nulo'	0	FALSO	Error
linea vacia	linea vacia	0	FALSO	Objeto de cadena
cadena no vacía	cadena no vacía	Valor de cadena numérica o NaN	verdadero	Objeto de cadena
0	’0′	0	FALSO	Objeto numérico
Yaya	'Yaya'	Yaya	FALSO	Objeto numérico
Infinidad	'Infinidad'	Infinidad	verdadero	Objeto numérico
-Infinidad	'-Infinidad'	-Infinidad	verdadero	Objeto numérico
cualquier otro numero	Representación en cadena de un número	El número en sí	verdadero	Objeto numérico
verdadero	'verdadero'	1	verdadero	Objeto booleano
FALSO	'FALSO'	0	FALSO	Objeto booleano
Objeto, función	Encadenar()	valor de(), toString() o NaN	verdadero	Objeto, función

Conversiones de tipos de datos

Puede obtener un tipo de datos booleano a partir de cualquier tipo de datos. Esto se hace usando el operador de negación o doble negación. Ejemplo:

Var a = 20; var b = !a; //devuelve falso var c = !!a; //devuelve verdadero

Se puede obtener una cadena de cualquier objeto. Ejemplo:

Var a = 20; var b = a.toString(); //devuelve "20" var c = a + ""; //devuelve "20" tipo de b; //devuelve cadena tipode c; //devuelve cadena

Obtener un número de una cadena. Ejemplo:

Var a = "20"; var b = a * 1; //devuelve 20 var c = + a; //devuelve 20 tipo de b; //número de retorno tipode c; //número de devolución

Analicemos ahora, con base en el conocimiento adquirido, el comportamiento del “Y” lógico (&&) y "O" lógico (||):

"Y" lógico (&&):

Para que este operador se ejecute correctamente, es necesario que los valores de todos los operandos se puedan convertir a verdaderos. Si los valores de todos los operandos se pueden convertir a verdaderos, se devolverá el valor original del último operando comparado. Si el valor de al menos un operando se convierte en falso, se devuelve el valor original de ese operando. Ejemplo:

Vara = 15; var b = "abc"; var c = 0; resultado de la variable; resultado = a && b && c; //devuelve 0 resultado = c && b && a; //devuelve 0 resultado = 7 && a; //devuelve 15 resultado = 7 && b; //devuelve "abc"

"O" lógico (||):

Déjame explicarte un poco sobre operadores y operandos. Analicemos la expresión resultadot = a && b && c . Aquí los operadores son "=" y "&&", es decir. estas son acciones. Operandos: resultado, a, b, c. Sobre esto se toman medidas.

No importa qué tipo de variable se utilice en la expresión. Si la expresión es matemática, todas sus variables automáticamente se interpretarán como numéricas. Si se procesan cadenas, todos los "participantes" de la expresión se tratan como cadenas. Sin embargo, el desafío de la conversión de cadena a número en 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 en todos los casos simples. Aquí JavaScript (especialmente para principiantes) es el camino de lo simple a lo complejo utilizando ejemplos prácticos.

El ejemplo describe cuatro cadenas diferentes. En el primer bloque de salida, la función typeof define el tipo de cada variable como cadena. Luego, cada cadena se convierte de manera muy simple en un número. En el segundo bloque de salida son visibles los cambios en las variables después de la conversión, su tipo se ha convertido en un número. El ejemplo de conversión de JavaScript parseFloat es particularmente ilustrativo: era "12e+3" y se convirtió en "12000".

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

La conversión inversa de una cadena que "se convierte" en un número no siempre es la misma cadena. Este punto se puede utilizar para comprobar la exactitud de la introducción de información numérica.

Métodos de conversión comunes

Hay números enteros y números fraccionarios, respectivamente, JavaScript convierte una cadena en un número mediante:

• parseInt;
• analizar flotar.

El caso general se implementa utilizando la cadena en una expresión matemática simple.

Basta con poner un signo “+” delante de la cadena de caracteres y, si contiene un número, entonces 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 una variable convertida en una expresión de cadena puede producir un resultado completamente diferente.

JavaScript para principiantes en este contexto es extremadamente simple. Es más difícil entender el funcionamiento de la conversión de números enteros usando el método passreInt, ya que funciona automáticamente en el sistema numérico decimal, pero puede interpretar la cadena como octal o hexadecimal. Sin embargo, 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 digital al principio de la línea, el resultado será NaN.

Es necesario comprender los sistemas numéricos, 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 qué es una notación matemática para un número real.

Transformación con fines de clasificación.

JavaScript es un lenguaje de navegador, por lo que es más importante que otros lenguajes para caracteres fuera del conjunto básico del alfabeto latino y números. La clasificación es una operación popular. Pero no siempre tiene sentido enviar datos al servidor para ordenarlos; es más fácil y práctico hacer el trabajo localmente, en el navegador.

Para solucionar este problema, puedes convertir los caracteres de una cadena en sus códigos numéricos o asignar una secuencia ordenada de números a letras y números. El método charCodeAt() aplicado a una 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 97, puede obtener los números de todas las letras del alfabeto latino en orden ascendente en conjuntos de mayúsculas y minúsculas. Lo mismo ocurre con las letras del alfabeto ruso.

Nuestra propia versión de clasificación de números le permite crear los conjuntos de caracteres necesarios. Puede, por ejemplo, "reorganizar" los alfabetos cirílico y latino o mezclarlos para dejar solo letras que sean distintas en ortografía, o agregar tabulaciones y espacios a los conjuntos.

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

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 de cada carácter de una cadena, es difícil obtener el número único de esa cadena.

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

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

luego, multiplicando el número único de cada carácter en la cadena por el peso de la posición en la que se encuentra y sumando todos los números, puede obtener un número único y usarlo como una correspondencia uno a uno con el original. cadena.

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

Selectores de páginas de sitio "en crecimiento"

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

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

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

Para resolver este problema, no se puede utilizar el método de cadena a número de JavaScript. Los métodos habituales parseInt y parseFloat están diseñados para otros usos, pero se puede crear un algoritmo para convertir sin ambigüedades una cadena en un número, y no necesariamente en uno invertible. Basta con que el algoritmo de conversión no se repita en diferentes conjuntos de caracteres de una cadena.

Optimización y análisis del tráfico

Al crear una página, el desarrollador utiliza cantidades importantes de información. Permitir que el visitante ingrese información es una buena manera de bajar la clasificación del sitio debido a su mala funcionalidad y frustrar al visitante.

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

La transformación de información de cadena aquí puede ser arbitrariamente grande en la parte de cadena y muy pequeña en la parte numérica. En otras palabras, el desarrollador convierte una cadena de JavaScript en un número utilizando su propio algoritmo. El visitante manipula información comprensible y la cantidad mínima de datos (un número) se envía al servidor.

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), solicitada a la 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 para convertir una cadena de JavaScript en un número es muy popular 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 crean como subcadenas, de forma recursiva. Normalmente el parámetro es un número seguido de varias letras (por ejemplo, "px", "pt", "em", ...). El parámetro es una subcadena en la regla y la regla es una subcadena en el estilo de clase o identificador.

Recursión de JavaScript.Substring.Substring... encuentra el número deseado, lo convierte de una cadena a un número, lo modifica y lo vuelve a escribir en la ubicación deseada. La regla cambia automáticamente. Es simple y conveniente, sin participación del servidor.

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

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

La función también puede procesar “el número n multiplicado por 10 elevado a x”, que en programación suele escribirse con 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/1000000.

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 está escrito el número en la cadena de origen (por ejemplo, decimal, octal o hexadecimal, pero no sólo estos). También puede especificar el sistema numérico explícitamente pasándolo como la base del segundo parámetro. El parámetro base puede tomar cualquier número del 2 al 36 (en sistemas superiores a 10 se utilizan letras del alfabeto inglés, de la A a la Z).

La función no maneja números como 1.5e6 como parseFloat() .

Lea los ejemplos a continuación para no tropezar con los errores ocultos en el funcionamiento de 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!!! cero primero hará que la función analice la cadena como un número octal ) parseInt(" "88"",8) // NaN (no hay el dígito 8 en el sistema octal) parseInt(""a1"") // NaN (¡¡IMPORTANTE!!! La función predeterminada no trata el número como hexadecimal si no se 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 numérico hexadecimal correcto) , no es necesario especificar el segundo parámetro) parseInt( ""099"") // 0 (¡¡IMPORTANTE!!! El número se trata 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á analizando la entrada del usuario desde un campo de texto, use siempre parseInt() junto con un segundo parámetro de base para proteger su código de resultados inesperados.

| |

JavaScript divide los datos en tipos, lo que le ayuda a agrupar datos y determinar qué valores se pueden asignar y qué operaciones se pueden realizar.

Aunque JavaScript convierte muchos valores automáticamente debido a la conversión de tipos, es mejor convertir los tipos de datos manualmente para lograr los resultados esperados.

Este tutorial le enseñará cómo convertir tipos de datos primitivos de JavaScript, incluidos números, cadenas y valores booleanos.

Conversión implícita

El lenguaje de programación JavaScript es muy bueno para manejar valores inesperados. JavaScript no rechaza valores inesperados, sino que intenta convertirlos. Esta conversión implícita también se denomina coerción de tipo.

Ciertos métodos convierten valores automáticamente para usarlos. El método alert() toma una cadena como parámetro y convierte automáticamente otros tipos en cadenas. Entonces puedes pasar un valor numérico a este método:

Si ejecuta esta cadena, el navegador devolverá una ventana emergente con el valor 8.5, que ya estará convertida en una cadena.

Al utilizar cadenas de números junto con operadores matemáticos, descubrirá que JavaScript puede manejar valores convirtiendo implícitamente cadenas en números:

// Resta
"15" - "10";
5
// módulo
"15" % "10";
5

Pero no todos los operadores funcionan de forma predecible. Esto es especialmente cierto para el operador +: realiza la suma de números y la concatenación de cadenas.

// Cuando trabajamos con cadenas, + realiza concatenación
"2" + "3";
"23"

Debido a que el operador + tiene muchos usos, en este ejemplo trata los valores 2 y 3 como cadenas, aunque estén expresados ​​como cadenas numéricas. Por lo tanto, combina las cadenas “2” y “3” y obtiene 23, en lugar de sumar 2 y 3 y obtener 5.

Esta ambigüedad se produce en el código y, en ocasiones, provoca resultados inesperados, por lo que es mejor convertir explícitamente los tipos de datos siempre que sea posible. Esto ayudará con el mantenimiento del código y el manejo de errores.

Convertir valores a cadenas

Para convertir explícitamente un valor en una cadena, llame al método String() o n.toString().

Intente convertir el valor booleano verdadero en una cadena usando String().

Esto devolverá la cadena literal "verdadero".

También puedes intentar pasar un número a la función:

Devolverá una cadena literal:

Ahora intenta usar String() con una variable. Asigne un valor numérico a la variable odyssey y use el operador typeof para verificar el tipo.

let odisea = 2001;
console.log(tipo de odisea);
número

Actualmente, a la variable odyssey se le asigna el valor numérico 2001. El operador typeof confirma que el valor es un número.

Ahora asigne la variable odyssey a su equivalente dentro de la función String() y luego use typeof para asegurarse de que el valor de la variable se convierta correctamente de un número a una cadena.

odisea = String(odisea); // "2001"
console.log(tipo de odisea);
cadena

Como puede ver, la variable odyssey ahora contiene una cadena.

La función n.toString() funciona de forma similar. Reemplace n con una variable.

dejar golpes = 400;
golpes.toString();

La variable de golpes contendrá la cadena.

En lugar de una variable, puedes poner un valor entre paréntesis:

(1776).toString(); // devuelve "1776"
(falso).toString(); // devuelve "falso"
(100 + 200).toString(); // devuelve "300"

String() y n.toString() convierten explícitamente valores booleanos y numéricos en cadenas.

Convertir valores a números

El método Number() puede convertir un valor en un número. A menudo es necesario convertir cadenas que constan de números, pero a veces también es necesario convertir valores booleanos.

Por ejemplo, pase la siguiente cadena al método Number():

La cadena se convertirá en un número y ya no estará entre comillas.

También puedes asignar una cadena a una variable y luego convertirla.

let dálmatas = "101";
Número(dálmatas);
101

La cadena literal "101" se convirtió al número 101.

Las cadenas de espacios o cadenas vacías se convertirán al número 0.

Número(" "); // devuelve 0
Número(""); // devuelve 0

Tenga en cuenta que las cadenas que no consisten en números se convierten a NaN, lo que significa No es un número. Esto también se aplica a los números separados por espacios.

Número("doce"); // devuelve NaN
Número("20.000"); // devuelve NaN
Número("2 3"); // devuelve NaN
Número("11-11-11"); // devuelve NaN

En datos booleanos, falso será 0 y verdadero será 1.

Conversión de valores a valores booleanos

Para convertir números o cadenas a valores booleanos, se utiliza el método Boolean(). Por ejemplo, ayuda a determinar si el usuario ingresa datos en un campo de texto o no.

Cualquier valor que se interprete como vacío, como el número 0, la cadena vacía, indefinido, NaN o nulo, se convierte en falso.

Booleano(0); // devuelve falso
Booleano(""); // devuelve falso
Booleano (indefinido); // devuelve falso
Booleano(NaN); // devuelve falso
booleano (nulo); // devuelve falso

Otros valores, incluidos los literales de cadena que constan de espacios, se convertirán a verdadero.

Booleano(2000); // devuelve verdadero
Booleano(" "); // devuelve verdadero
Booleano("Maníacos"); // devuelve verdadero

Tenga en cuenta que el literal de cadena "0" se convierte en verdadero porque no es un valor vacío:

Booleano("0"); // devuelve verdadero

La conversión de números y cadenas a valores booleanos permite evaluar los datos en binario y puede usarse para controlar el flujo en los programas.

Conclusión

Ahora sabes cómo JavaScript convierte tipos de datos. A menudo, la conversión de tipos hace que los datos se conviertan implícitamente, lo que puede dar como resultado valores inesperados. Se recomienda convertir explícitamente los tipos de datos para garantizar que los programas funcionen correctamente.

JavaScript proporciona varios tipos de datos integrados. Además de estos, este artículo cubre tipos virtuales en jQuery, como selectores, pseudotipos extendidos como eventos y todo tipo de funciones.

Lo mejor es que pruebes la mayoría de los ejemplos siguientes. Esto se puede hacer fácilmente simplemente copiando estos ejemplos en la consola Firebug, una extensión del navegador Firefox.

Siempre que los ejemplos realicen operaciones en un contexto booleano (como comparaciones), es importante saber cómo se comporta cada tipo de datos en ese contexto:

Var x = "" if (x) console.log("x predeterminado es verdadero") else console.log("x predeterminado es falso")

En este caso, se imprimirá "x es igual a falso".

Para reducir la longitud de los ejemplos, se utiliza el operador de negación para mostrar el contexto booleano:

X // verdadero

Tipos de datos jQuery

1. Instrumentos de cuerda
   • Métodos integrados para cadenas.
   • propiedad de longitud
   • contexto booleano
2. Números
   • contexto booleano
   • Analizando números
   • Números a cadenas
   • NaN e infinito
   • Entero
   • Flotar
3. tipo booleano
4. Objetos
   • Notación de puntos
   • Notación de matriz
   • Iteración
   • valor predeterminado booleano
   • Prototipo
5. Opciones
6. matrices
   • Iteración
   • Valor booleano predeterminado
   • Formación Notación
7. Funciones
   • Argumentos
   • Contexto, Llamar y Aplicar
   • Área de visibilidad
   • Cierres
   • Patrón de proxy
8. Funciones de devolución de llamada
9. Selectores
10. Eventos
11. Elementos
12. tipo jQuery
13. Tipo de solicitud XMLHttp

Instrumentos de cuerda

"¡Esta es una cadena de JavaScript!" "¡Y esto también es una línea!"

Una cadena en JavaScript es un objeto inmutable que contiene cero, uno o más caracteres.

El tipo de cadenas es "cadena". Puedes averiguar el tipo de cadena de esta manera:

Tipo de "alguna cadena"; // "cadena"

Usar comillas en cadenas

Una cadena se puede definir utilizando comillas simples o dobles. Puede utilizar comillas simples dentro de una cadena entre comillas dobles y viceversa. Para utilizar comillas dobles dentro de cadenas entre comillas dobles, deben ir acompañadas de una barra invertida \ . Esto también se aplica a las comillas simples.

"Usted me hace triste." "¡Santo Moisés!" " hogar" "hogar"

Métodos integrados para cadenas.

JavaScript tiene varios métodos integrados para manipular cadenas, cuyo resultado puede ser una cadena o, por ejemplo, una matriz:

"hello".charAt(0) // "h" - obtener el carácter en la posición deseada en la cadena "hello".toUpperCase() // "HELLO" - convertir la cadena a mayúsculas "Hello".toLowerCase() // "hello" - convertir una cadena a minúsculas "hello".replace(/e|o/g, "x") // "hxllx" - reemplazar parte de una cadena con una subcadena usando el patrón de expresión regular "1, 2,3".split(", ") // ["1", "2", "3"] - dividir una cadena en una matriz por una subcadena específica

propiedad de longitud

Las cadenas tienen una propiedad de longitud que especifica la longitud de la cadena.

"Hola".length // 5 "".length // 0

contexto booleano

Una cadena vacía se evalúa como falsa:

!"" // ¡verdadero! "hola" // falso! "verdadero" // falso! nuevo booleano(falso) // falso

Números

12 3.543

Los números en JavaScript están en formato de doble precisión de 64 bits según el estándar IEEE 754. También son inmutables. Para trabajar con números están disponibles todos los operadores, al igual que en el lenguaje C (+, -, *, /, %, =, +=, -=, *=, /=, ++, --).

El tipo de números es "número". Puedes comprobar el tipo de números así:

Typeof 12 // "número" typeof 3.543 // "número"

contexto booleano

Si el número es cero, entonces es igual a falso:

0 // verdadero !1 // falso !-1 // falso

Debido a que los números se implementan en formato de doble precisión, el resultado del siguiente ejemplo no es incorrecto:

0.1 + 0.2 // 0.30000000000000004

Objeto matemático

JavaScript proporciona funciones para trabajar con números en un objeto Math:

Math.PI // 3.141592653589793 Math.cos(Math.PI) // -1

Convertir a números

Las funciones parseInt y parseFloat convierten cadenas en números. Ambas funciones realizan una conversión implícita si no se especifica el sistema numérico:

ParseInt("123") = 123 (conversión decimal implícita) parseInt("010") = 8 (conversión octal implícita) parseInt("0xCAFE") = 51966 (conversión hexadecimal implícita) parseInt("010", 10) = 10 ( conversión decimal explícita con base 10) parseInt("11", 2) = 3 (conversión binaria explícita) parseFloat("10.10") = 10.1

Convertir números a cadenas

Si agrega números a una cadena usando la operación "+", el resultado siempre será una cadena. Para realizar cálculos antes de agregar un número a una cadena, asegúrese de incluir los cálculos entre paréntesis:

"" + 1 + 2; // "12" "" + (1 + 2); // "3" "" + 0.0000001; // "1e-7" parseInt(0.0000001); // 1 (¡nota!)

También puedes usar la clase String de JavaScript, que convierte el valor pasado en una cadena:

Cadena(1) + Cadena(2); // "12" Cadena(1 + 2); // "3"

Tipos NaN e Infinity

La conversión de valores que no son números da como resultado NaN. La función isNaN determina si el valor que se le pasa es igual a NaN:

ParseInt("hola", 10) // NaN isNaN(parseInt("hola", 10)) // verdadero

Al dividir por cero se obtiene el resultado Infinito:

1/0 // Infinito

Tanto el valor NaN como el Infinity son de tipo "número":

Typeof NaN // "número" typeof Infinity // "número"

Tenga en cuenta que la comparación de los valores NaN se realiza de forma no estándar:

NaN == NaN // falso (!)

Infinito == Infinito // verdadero

tipo entero

El número entero es un tipo entero.

Tipo flotador

Float es un tipo de número de punto flotante.

tipo booleano

Un tipo booleano en JavaScript puede ser verdadero o falso:

Si (verdadero) consola.log("¡siempre!") si (falso) consola.log("¡nunca!")

Por ejemplo, un tipo booleano se ve así al configurar la configuración al conectar complementos de jQuery:

$("...").somePlugin(( hideOnStartup: verdadero, onlyOnce: falso ));

Objetos

Todo en JavaScript es un objeto. La forma más sencilla de crear un objeto es:

Var x = (); var y = ( nombre: "Pete", edad: 15 );

El tipo de objetos es "objeto":

Tipo de() // "objeto"

Propiedades del objeto

Puedes cambiar y obtener propiedades de un objeto usando la notación de puntos:

Y.nombre // "Pete" y.edad // 15 x.nombre = y.nombre + " Pan" // "Pete Pan" x.edad = y.edad + 1 // 16

También puedes usar el objeto como una matriz:

Operaciones var = (aumentar: "++", disminuir: "--" ) operación var = "aumentar"; operaciones // "++"; operaciones["multiplicar"] = "*"; // "*"

Iteraciones sobre objetos

Iterar sobre objetos es muy fácil usando el operador de bucle for-in:

Var obj = (nombre: "Pete", edad: 15); for(clave en obj) (alerta("la clave es "++", el valor es "+obj);)

jQuery proporciona una función

para iterar sobre propiedades de objetos o elementos de matriz:

JQuery.each(obj, function(clave, valor) ( ​​console.log("clave", clave, "valor", valor); ));

contexto booleano

Un objeto, tenga propiedades o no, siempre es verdadero:

!() // FALSO

Prototipos

Todos los objetos tienen una propiedad de prototipo. Siempre que el intérprete busca una propiedad en un objeto, también verifica su prototipo. En jQuery, este mecanismo se usa ampliamente para agregar métodos a instancias de objetos jQuery.

Formulario var = $("#miformulario"); formulario.clearForm; // formulario indefinido.fn.clearForm = function() ( return this.find(":input").each(function() ( this.value = ""; )).end(); ); form.clearForm() // se puede aplicar a todas las instancias de objetos jQuery desde que se agregó un nuevo método al prototipo