----------------------Preguntas comunes de las entrevistas: deduplicación de matrices, resumir algunas, bajar y tocar------ --------------
Lo mejor es utilizar IIEF.
1) Bucle de doble capa más método de empalme
2) índice de deduplicación
3) incluye deduplicación
4) Utilice el objeto vacío para reemplazar el método de cobertura.
5) Usando recursividad
。。。
-------------------------------------------------- Comienza el contenido de hoy ----------------------------------------
Uno: prototipo y cadena de prototipos
prototipo prototipo:
1) Cada función tiene muchos atributos y métodos, y hay un atributo prototipo y su valor correspondiente es un objeto, al que llamamos objeto prototipo.
2) Se colocan muchas propiedades y métodos en el objeto prototipo.
3) Debe haber un constructor en cada objeto prototipo. El constructor también es un nombre de atributo y su valor es la función (clase) actual.
4) Cada objeto tiene un atributo __proto__ y el valor correspondiente es el objeto prototipo de la clase que creó el objeto.
5) También hay un __proto__ en este objeto prototipo, que corresponde al objeto prototipo (clase base) correspondiente a Objeto. Porque el objeto es la clase de nivel superior, también llamada clase base.
6) Entonces Object.prototype.__proto__ apunta a sí mismo. Como no tiene sentido apuntar a sí mismo, su valor predeterminado es nulo.
cadena prototipo
Si estás buscando un atributo, primero mira dentro de ti (privado).
Si lo hay, úsalo sin mirar atrás.
De lo contrario, siga __proto__, busque las propiedades en el objeto prototipo de clase y siga buscando hasta encontrar Object.prototype.
---------------------------------- Aquí hay dos preguntas del cuestionario ----------- ----Ver si está envuelto por la cadena prototipo.
function Func(){
this.name = "张"
}
let obj1 = new Func();
let obj2 = nueva Func();
Func.prototype.say = function(){
console.log("decir...")
}
Las preguntas de prueba console.log(obj1.say === obj2.say) , obj1 y obj2 apuntan al mismo objeto prototipo, y los métodos internos son consistentes console.log(Func.prototype.say === obj1.say) , obj1 No hay nada que decir, vaya a su objeto prototipo para encontrarlo, su objeto prototipo apunta al objeto prototipo de la clase que creó este objeto console.log (obj1.__proto__. say === Func.prototype.say) , el objeto prototipo de obj1 apunta al objeto prototipo de la clase que creó este objeto console.log(obj1.__proto__ === Func.prototype) , el objeto prototipo de obj1 apunta al objeto prototipo de la clase que creó este objeto console.log(obj1.name === obj2.name) , ambos objetos no tienen parámetros, ambos no están definidos, devuelven verdadero console.log(obj1 instanciade Func) , func también es un objeto console.log(obj1 instanciade Objeto ) ,, son del mismo tipo
prueba 2
var arr1 = nueva matriz("a","b","c")
var arr2 = nueva matriz("d","e","f")
console.log(Array.prototype === arr1.__proto__) , Array pertenece a objetos integrados, clases integradas, constructores, el objeto prototipo de arr1 corresponde al objeto prototipo de la clase que lo creó console.log( Array.prototype.push == = arr1.push) , no hay ningún push en arr1, irá a su objeto prototipo para encontrarlo, por lo que corresponde al push en su objeto prototipo console.log(arr1 === arr2 ) , arr1 y arr2 son dos piezas del montón, no iguales, false console.log(arr1 instanciade Array) . . console.log(arr1 instancia del objeto) . . console.dir(arr1.__proto__)//Objeto prototipo console.dir(arr1.__proto__.__proto__)//El objeto prototipo apunta al objeto prototipo al que apunta el objeto, clase base console.dir(arr1.__proto__.__proto__.__proto__) //nulo
2. Es difícil lidiar con esto
Respecto a esta pregunta, varios lugares donde esto aparece
1) En el oyente, esto representa la fuente del evento.
fuente del evento btn, en el prefijo, haga clic en tipo de evento
2) En modo no estricto. Esto aparece en funciones ordinarias, lo que significa ventana, y en modo estricto, significa indefinido.
Modo estricto: use estricto
3) esto aparece en el método de un objeto, indicando el objeto actual
4) esto aparece en el constructor, indicando que apunta a un nuevo objeto
5) En variables globales, esto significa ventana
La esencia de esto: este punto en el método es incierto, quien llame al método así, esto apunta a quién
Una serie de preguntas de práctica:
(1)
función Func(){
this.a = 1;
this.b = 2;
this.say = function(){
console.log(this.a)
}
}
Func.prototype.say = function(){
console.log(this .b)
}
Func.prototype.jump = function(){
// quien llamó al método de salto, este en el método de salto es quien
console.log(this.a+this.b)
}
let wc = new Func();
wc.saltar(); // 3
(2)
function Func(){
this.a = 1;
this.b = 2;
this.say = function(){
console.log(this.a)
}
}
Func.prototype.say = function(){
// quién llamó a say este método, entonces este es quién
// wc.__proto__
console.log(this.b)
}
Func.prototype.jump = function(){
console.log(this.a+this.b)
}
let wc = new Func ( );
// Señale claramente que el método en el objeto prototipo se llama
// wc.__proto__ Llama al método say, entonces esto en este método es wc.__proto__
wc.__proto__.say(); // undefinido
(3)
función Func(){
this.a = 1;
esto.b = 2;
this.say = function(){
console.log(this.a)
}
}
Func.prototype.say = function(){
console.log(this.b)
}
Func.prototype.jump = function(){
// 此时this表示wc.__proto__
console.log(this.a) // indefinido
console.log(this.b) // indefinido
console.log(this.a+this.b) // NaN
}
let wc = new Func( );
wc.__proto__.jump(); //NaN
3. Algunas preguntas sobre funciones anónimas
1) var f =function(){}, que consiste en asignar una función anónima a f.
Para la expresión de función anónima anterior, puede especificar el nombre de función g para esta función anónima. .
var f = función g(){console.log("jaja...")}
F()
g()// se imprimirá, g no está definido
// Como dijimos antes, no se puede llamar mediante el nombre de la función de la expresión de la función, por lo que solo se puede llamar mediante f (), no g ().
2) Entonces, ¿cómo utilizar nombres de funciones anónimas? Luego úselo en su propio cuerpo funcional.
Por ejemplo:
var f = function g(){ console.log(g) // g es el nombre de la función,
puedes usar g()
en el cuerpo de la función ; // puedes llamar a esta función a través de g(), pero habrá una bucle infinito si no hay salida
g = 1; // Asignar tipos de datos básicos a g no tiene ningún efecto
g = []; // Asignar tipos de datos de referencia a g tampoco tiene efecto
g = {};
g = function(){
console.log("xixi..." )
}
console.log(g)
}
f()
Para resumir las consideraciones sobre nombres de funciones anónimas:
1) Se pueden utilizar nombres de funciones anónimos en el cuerpo de la función.
2) Se puede llamar directamente, pero habrá un bucle infinito si no hay salida.
3) No se puede reasignar, ni el tipo de datos básico ni el tipo de datos de referencia
4) En resumen: para una expresión de función, puede tener un nombre de función, se puede llamar internamente y no se puede llamar externamente a través del nombre de la función.
----------------------------------------- Practiquemos con dos ejemplos---- -----------------------
(1)
var a = función abc(núm) {
abc = núm;
console.log(num)
console.log(abc)
console.log(tipo de abc)
}
a(1)
(2)
var a = función abc(núm) { abc = núm; devolver 1; } a(1) consola.log(abc())
4. Para practicar esto, busque las siguientes preguntas de la entrevista para resumir esto (un poco más). .