En la programación orientada a objetos, muchos idiomas admiten la sobrecarga de funciones y pueden hacer diferentes operaciones de acuerdo con diferentes números y tipos de parámetros aprobados por la función. Sin embargo, JS no lo admite, por lo que necesitamos hacer algunas acciones extra pequeñas.
En el contexto de ejecución de la función JS, hay una variable interesante llamada argumentos. Almacena todos los parámetros pasados durante la ejecución de la función en forma de una matriz, incluso si la definición de función no define tantos parámetros formales. Otra característica especial es que en comparación con el tipo de matriz, la variable de argumentos tiene y solo tiene un atributo de longitud. Los métodos de matriz, como Push, Pop, etc., no lo tienen. Es solo un "pseudo-array": tiene un atributo de longitud, y la matriz almacenada puede ser accedida por el personaje de acceso a la matriz [], y solo es de lectura y no se puede escribir.
1. Sobrecarga de diferentes números
Debería estar muy claro aquí que puede usar el atributo de longitud de la función de argumentos para juzgar.
La copia del código es la siguiente:
<script type = "text/javaScript">
Function Talk (MSG, Handler) {
var len = argumentos.length;
// ejecutar al pasar un parámetro
if (len == 1) {
alerta ("La función dice:"+msg);
}
// ejecutar cuando se pasan dos parámetros
else if (len == 2) {
manejador (msg);
}
}
hablar ("demo");
hablar ("demo", función (w) {alert ("Handler dice:"+W);});
</script>
2. Sobrecarga de diferentes tipos de parámetros
Para un lenguaje tipado dinámicamente como JS, la naturaleza arbitraria de las declaraciones variables minimiza la importancia de los tipos variables estrictos en las mentes de los desarrolladores (PS: también basado en el sistema ECMA, ya que introduce los tipos obligatorios de declaraciones variables). Muchos errores inesperados son realmente causados por la conversión automática de este tipo de variable. De hecho, JS proporciona un método muy preciso para detectar estrictamente los tipos de variables. Los más comunes son el método typeof y el atributo de constructor.
1. TypeOf Variable Devuelve Tipo de variable
La copia del código es la siguiente:
temp = "decir"; //cadena
temp = 1; //número
temp = indefinido; //indefinido
temp = nulo; //objeto
temp = {}; //objeto
temp = []; //objeto
temp = verdadero; // booleano
temp = function () {} // función
alerta (TypeOf Temp);
A través de la prueba anterior, puede ver que para nulo, objeto y matriz, todos los tipos de objetos de retorno, y usar el siguiente método puede resolver este problema.
2. El atributo de constructor detecta el tipo de variable
Cada objeto en JS tiene un atributo de constructor, que se utiliza para hacer referencia a la función que construye este objeto. Al juzgar esta referencia, se pueden detectar tipos de variables.
La copia del código es la siguiente:
temp = "decir";
temp.constructor == cadena; //verdadero
temp = {};
temp.constructor == Object; // True
temp = [];
temp.constructor == Array; // True
A través de la prueba anterior, es fácil distinguir entre variables de matriz y tipo de objeto. Probemos el objeto personalizado para ver qué sucede.
La copia del código es la siguiente:
// Objeto personalizado
función ball () {}
// instanciar un objeto
Var Basketball = new Ball ();
baloncesto.constructor == Ball; //verdadero
Esto puede indicar que el atributo Constructor también es aplicable a objetos personalizados.
Después de comprender la aplicación de los dos métodos anteriores, volvamos a la simulación de sobrecarga de la función JS. El siguiente ejemplo es sobrecargar de acuerdo con el tipo de parámetro.
La copia del código es la siguiente:
Function Talk (msg) {
var t = typeOf msg;
if (t == "string") {
alerta ("es una cadena");
}
else if (t == "número") {
alerta ("es un número");
}
}
hablar (10); // es una cadena
hablar ("demo"); // es un número
Se adjunta una función muy inteligente que detecta estrictamente los tipos y números de parámetros:
La copia del código es la siguiente:
// Verifique estrictamente el tipo de lista de variables basada en la lista de parámetros
función estricta (tipos, args) {
// Asegúrese de que el numero y el tipo de núcleo de los parámetros coincidan
if (tipos.length! = args.length) {
// Si la longitud no coincide, se lanzará una excepción
arrojar "número no válido de argumentos. esperado" + tipos.length + ", recibido" + args.length + "en su lugar.";
}
// viajar a través de cada parámetro y verificar el tipo base
para (var i = 0; i <args.length; i ++) {
// Si un cierto tipo de JavaScript no coincide, se lanzará una excepción
if (args [i] .constructor! = tipos [i]) {
Lanzar "Tipo de argumento no válido. Esperado" + Tipos [i] .name + ", recibido" + args [i] .constructor.name + "en su lugar.";
}
}
}
// Uso del método anterior
function dOfunction (id, nombre) {
// detectar el número y el tipo de parámetros
estricto ([número, cadena], argumentos);
..
}