¿Cómo puedo comprobar si una variable es actualmente de tipo entero? He buscado algún tipo de recurso para esto y creo que el operador === es importante, pero no estoy seguro de cómo verificar si una variable es un entero (o una matriz para el caso)

Una variable nunca será un tipo entero en JavaScript, no distingue entre diferentes tipos de Número.

Puede probar si la variable contiene un número y si ese número es un número entero.

(typeof foo === "number") && Math.floor(foo) === foo

Si la variable puede ser una cadena que contiene un número entero y desea ver si ese es el caso:

foo == parseInt(foo, 10)

En estos días, ECMAScript 6 (ECMA-262) está "en la casa". Use Number.isInteger(x)para hacer la pregunta que desea hacer con respecto al tipo de x:

js> var x = 3
js> Number.isInteger(x)
true
js> var y = 3.1
js> Number.isInteger(y)
false

Un número es un entero si su módulo% 1 es 0-

function isInt(n){
    return (typeof n== 'number' && n%1== 0);
}

Esto es solo tan bueno como javascript obtiene, digamos + - diez al 15.

isInt(Math.pow(2,50)+.1)regresa true, como lo hace Math.pow(2,50)+.1 == Math.pow(2,50)

Sé que está interesado en los números enteros, así que no responderé eso, pero si alguna vez quisiera verificar los números de punto flotante, puede hacerlo.

function isFloat( x )
{
    return ( typeof x === "number" && Math.abs( x % 1 ) > 0);
}

Nota: Esto PUEDE tratar números que terminan en .0(o cualquier número lógicamente equivalente de0 ) como un INTEGER. En realidad, necesita que ocurra un error de precisión de punto flotante para detectar los valores de punto flotante en ese caso.

Ex.

alert(isFloat(5.2));   //returns true
alert(isFloat(5));     //returns false
alert(isFloat(5.0));   //return could be either true or false

Unas cuantas bibliotecas de utilidades como YourJS ofrecen funciones para determinar si algo es una matriz o si algo es un número entero o también muchos otros tipos. YourJS define isInt comprobando si el valor es un número y luego si es divisible por 1:

function isInt(x) {
  return typeOf(x, 'Number') && x % 1 == 0;
}

El fragmento anterior se tomó de este fragmento de YourJS y, por lo tanto, solo funciona porque typeOfestá definido por la biblioteca. Puede descargar una versión minimalista de YourJS que principalmente solo tiene funciones de verificación de tipo como typeOf(), isInt()y isArray(): http://yourjs.com/snippets/build/34,2

También puede echar un vistazo a Runtyper , una herramienta que realiza la verificación de tipo de operandos en ===(y otras operaciones).
Por ejemplo, si tiene una comparación estricta x === yy x = 123, y = "123", automáticamente verificará typeof x, typeof yy mostrará una advertencia en la consola:

Comparación estricta de diferentes tipos: 123 (número) === "123" (cadena)

Prueba este código:

 alert(typeof(1) == "number");

Un enfoque limpio

Puede considerar usar una biblioteca muy pequeña y libre de dependencias como Not . Resuelve todos los problemas:

// at the basic level it supports primitives
let number = 10
let array = []
not('number', 10) // returns false
not('number', []) // throws error

// so you need to define your own:
let not = Object.create(Not)

not.defineType({
    primitive: 'number',
    type: 'integer',
    pass: function(candidate) {
        // pre-ECMA6
        return candidate.toFixed(0) === candidate.toString()
        // ECMA6
        return Number.isInteger(candidate)
    }
})
not.not('integer', 4.4) // gives error message
not.is('integer', 4.4) // returns false
not.is('integer', 8) // returns true

Si lo convierte en un hábito, su código será mucho más fuerte. TypeScript resuelve parte del problema pero no funciona en tiempo de ejecución, lo cual también es importante.

function test (string, boolean) {
    // any of these below will throw errors to protect you
    not('string', string)
    not('boolean', boolean)

    // continue with your code.
}