Aprendizaje basado en JavaScript - Tipo Resumen

numérico

JavaScript sigue la especificación IEEE754
problemas de cálculos de punto flotante

0.1 + 0.2 === 0.3 // false
0.1 + 0.2=== 0.30000000000000004 // true

La solución a este problema, la precisión de la máquina, ES6, este valor es Number.EPSILON, 2 ^ -52
polyfill

if (!Number.EPSILON) {
  Number.EPSILON = Math.pow(2, -52);
}

La determinación de si los dos números son iguales

if (!Number.EPSILON) {
  Number.EPSILON = Math.pow(2, -52);
}

function numberIsEqual(n1, n2) {
  return Math.abs(n1 - n2) < Number.EPSILON;
}

numberIsEqual(0.1 + 0.2, 0.3); // true

---

El número máximo de Number.MAX_VALUE 1.7976931348623157e + 308
número mínimo Number.MIN_VALUE 5e-324

Seguridad entero máximo Number.MAX_SAFE_INTEGER 9007199254740991
de seguridad mínimo número entero Number.MIN_SAFE_INTEGER -9007199254740991

---

Entero detección
Number.isInteger

console.log(Number.isInteger(3)); // true
console.log(Number.isInteger(-3)); // true
console.log(Number.isInteger(3.0)); // true
console.log(Number.isInteger(3.1)); // false

polyfill

if (!Number.isInteger) {
  Number.isInteger = function(num) {
    return typeof num === 'number' && num % 1 == 0;
  };
}

---

Seguridad entero
Number.isSafeInteger
polyfill

if (!Number.isSafeInteger) {
  Number.isSafeInteger = function(num) {
    return Number.isInteger(num) && Math.abs(num) <= Number.MAX_SAFE_INTEGER;
  };
}

---

NaN
no es un número de figuras, NaN! == NaN, es el único que no es igual a su valor
isNaN no NaN ni ningún valor numérico devuelto es cierto

var a = 2 / 'foo';
console.log(typeof a, a); // number NaN
console.log(a == NaN); // false
console.log(a === NaN); // false
console.log(isNaN(a)); // true
console.log(isNaN('foo')); // true

ES6 añadió Number.isNaN

console.log(Number.isNaN(a)); // true
console.log(Number.isNaN('foo')); // false

polyfill

if (!Number.isNaN()) {
  Number.isNaN = function(n) {
    return typeof n === 'number' && window.isNaN(n);
  };
}

if (!Number.isNaN()) {
  Number.isNaN = function(n) {
    return n !== n;
  };
}

---

El infinito
más infinito Number.POSITIVE_INFINITY
infinito negativo Number.NEGATIVE_INFINITY

var a = 1 / 0 // Infinity
var b = -1 / 0 // -Infinity
var c = Infinity / Infinity // NaN

---

ES6 Object.is determina valores son iguales

var a = 2 / 'foo'
-0 === 0 // true
a === NaN //false
Object(a,NaN) // true
Object(-0,0) // false

polyfill

if (!Object.is) {
  Object.is = function(v1, v2) {
    // 判断是否是 -0
    if (v1 === 0 && v2 === 0) {
      return 1 / v1 === 1 / v2;
    }
    // 判断是否是NaN
    if (v1 !== v1) {
      return v2 !== v2;
    }
    // 其他情况
    return v1 === v2;
  };
}

Valor y referencia

valor simple (tipo de valor base) es un valor asignado a un duplicado de manera
crítica los valores objetivo (array, función) asignados por referencia al copiado

  var a = 2,
    b = a;
  b++;
  console.log(a); // 2
  console.log(b); // 3

  var c = [1, 2, 3],
    d = c;
  d.push(4);
  console.log(c); // [1, 2, 3, 4]
  console.log(d); // [1, 2, 3, 4]

---

A medida que el punto de referencia es el valor en sí, no variable, de modo una referencia a otro punto de referencia no se puede cambiar

var a = [1, 2, 3];
var b = a;

b = [4, 5, 6];
console.log(a);
console.log(b);

// 让人疑惑的函数
function foo(x) {
  x.push(4);
  console.log(x); // 1,2,3,4

  x = [4, 5, 6];
  x.push(7);
  console.log(x); // 4,5,6,7
}

foo(a);
console.log(a); // 1,2,3,4

En la función, cuando una transmisión es en realidad una referencia a una copia del asignado a x, el valor puede ser cambiado por un empuje, pero x = [4,5,6] y lo anterior b = [4 5, 6] es lo mismo, no tiene un impacto.