A menudo usamos métodos de cierre para acceder a variables dentro de la función desde fuera de la función
Acceder a un tipo de variable básica
Proteja las variables de datos básicas para que no se pueda acceder a ellas directamente (leer, escribir)
function operateBaseVariable(){
let a = 10
function getA() {
return a
}
function setA(any){
a = any
}
return {
getA,
setA,
}
}
let opertaeBase = operateBaseVariable()//这是一个对象,对象里面包含两个函数
//获取a的值
opertaeBase.getA()
//设置a的值
opertaeBase.setA('a 被重新设置了')
Esta es una encapsulación de datos sensibles. A. Uno de los principios de la encapsulación es exponer la menor cantidad posible de métodos de implementación interna. Aunque los datos a están protegidos aquí, hemos expuesto el método de operación, por lo que podemos mejorar:
function operateBaseVariable(){
let a = 10
function getA() {
return a
}
function setA(any){
a = any
}
return {
getBaseA: getA,
setBaseA: setA,
}
}
let opertaeBase = operateBaseVariable()//这是一个对象,对象里面包含两个函数
//获取a的值
opertaeBase.getBaseA()
//设置a的值
opertaeBase.setBaseA('a 被重新设置了')
Aquí, si queremos operar y acceder a los datos a, solo podemos usar getBaseA () y setBaseA (). Luego, otros desarrolladores no saben cómo leer y escribir internamente, pero solo saben que pueden hacerlo a través de estos dos métodos. Operación
Acceder a un tipo de datos de referencia (matriz)
¿Cómo proteger una matriz? Ir directamente al código
function operateComplexVariable(){
let arr = [1,2,3]
function getArr() {
let newArr = [...arr] //深拷贝
return newArr
}
function pushArr(any){
arr.push(any)
}
return {
getComplexArr: getArr,
pushComplexArr: pushArr,
}
}
let opertaeComplex = operateComplexVariable()//这是一个对象,对象里面包含两个函数
//获取arr的值
opertaeBase.getComplexArr()
//设置a的值
opertaeBase.pushComplexArr('arr push 的数据')
Acceder a un tipo de datos de referencia (objeto)
function obj() {
let mySymbol = Symbol() /* es6 出现的新的基本数据类型,我只是想要使用一下 */
let obj = {
name: '张三',
age: 18,
sex: '男',
[mySymbol]: 'symbol数据'
}
function getObj(){
let newobj = {
}
Object.assign(newobj,obj)
return newobj
}
function setObj(setObj){
//setObj应该是个对象
//Object.assign(obj,setObj)
//对象只有一级属性时,用这个方法深拷贝没有问题
//在对象的二级属性为引用类型时,这个方法就是浅拷贝二级属性了了
//更改
return JSON.parse(JSON.stringify(obj ))
}
return {
getObject: getObj,
setObject: setObj,
}
}
let objOperate = obj()
objOperate.getObject()
objOperate.setObject({
add: '新增数据'})
console.log(objOperate.getObject())
Esto es diferente a los datos de tipo básico, si arr (esta es una dirección) se expone directamente en la función obtenida, no la protege en absoluto, la razón es que el tipo de referencia se almacena en la memoria.
El almacenamiento de datos básicos se almacena directamente en la pila, donde la operación incorrecta no afectará el valor de la a protegida. El
tipo de datos de referencia se almacena en el montón. Si el arr protegido se devuelve directamente, la operación incorrecta cambiará el valor de arr , y si esta es la operación, haga una copia profunda, incluso si hay un mal funcionamiento externo, no afectará el arr protegido porque es el arr sustituto newArr el que se ha cambiado
Principio de
replicación de Object.assign , la implementación interna puede ser así
//由上面的错误的思考
Object.assign = function(newObj,oldObj) {
for(let key in oldObj) {
newObj[key]=oldObj[key]
}
return newObj
}
Opinión personal, poco después de comenzar, si hay errores, corríjame.