tipo de datos

a. ¿Qué es un tipo de referencia/tipo de valor?

1. La clave de tipo de valor y el valor se almacenan en la pila (cantidad pequeña)
2. El tipo de aplicación del tipo de referencia se expande y almacena datos en la pila (cantidad grande)
3. La asignación del tipo de referencia a una variable es la referencia de la variable La dirección apunta a la dirección en el montón de tipo de referencia

B. ¿Cuáles son los tipos de valor?

Carácter de cadena, número de número, booleano booleano, indefinido indefinido, nulo vacío, símbolo símbolo

c.¿Cuáles son los tipos de referencia?

Objeto objeto, número de matriz, función función, diagrama de mapa, colección de conjuntos

D. ¿Cómo juzgar el tipo de datos?

tipo de tipo

typeof “abc” ----------- string
typeof 123 ----------- number
typeof true ----------- boolean
typeof undefined ----------- undefined
typeof null ----------- object（null空指针）
typeof {
    
    } ----------- object
typeof [] ----------- object
typeof function() ----------- function
//引用类型出函数外 返回的是object
//适合判断值类型与引用类型，不能判断具体引用类型

instancia de instancia

[] instanceof Array ----------- true
[] instanceof Object ----------- true
{
    
    } instanceof Array ----------- false
{
    
    } instanceof Object ----------- true
//判断是否是其原型链上的实例，只要构造函数在原型链上都返回true
//[]由Array创建的，Array是Object的子类，instanceof Array和Object都返回true

constructor constructor

//判断实例对象构造函数 
[] constantor === Array  true

Si Array.isArray() es una matriz
Object.prototype.toString.call(obj) prototipo
juicio más exacto

Object,prototype.toString.call(obj).slice(8,-1)                                        
//返回最精准的数据类型

copia superficial y copia profunda

¿Puede citar algunos métodos de copia superficial?

expandir {... obj}
para recorrido (copia superficial (si el valor del atributo es un tipo de referencia, los atributos de ambas variables apuntan a la misma dirección de memoria))
Object.assign() (Combina los dos objetos del parámetro y el mismo atributo sobrescribirá el frente)

// js拷贝对象
    // 浅拷贝，只能拷贝值类型，引用类型数据还是指向地址
    var obj1 = {
    
    
        name:"mumu",
        age:18,
        friend:["小红","小蓝",{
    
    
            name:"小绿",
            job:"teacher"
        }]
    }
    // ES6扩展
    var obj2 = {
    
    ...obj1}
    // 循环
    var obj3 = {
    
    }
    for(var k in obj1){
    
    
        obj3[k] = obj1[k];
    }
    // Object.assign把参数的两个对象进行合并，属性相同后面覆盖前面
    var obj4 = Object.assign(obj1,{
    
    });

b. ¿Qué sabes sobre la copia profunda?

Copia profunda, el objeto de destino y el objeto de origen se separan entre sí

JSON.parse (JSON.stringify (datos)):
el tipo de datos json solo admite único, cadena, número, nulo, indefinido, matriz, el objeto ignorará funciones y otros tipos de datos
Copia profunda recursiva juzgando el tipo (recursión significa que la función se llama a sí misma y debe haber una condición final)

// js拷贝对象
    // 深拷贝，目标对象与元对象相互之间切断联系
    var obj1 = {
    
    
        name:"mumu",
        age:18,
        friend:["小红","小蓝",{
    
    
            name:"小绿",
            job:"teacher",
            say(){
    
    
                alert("你好，我是"+this.name)
            }
        }]
    }
    // JSON转字符串，字符串转对象
    var obj2 = JSON.parse(JSON.stringify(obj1))
    // json字符串的值指挥保留数组、对象、字符串、数字、null、undefined
    // 对象中的函数会被过滤掉（一般数据也是不带函数的）

//通过递归自己调用自己
var obj1 = {
    
    
        name:"mumu",
        age:18,
        friend:["小红","小蓝",{
    
    
            name:"小绿",
            job:"teacher",
            say(){
    
    
                alert("你好，我是"+this.name)
            }
        }]
    }
    function deepCopy(obj){
    
    
        if(typeof obj == "object" && obj!= null){
    
    
            var temp = null;
            if(obj instanceof Array){
    
    
                temp = [];
                for(var i=0;i<obj.length;i++){
    
    
                    temp[i] = deepCopy(obj[i])
                }
            }else{
    
    
                temp = {
    
    };
                for(var k in obj){
    
    
                    temp[k] = deepCopy(obj[k]);
                }
            }
            return temp;
        }else{
    
    
            return obj;
        }
    }
    var obj2 = deepCopy(obj1);

conversión implícita

