Wir verwenden häufig Abschlussmethoden, um von außerhalb der Funktion auf Variablen innerhalb der Funktion zuzugreifen
Greifen Sie auf einen grundlegenden Variablentyp zu
Schützen Sie grundlegende Datenvariablen so, dass auf sie nicht direkt zugegriffen werden kann (Lesen, Schreiben).
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 被重新设置了')
Dies ist eine Kapselung sensibler Daten a. Eines der Prinzipien der Kapselung besteht darin, so wenig interne Implementierungsmethoden wie möglich verfügbar zu machen. Obwohl Daten a hier geschützt sind, haben wir die Methode zur Bedienung verfügbar gemacht, damit wir Folgendes verbessern können:
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 被重新设置了')
Wenn wir Daten a bedienen und darauf zugreifen möchten, können wir hier nur getBaseA () und setBaseA () verwenden. Dann wissen andere Entwickler nicht, wie man intern liest und schreibt, sondern wissen nur, dass sie über diese beiden ausgeführt werden können Methoden. Betrieb
Zugriff auf einen Referenzdatentyp (Array)
So schützen Sie ein Array: Gehen Sie direkt zum Code
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 的数据')
Zugriff auf einen Referenzdatentyp (Objekt)
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())
Dies unterscheidet sich von grundlegenden Typdaten. Wenn arr (dies ist eine Adresse) in der erhaltenen Funktion direkt verfügbar gemacht wird, schützt es sie überhaupt nicht. Der Grund dafür ist, dass der Referenztyp im Speicher gespeichert ist.
Der Basisdatenspeicher wird direkt im Stapel gespeichert, wobei die Fehloperation den Wert des geschützten a nicht beeinflusst. Der
Referenzdatentyp wird im Heap gespeichert. Wenn der geschützte arr direkt zurückgegeben wird, ändert die Fehloperation den Wert von arr Wenn dies der Vorgang ist, erstellen Sie eine tiefe Kopie, auch wenn eine externe Fehloperation vorliegt. Dies hat keine Auswirkungen auf den geschützten Arr, da der arr-Ersatz newArr geändert wurde
Das
Replikationsprinzip von Object.assign kann wie folgt aussehen
//由上面的错误的思考
Object.assign = function(newObj,oldObj) {
for(let key in oldObj) {
newObj[key]=oldObj[key]
}
return newObj
}
Persönliche Meinung, kurz nach dem Start, wenn es Fehler gibt, korrigieren Sie mich bitte.