JavaScript 中创建私有成员

前言：

面向对象编程语言中的 private 关键字是一个访问修饰符，可用于使属性和方法只能在声明的类中访问。这使得隐藏底层逻辑变得容易，这些底层逻辑应该被隐藏起来，并且不应该与类的外部交互。

但是如何在 javascript 中实现类似的功能呢？ 没有保留关键字 private ，但在新的标准中 javascript 有自己的方法来创建类私有成员，但目前还处于 es2020 试验草案中，并且语法比较奇怪，以 # 作为前缀。下面介绍几种在 javascript 代码中实现私有属性和方法的方式。

1.使用闭包

使用闭包可以使用私有属性或者方法的封装。利用闭包可以访问外部函数的变量特征。

如下代码片段：

function myprofile() {
    const mytitle = "devpoint";

    return {
        gettitle: function () {
            return mytitle;
        },
    };
}
const myprofile = myprofile();
console.log(myprofile.gettitle()); // devpoint

这可以转化为将最顶层的自调用函数调用分配给一个变量，并且只用函数返回来公开它的一些内部函数：

const buttoncreator = (function () {
    const properties = {
        width: 100,
        height: 50,
    };

    const getwidth = () => properties.width;
    const getheight = () => properties.height;
    const setwidth = (width) => (properties.width = width);
    const setheight = (height) => (properties.height = height);

    return function (width, height) {
        properties.width = width;
        properties.height = height;

        return {
            getwidth,
            getheight,
            setwidth,
            setheight,
        };
    };
})();
const button = new buttoncreator(600, 360);
console.log(button.getheight()); // 360

2.使用 es6 类

为了使代码更类似于 oop 方法，可以使用 es6 中引入的 class 关键字。要使属性和方法私有，可以在类之外定义它们。

就对上面的 buttoncreator 的例子使用 class 进行重构：

const properties = {
    width: 100,
    height: 50,
};

class buttoncreator {
    constructor(width, height) {
        properties.width = width;
        properties.height = height;
    }

    getwidth = () => properties.width;
    getheight = () => properties.height;
    setwidth = (width) => (properties.width = width);
    setheight = (height) => (properties.height = height);
}
const button = new buttoncreator(600, 360);
console.log(button.getheight()); // 360

现在假设属性是公共的，但想在私有方法中使用它们，其中上下文指向 buttoncreator，可以通过以下方式实现它：

const privates = {
    calculatewidth() {
        return this.width;
    },
};

class buttoncreator {
    constructor(width, height) {
        this.width = width;
        this.height = height;
    }

    getwidth = () => privates.calculatewidth.call(this);
    getheight = () => this.height;
    setwidth = (width) => (this.width = width);
    setheight = (height) => (this.height = height);
}
const button = new buttoncreator(600, 360);
console.log(button.getheight()); // 360

上面的代码使用了 function.prototype.call，它用于调用具有给定上下文的函数。在例子中，使用 buttoncreator 类的上下文。

如果私有函数也需要参数，可以将它们作为附加参数传递以调用：

const privates = {
    calculatewidth(percent) {
        return this.width * percent;
    },
};

class buttoncreator {
    constructor(width, height) {
        this.width = width;
        this.height = height;
    }

    getwidth = () => privates.calculatewidth.call(this, 0.1);
    getheight = () => this.height;
    setwidth = (width) => (this.width = width);
    setheight = (height) => (this.height = height);
}
const button = new buttoncreator(600, 360);
console.log(button.getwidth()); // 60

3.使用 es2020 提案

还处于 es2020 试验草案中，引入了私有方法或者属性的定义，语法比较奇怪，以 # 作为前缀。

class buttoncreator {
    #width;
    #height;
    constructor(width, height) {
        this.#width = width;
        this.#height = height;
    }
    // 私有方法
    #calculatewidth() {
        return this.#width;
    }

    getwidth = () => this.#calculatewidth();
    getheight = () => this.#height;
    setwidth = (width) => (this.#width = width);
    setheight = (height) => (this.#height = height);
}
const button = new buttoncreator(600, 360);
console.log(button.width); // undefined
console.log(button.getwidth()); // 600

4.使用 weakmap

这种方法建立在闭包方法之上，使用作用域变量方法创建一个私有 weakmap，然后使用该 weakmap 检索与此相关的私有数据。这比作用域变量方法更快，因为所有实例都可以共享一个 weakmap，所以不需要每次创建实例时都重新创建方法。

const buttoncreator = (function () {
    const privateprops = new weakmap();
    class buttoncreator {
        constructor(width, height, name) {
            this.name = name; // 公共属性
            privateprops.set(this, {
                width, // 私有属性
                height, // 私有属性
                calculatewidth: () => privateprops.get(this).width, // 私有方法
            });
        }

        getwidth = () => privateprops.get(this).calculatewidth();
        getheight = () => privateprops.get(this).height;
    }
    return buttoncreator;
})();
const button = new buttoncreator(600, 360);
console.log(button.width); // undefined
console.log(button.getwidth()); // 600

这种方式对于私有方法的使用有点别扭。

5.使用 typescript

可以将 typescript 用作 javascript 的一种风格，可以使用 private 关键字从面向对象的语言中真正重新创建功能。

class buttoncreator {
    private width: number;
    private height: number;
    constructor(width: number, height: number) {
        this.width = width;
        this.height = height;
    }
    private calculatewidth() {
        return this.width;
    }
    public getwidth() {
        return this.calculatewidth();
    }
    public getheight() {
        return this.height;
    }
}
const button = new buttoncreator(600, 360);

console.log(button.getwidth()); // 600
console.log(button.width); // error ts2341: property 'width' is private and only accessible within class 'buttoncreator'.

总结：

到此这篇关于javascript 中创建私有成员的文章就介绍到这了,更多相关javascript 中创建私有成员内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！