仅在具有该类实例的类内部访问该类的私有成员

Question

我正在实现一个链接列表。 我有两个班级Node 和SingleLinkedList。现在我需要从SingleLinkedList 类访问Node 类的私有成员，但在外面我认为这是不可能的；通过这种方式，我可以从SingleLinkedList 返回一个Node 实例，并且用户无法使用该节点加入所有数据结构。在 Java 中，当一个类具有另一个类的对象（组合）时可以做到这一点，而在 C++ 中则有友元类。我怎样才能在 Javascript 中做到这一点？

以下是我正在实施的“示例玩具”，以测试我目前获得的知识并看看会出现什么问题

  class Node {
             next = null;
             constructor(value) {
                this.value = value;

             }
          }

          class SingleLinkedList {
             #size = 0;
             #head = null;
             #tail = null;

             // read only get accessor property
             get size() {
                return this.#size;
             }

             isEmpty() {
                return this.#size === 0;
             }

            // insert a new Node (in tail) with the desired value
         push(value) {
            const node = new Node(value);

            if (this.isEmpty()) {
               this.#head = node;
            } else {
               this.#tail.next = node;
            }

            // the following instructions are common to both the cases.
            this.#tail = node;
            this.#size++;

            // to allow multiple push call
            return this;
         }



        get(index){
        if(index<0 || index>=this.#size)
           return null;

        let current = this.#head;


        return current.value;
     }


          }

          const myLinkedList = new SingleLinkedList();
          myLinkedList.push(3).push(5);

例如，如果我将 Node 类的 nextproperty 设为私有@
我无法再访问我的SingleLinkedClass 中的变量。相反，如果我留下这样的代码并从某个函数返回一个Node 实例，那么用户可以使用下一个属性加入几乎所有我的结构。它是否存在一些可能很简单的 Javascript 解决方案？ 我想尽可能清楚。因此，我想要做的是：

  class Node {
         next = null;
         constructor(value) {
            this.value = value;

         }
      }

      class SingleLinkedList {
         #size = 0;
         #head = null;
         #tail = null;

         // read only get accessor property
         get size() {
            return this.#size;
         }

         isEmpty() {
            return this.#size === 0;
         }


        // insert a new Node (in tail) with the desired value
     push(value) {
        const node = new Node(value);

        if (this.isEmpty()) {
           this.#head = node;
        } else {
           this.#tail.next = node;
        }

        // the following instructions are common to both the cases.
        this.#tail = node;
        this.#size++;

        // to allow multiple push call
        return this;
     }


        get(index){
        if(index<0 || index>=this.#size)
           return null;

        let current = this.#head;


        return current; //NOW RETURN A NODE
     }

      const myLinkedList = new SingleLinkedList();
      myLinkedList.push(3).push(5);

      const myNode = myLinkedList.get(0); //RETURN NODE

现在，在上面的代码中，get() 返回一个节点，您可以使用它扫描整个列表。不好。因此我想做：

class Node {
         #next = null; //PRIVATE MEMBER
         constructor(value) {
            this.value = value;

         }
      }

      class SingleLinkedList {
         #size = 0;
         #head = null;
         #tail = null;

         // read only get accessor property
         get size() {
            return this.#size;
         }

         isEmpty() {
            return this.#size === 0;
         }


        // insert a new Node (in tail) with the desired value
     push(value) {
        const node = new Node(value);

        if (this.isEmpty()) {
           this.#head = node;
        } else {
           this.#tail.#next = node; //ERROR
        }

        // the following instructions are common to both the cases.
        this.#tail = node;
        this.#size++;

        // to allow multiple push call
        return this;
     }



        get(index){
        if(index<0 || index>=this.#size)
           return null;

        let current = this.#head;


        return current; //NOW RETURN A NODE
     }



      }

      const myLinkedList = new SingleLinkedList();
      myLinkedList.push(3).push(5);
      console.log(myLinkedList.toString());
      const myNode = myLinkedList.get(0); //RETURN NODE,NO MORE A PROBLEM

在最后一个版本中，当我从 get() 返回一个节点时不再是问题，因为 Node 类的成员，即 #next 是私有的，但这样我有一个错误，因为即使在 @ 987654338@ 成员#next 不可见。

我希望这能澄清我的问题

Answer 1

私有标识符是词法范围的，因此#size 等在SingleLinkedList 之外是不可访问的。但是有几种方法可以做到这一点。

最简单的就是让Node在SingleLinkedList:

"use strict";
class SingleLinkedList {
    #size = 0;
    
    constructor(size) {
        this.#size = size;
    }

    static Node = class Node {
        example(list) {
            console.log(`The size of the list is ${list.#size}`);
        }
    }
}
const Node = SingleLinkedList.Node;

// The `Node` code has access to `SingleLinkedList`'s private field:
const l = new SingleLinkedList(42);
const n = new Node();
n.example(l); // "The size of the list is ${getSize(list)}"

由于作用域是词法的，并且Node 的所有代码都在SingleLinkedList 的作用域内，所以效果很好。

如果您不希望它们嵌套，您可以让SingleLinkedList 为Node 提供一个只有Node 可以访问的函数，这将使Node 从SingleLinkedlist 的私人获取信息字段。这是一个示例，请参见 cmets：

"use strict";
const {Node, SingleLinkedList} = (() => {
    // A function SingleLinkedList will fill in
    let getSize;

    // Create the class
    class SingleLinkedList {
        #size = 0;
        
        constructor(size) {
            this.#size = size;
        }

        // This is a temporary function for filling in `getSize`
        static boot() {
            getSize = list => list.#size;
        }
    }

    // Fill in `getSize`
    SingleLinkedList.boot();
    delete SingleLinkedList.boot;

    // Find the `Node` class, which uses `getSize`
    class Node {
        example(list) {
            console.log(`The size of the list is ${getSize(list)}`);
        }
    }

    // Return them; `getSize` is entirely private to the code
    // in this function, nothing else can use it
    return {Node, SingleLinkedList}
})();

// The `Node` code has access to `SingleLinkedList`'s private field:
const l = new SingleLinkedList(42);
const n = new Node();
n.example(l); // "The size of the list is ${getSize(list)}"

之所以有效，是因为#size 的实际使用在它存在的范围内。

另一种选择是使Node 在 SingleLinkedList: