JavaScript 비공개 필드 접근 제어: 캡슐화 강제

            class Counter {
  constructor() {
    this._count = 0; // Convention: treat as private
  }

  increment() {
    this._count++;
  }

  getCount() {
    return this._count;
  }
}

const counter = new Counter();
counter._count = 100; // Still accessible!
console.log(counter.getCount()); // Output: 100

            

              
                Copy
              
            
          

            function createCounter() {
  let count = 0; // Private variable

  return {
    increment: function() {
      count++;
    },
    getCount: function() {
      return count;
    }
  };
}

const counter = createCounter();
counter.increment();
console.log(counter.getCount()); // Output: 1
// console.log(counter.count); // Error: counter.count is undefined

            

              
                Copy
              
            
          

            const _count = new WeakMap();

class Counter {
  constructor() {
    _count.set(this, 0);
  }

  increment() {
    const currentCount = _count.get(this);
    _count.set(this, currentCount + 1);
  }

  getCount() {
    return _count.get(this);
  }
}

const counter = new Counter();
counter.increment();
console.log(counter.getCount()); // Output: 1
// console.log(_count.get(counter)); // Error: _count is not accessible outside the module

            

              
                Copy
              
            
          

            class MyClass {
  #privateField;

  constructor(initialValue) {
    this.#privateField = initialValue;
  }

  getPrivateFieldValue() {
    return this.#privateField;
  }
}

            

              
                Copy
              
            
          

            class Counter {
  #count = 0; // Private field

  increment() {
    this.#count++;
  }

  getCount() {
    return this.#count;
  }
}

const counter = new Counter();
counter.increment();
console.log(counter.getCount()); // Output: 1

// console.log(counter.#count); // SyntaxError: Private field '#count' must be declared in an enclosing class

            

              
                Copy
              
            
          

            class User {
  #apiKey;

  constructor(apiKey) {
    this.#apiKey = apiKey;
  }

  isValidAPIKey() {
    // Perform validation logic here
    return this.#validateApiKey(this.#apiKey);
  }

  #validateApiKey(apiKey) {
    // Private method to validate the API Key
    return apiKey.length > 10;
  }
}

const user = new User("mysecretapikey123");
console.log(user.isValidAPIKey()); //Output: True
//console.log(user.#apiKey); //SyntaxError: Private field '#apiKey' must be declared in an enclosing class

            

              
                Copy
              
            
          

            class TemperatureSensor {
  #temperature;

  constructor(initialTemperature) {
    this.setTemperature(initialTemperature);
  }

  getTemperature() {
    return this.#temperature;
  }

  setTemperature(temperature) {
    if (temperature < -273.15) { // Absolute zero
      throw new Error("Temperature cannot be below absolute zero.");
    }
    this.#temperature = temperature;
  }
}

try {
  const sensor = new TemperatureSensor(25);
  console.log(sensor.getTemperature()); // Output: 25

  sensor.setTemperature(-300); // Throws an error
} catch (error) {
  console.error(error.message);
}

            

              
                Copy
              
            
          

            class Calculator {
  #internalResult = 0;

  add(number) {
    this.#internalResult += number;
    return this;
  }

  subtract(number) {
    this.#internalResult -= number;
    return this;
  }

  getResult() {
    return this.#internalResult;
  }
}

const calculator = new Calculator();
const result = calculator.add(10).subtract(5).getResult();
console.log(result); // Output: 5
// console.log(calculator.#internalResult); // SyntaxError

            

              
                Copy
              
            
          

            class MyClass {
  #privateMethod() {
    console.log("This is a private method.");
  }

  publicMethod() {
    this.#privateMethod(); // Call the private method
  }
}

const myObject = new MyClass();
myObject.publicMethod(); // Output: This is a private method.

// myObject.#privateMethod(); // SyntaxError: Private field '#privateMethod' must be declared in an enclosing class

            

              
                Copy