Funciones de conversión
// fundido común
Número ( '1'); // 1
// Regla ToNumber: true -> 1; indefinido -> NaN; null -> 0; {} -> NaN; valor entero de la cadena sigue las reglas de conversión, el proceso no pudo volver NaN
// Número Se observará que '', '', una combinación de conversión '\ n' como una cadena vacía o otra cadena está vacía 0
String (1); // "1"
// toString reglas: null -> "nulo"; indefinido -> "indefinido"; verdadero -> "true"; 1 -> "1"; objetos ordinarios sí mismos a menos que se defina lo contrario utilizar toString interna () (Object.prototype .ToString devuelve el método ()) la propiedad interna valor [] Clase []
[1,2,3] .toString (); // "1,2,3"
Hay a = * 1,000 * 1.07 1,000 * 1,000 * 1,000 * 1,000 * 1,000 * 1,000;
a.toString (); //"1.07e+21"
Varios revolución digital binario
Hay t = 60;
t.toString (8); // 74
t.toString (16); // 3c
Boolean (1); // true
// reglas toBoolean: proporciona valores falsos incluyen: undefined, null, falso, 0, -0, NaN "". Todo lo demás es cierto (y hay excepciones, detrás del falso valor del objeto es un caso especial).
// encapsula el valor falso del objeto, en el análisis final del objeto, el objeto debe girar a bool es cierto
var a = new Boolean (false);
var b = new Number (0);
fue c = new String ( '');
var d = Boolean (a && b && c); // true
// Pero hacer y falsos valores y falsa comparación Shique igual
a == false; // true
una === false; // false
// objetos falsos, es falsa cuando se convierte a bool
Boolean (document.all); // false
conversión implícita
Hay unos = '20';
var b = 10;
Hay c = [1,2];
var d = [3,4];
a + b; // "2010"
c + d; // "1,23,4"
+ (Operador de adición) por sólo numérico y cadena (o puede ser convertido en un valor digital y la cadena), si hay una secuencia, se obtiene el resultado cadena (Realiza concatenación de cadenas). De lo contrario, debe ser digital o NaN (realizando Además digital)
c objetos no se pueden obtener mediante una llamada telefónica a sus tipos básicos valueOf (), se vuelve invoca toString () para obtener el "1,2"
String (c) de forma explícita a una cadena es en realidad un método toString llamada directa ()
Ejemplo:
Hay = {
valueOf: function () {return 42;},
toString: function () {return 4;}
}
a + ""; // "42"
String (a); // '4'
[] + {}; // "[Objeto objeto]"
Explicación: {+} aparecerá en el operador, se utiliza como un valor (procesamiento de objeto nulo), [], y {} son procesadas toString llamada final
{} + []; // 0
Explicación: {} bloque de código se considera que es independiente (no se realiza ninguna operación), el bloque final no requiere un punto y coma, no hay errores de sintaxis. Detrás de "+ []" se considera el ser explícitamente un yesos.
({} + []); // "[object Object]"
[1, [2,3], {nombre: '1'}] toString ();.
// después de "1,2,3, [object Object]" array toString toString se hace para cada elemento de la matriz es bueno empalme
- operador digital, y * y / tan sólo para la televisión digital, con el tiempo convertirse en el nuevo cálculo necesidad digital.
"3.14" - 0; // 3,14
[2] - [1]; // 1
// implícitamente convertido a boolean
si / de / mientras / hacer mientras / :? / (&& y || operando de la izquierda)
// símbolo fundido
era s1 = Símbolo ();
Boolean (s1); // true
s1 && 1; // 1
Número (s1); // error de sintaxis
s1 + 1; // error de sintaxis
String (S1); // "El símbolo ()"
s1 + ''; // error de sintaxis
Representa un valor igual == === representa congruentes (valor Tipo)
Los tipos básicos == === y el resultado será diferente
Valores, boolean, string == se puede hacer, mientras que no todos los tipos se convierten en valores digitales DO valor tipo especial no es igual a cualquier valor NaN (incluidos ellos mismos) NaN == NaN; // false
== null y undefined puede hacer
valor de tipo de símbolo no es igual a otros valores de cualquier tipo, y único (Símbolo () == Símbolo (); // false)
Los tipos de objeto (tipo de referencia) == === y comparan la misma manera que
Objetos y cadenas, números (no hay nada que decir booleano, debido a que el booleano será convertida a digital) == comparación, la primera operación llamará objetos abstractos toPrimitive (ver si usted puede conseguir un aspecto básico en el tipo valueOf, si no, utilizar el método toString)
42 == [42]; // true
Hay = {
valueOf: function () {return 42;},
toString: function () {return 4;}
}
a == 42; // true;
nueva cadena ( 'abc') == 'abc'; // cierto, objeto llamadas de acceso a toPrimitive tipos básicos, nueva cadena ( 'abc') valueOf () ;. // 'abc'
nueva cadena ( 'abc') === 'abc'; // false
// vistazo a la situación de las personas de vértigo
"0" == false;
false == 0;
"0" == "";
false == "";
false == [];
'' == 0;
'' == [];
'' == {};
0 == [];
"" == [nulo];
0 == '\ n';
// extraño fenómeno
Hay unos = {B: 42};
var b = {b: 43};
un <b; // false
a == b; // false
a> b; // false
a <= b; // true; determina primero una simple comparación de a> b; el resultado se invierte entonces
a> = b; // true primero determina una simple comparación de un <b; a continuación, invierte el resultado
Comparación de tamaño
La comparación de la secuencia digital, y luego se convierte primero en un comparador digital, si no es convertida en digital (NaN3), se realiza una comparación de cadenas
'1000'> 300 // verdadera
1000> '300' // verdadera
'1000'> '300' // falsa
'1000d'> 300 // falsa
1000> '30d' // falsa
Detección y conversión de digitales
isNaN está "Compruebe el parámetro o no un número es NaN" devuelve true, el resultado se basa en el resultado de la conversión de Número, Número de conversión es la conversión "valor total". parseFloat conversión es la conversión "sentencia válida"
'F' / 1; // NaN
isNaN ( 'f'); // true
isNaN ( 'f' / 1); // true
isNaN ( '1'); // false Número ( '1'); // 1 parseFloat ( '1'); // 1
isNaN ( "0xf"); // false Número ( "0xf"); // 15 parseFloat ( "0xf"); // 0
isNaN ( '1f'); // true Número ( '1f'); // NaN parseFloat ( '1f'); // 1
isNaN ( 'd1'); // true Número ( 'd1'); // NaN parseFloat ( 'd1'); // NaN
isNaN ( ''); // false Número ( ''); // 0 parseFloat ( ''); // NaN
isNaN (true); // false Número (true); // 1 parseFloat (true); // NaN
isNaN (null); // false Número (null); // 0 parseFloat (null); // NaN
isNaN (indefinido); // true; Número (indefinido); // NaN parseFloat (indefinido); // NaN
isNaN ({}); // true; Número ({}); // NaN parseFloat ({}); // NaN
isNaN (Símbolo ()); // error de sintaxis Número (Símbolo ()); // error de sintaxis parseFloat (Símbolo ()); // error de sintaxis
Sólo 10 análisis sintácticos decimal // parseFloat, banda parseInt pueden ser controlados por el segundo argumento.
proceso // análisis sintáctico es "el primer parámetro se convierte en una cadena, a continuación, analizar una cadena de"
parseInt (1/0, 18); // NaN
parseInt (1/0, 19); // 18 proceso es: parseInt ((1/0) .ToString (), 19) -> parseInt ( "infinito", 19) -> 18; // "que" se puede utilizar 19 el número de decimales, pero "n" no funciona
parseInt (nueva cadena ('42 ')) -> parseInt (nueva cadena ('42') toString ().) -> parseInt ('42' ) -> 42
parseInt (0,00008) -> parseInt ((0,00008) .toString ()) -> parseInt ( '0.00008') -> 0
parseInt (parseInt, 16) -> parseInt (parseInt.toString (), 16) -> parseInt ( "Función parseInt () {[código nativo]}", 16) -> 15
parseInt (falso, 16) -> parseInt (false.toString (), 16) -> parseInt ( "falsa", 16) -> 250
parseInt ( '0x10') -> ... -> 16; // no establece el tiempo predeterminado es de 10 notación hexadecimal, y sólo cuando hay "0x" se identifica como hexagonal 16, no reconoce octal "0"; esta cadena al número digital y el mismo
parseInt ( '010') -> ... -> 10;
parseInt (010) -> parseInt ((010) .toString ()) -> parseInt ((8) .toString ()) -> parseInt ( '8') -> 8
// Resumen: analizar la cadena, decimales, y sólo reconoce el valor por defecto "0x" hexadecimal
Número ( '0x10'); // 16
Número (0x10); // 16
Número ( '010'); // 10
Número (010); // 8
// valor js
010; // 8
0x10; // 16
10; // 10
Number.isNaN sólo detecta si un NaN
Number.isNaN ( 'f'); // false
Number.isNaN ( 'f' / 1); // true;
if (! Number.isNaN) {
Number.isNaN = function (n) {
volver n = n!;
}
}
otro
Unario + fundido en un convertidor digital
+ New Date (); // no 1545891424614 recomendada, el uso Date.now ()
+ "02"; // 2
+ "- 2"; // - 2
var a = {b: 42, c: "42", d: [1, 2, 3]}
JSON.stringify (a, [ 'b']); // "{" b ": 42}"
JSON.stringify (a, función (k, v) {if (k == 'c') de retorno v;!}); // "{" b ": 42," d ": [1,2,3] }"
JSON.stringify (a, null, 4);
// sangría cuatro caracteres
"{
"B": 42,
"C": "42",
"D": [
1,
2,
3
]
}"