consejo: la conversión de tipos de datos se divide en: conversión obligatoria, conversión implícita;

a.¿Qué son las conversiones de énfasis? :

Number() se convierte en un número
String() a String Boolear()
a Booleano

b.¿Cuáles son los símbolos de conversión implícitos? :

El símbolo de concatenación de cadenas + intentará convertir otros tipos en cadenas;
± * / == intentará convertir otros tipos a números,
error de conversión NaN;
false se convierte en 0, true se convierte en 1;
<,>,>= ,<=, ! !,= == El juicio y el retorno lógico intentarán convertir otros tipos de valores booleanos (falsamente variables en falso; cadenas vacías, nulo, NaN, indefinido, 0, en falso )

c) ¿Estrictamente igual y relativamente igual al significado?

= = =
Juzgar si el tipo y el valor son relativos
debe usarse en cualquier momento = = = (al juzgar si es nulo o indefinido puede ser un caso especial)
null === null true
==
Juzgue el valor "100" después de la conversión implícita
== 100 // verdadero
nulo == indefinido // verdadero
0 == falso // verdadero
Caso especial: NaN === null // false
{} == {} // false
[] == {} // false
apunta a una dirección de memoria diferente

¿Qué hace el juicio si?

Si el juicio en if() es verdaderamente una variable
Falsamente variable: cadena vacía falsa 0 NaN indefinido nulo (Dos veces negado !!a para obtener el resultado es falso)
Además de la variable falsa, todas las demás son variables verdaderas

¿Lógico y lógico o realizar la distinción?

1. A||B

A es verdadero (verdaderamente) el resultado es A, de lo contrario el resultado es B

2. A&B

A es falso (falsamente) el resultado es A, de lo contrario el resultado es B

3. Objeto de la sentencia

if(a&&a.b&&a.bc){}
if(a?.b?.c){}
Si hay a y hay ab y hay abc
if(abc){} Esto es incorrecto

Prototipos y cadenas de prototipos

a.¿Qué es un prototipo y qué es una cadena de prototipos?

Prototipo de visualización: la clase/constructor es un prototipo de prototipo explícito, que es esencialmente un objeto
Prototipo Implícito: Cada instancia tiene un prototipo implícito __proto__
Relación explícita e implícita: la clase muestra que el prototipo prototipo es igual al prototipo implícito de la instancia que crea __proro__

b. ¿Qué es una cadena prototipo? (Se pueden dibujar iconos)

Cuando busque los métodos y propiedades de una instancia de objeto, primero búsquelo usted mismo, si no puede encontrarlo, busque a lo largo de __proro__, la relación en cadena formada por __proro__ se llama cadena prototipo


<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title>原型</title>
	</head>
	<body>
		<script>
			// 01 创建People类
			function People(name,age){
      
      
				this.name = name;
				this.age = age;
			}
			// 02 给pepole显示原型添加 eat方法
			People.prototype.eat = function(){
      
      
				console.log(this.name+"正在吃饭")
			}
			
			// 03  创建学生类继承 People类
			function Student(name,age,no){
      
      
				// 执行People构造按函数（执行people函数并把当前的this传入函数，当前peoplethis）
				People.call(this,name,age);
				// 定义学号
				this.no =no;
			}
			// 04 让Student原型链继承People的原型链
			Student.prototype = Object.create(People.prototype);
			// 05  修正 Student 显示原型上的构造函数
			Student.prototype.constructor = Student;
			// 06 在Student显示原型链添加方法
			Student.prototype.study = function(){
      
      
				console.log(this.name+"正在好好学习，dayday up");
			}
			// 07 构建Student的实例 s1
			var s1 = new Student("小曾",18,9527);		
		</script>
	</body>
</html>

c.¿El papel del prototipo y la cadena de prototipos?

Se dio cuenta de la herencia de js.
1.1 El método extends de clase

//- class 的 extends方法
class Student extends People{
    
    
constructor(name,age,no){
    
    
//类中继承构造函数
super(name,age)}
}

1.2 Usando la cadena prototipo

1. Stuent构造函数中继承
function Student(name,age,no){
    
     People.call(this,name,age) .... }
2.继承原型链
Student.prototype = Object.create(People.prototype)
2. 修正Student构造函数
Stuent.prototype.constructor = Student

Extensiones de método de instancia para implementar clases

Array.prototype.max = function(){return Math.max(…this))}
Todas las matrices tendrán el método max
String.prototype.reverse = function(){ return this.split("").reverse().join("")}
todas las cadenas tendrán el método inverso
Aviso: Por lo general, no modifique los métodos en el objeto predeterminado y tenga cuidado al extender

Preguntas de la entrevista de la entrevista de front-end sobre js