ਬਿਨਾਂ ਸ਼ਰਤ ਜਾਂਚਾਂ ਦੇ JavaScript ਵਿੱਚ ਆਬਜੈਕਟ ਪ੍ਰਾਪਰਟੀ ਇਟਰੇਸ਼ਨ ਨੂੰ ਅਨੁਕੂਲਿਤ ਕਰਨਾ

JavaScript ਵਿੱਚ ਆਬਜੈਕਟ-ਓਰੀਐਂਟਿਡ ਪ੍ਰਾਪਰਟੀ ਰੀਟਰੇਸ਼ਨ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰਨਾ

JavaScript ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਆਬਜੈਕਟ-ਅਧਾਰਿਤ ਪਹੁੰਚ ਅਪਣਾਉਣ ਨਾਲ ਤੁਹਾਡੇ ਕੋਡ ਨੂੰ ਹੋਰ ਸੰਗਠਿਤ ਅਤੇ ਸਾਂਭਣਯੋਗ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। ਇੱਕ ਆਮ ਪੈਟਰਨ ਇਹਨਾਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚ ਹੇਰਾਫੇਰੀ ਕਰਨ ਵਾਲੇ ਤਰੀਕਿਆਂ ਦੇ ਨਾਲ ਵਸਤੂਆਂ ਵਿੱਚ ਸੰਬੰਧਿਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦਾ ਸਮੂਹ ਕਰਨਾ ਹੈ। ਹਾਲਾਂਕਿ, ਇਹ ਅਕਸਰ ਚੁਣੌਤੀਆਂ ਵੱਲ ਖੜਦਾ ਹੈ ਜਦੋਂ ਵਿਧੀਆਂ ਦੁਹਰਾਅ ਦੌਰਾਨ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚ ਅਣਜਾਣੇ ਵਿੱਚ ਦਖਲ ਦਿੰਦੀਆਂ ਹਨ।

ਇੱਕ ਆਮ ਉਦਾਹਰਣ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸ਼ਾਮਲ ਹੈ Object.keys() ਕਿਸੇ ਵਸਤੂ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਦੁਹਰਾਉਣ ਲਈ। ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਅਕਸਰ ਇਸ ਦੁਹਰਾਓ ਦੇ ਦੌਰਾਨ ਤਰੀਕਿਆਂ ਨੂੰ ਬਾਹਰ ਕੱਢਣ ਦੀ ਜ਼ਰੂਰਤ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪੈਂਦਾ ਹੈ। ਇਸ ਲਈ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਛੱਡਣ ਲਈ ਇੱਕ ਸ਼ਰਤੀਆ ਧਾਰਾ ਜੋੜਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਜੋ ਕੋਡ ਨੂੰ ਗੁੰਝਲਦਾਰ ਦ੍ਰਿਸ਼ਾਂ ਵਿੱਚ ਬਣਾਈ ਰੱਖਣ ਲਈ ਵਧੇਰੇ ਮੁਸ਼ਕਲ ਅਤੇ ਔਖਾ ਬਣਾ ਸਕਦਾ ਹੈ।

ਇੱਕ ਵਿਕਲਪ ਹੈ ਨੇਸਟਡ ਆਬਜੈਕਟ ਦੇ ਅੰਦਰ ਗੁਣਾਂ ਦਾ ਸਮੂਹ ਕਰਨਾ, ਉਹਨਾਂ ਨੂੰ ਤਰੀਕਿਆਂ ਤੋਂ ਵੱਖ ਕਰਨਾ। ਹਾਲਾਂਕਿ ਇਹ ਅਣਇੱਛਤ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਘਟਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ, ਇਹ ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਹਵਾਲਾ ਪੇਸ਼ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਇਸ ਰਾਹੀਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਤੱਕ ਪਹੁੰਚ ਕਰਨਾ myObj.props.prop1 ਦੇ ਬਜਾਏ myObj.prop1. ਕੋਡ ਪੜ੍ਹਨਯੋਗਤਾ ਅਤੇ ਕਾਰਜਕੁਸ਼ਲਤਾ ਦੇ ਵਿਚਕਾਰ ਇਹ ਵਪਾਰ ਡਿਵੈਲਪਰਾਂ ਲਈ ਇੱਕ ਦਿਲਚਸਪ ਦੁਬਿਧਾ ਪੈਦਾ ਕਰਦਾ ਹੈ.

ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਕੋਡ ਨੂੰ ਸ਼ਾਨਦਾਰ ਅਤੇ ਕੁਸ਼ਲ ਰੱਖਦੇ ਹੋਏ ਇਹਨਾਂ ਚੁਣੌਤੀਆਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਦੇ ਵਿਹਾਰਕ ਤਰੀਕਿਆਂ ਦੀ ਪੜਚੋਲ ਕਰਾਂਗੇ। ਅਸੀਂ ਸ਼ਰਤਾਂ 'ਤੇ ਜ਼ਿਆਦਾ ਭਰੋਸਾ ਕੀਤੇ ਬਿਨਾਂ ਵਸਤੂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਦੁਹਰਾਉਣ ਲਈ ਵੱਖ-ਵੱਖ ਤਕਨੀਕਾਂ 'ਤੇ ਗੌਰ ਕਰਾਂਗੇ। ਅੰਤ ਤੱਕ, ਤੁਸੀਂ ਇੱਕ ਹੋਰ ਆਬਜੈਕਟ-ਅਧਾਰਿਤ ਫੈਸ਼ਨ ਵਿੱਚ ਵਸਤੂਆਂ ਦੀ ਬਣਤਰ ਬਾਰੇ ਸਮਝ ਪ੍ਰਾਪਤ ਕਰੋਗੇ ਜੋ ਬੇਲੋੜੀਆਂ ਜਟਿਲਤਾਵਾਂ ਤੋਂ ਬਚਦਾ ਹੈ।

JavaScript ਵਿੱਚ ਆਬਜੈਕਟ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਦੁਹਰਾਉਣ ਲਈ ਹੱਲਾਂ ਦੀ ਖੋਜ ਕਰਨਾ

ਸਾਡੇ ਦੁਆਰਾ ਵਿਕਸਤ ਕੀਤੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਦਾ ਉਦੇਸ਼ ਇੱਕ ਆਮ ਮੁੱਦੇ ਨੂੰ ਹੱਲ ਕਰਨਾ ਹੈ JavaScript: ਅਣਜਾਣੇ ਵਿੱਚ ਸੋਧਣ ਜਾਂ ਤਰੀਕਿਆਂ ਨਾਲ ਇੰਟਰੈਕਟ ਕੀਤੇ ਬਿਨਾਂ ਆਬਜੈਕਟ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਕਿਵੇਂ ਦੁਹਰਾਉਣਾ ਹੈ। ਪਹਿਲੇ ਹੱਲ ਵਿੱਚ, ਅਸੀਂ ਵਰਤਦੇ ਹਾਂ Object.defineProperty ਵਿਧੀ ਨੂੰ ਗੈਰ-ਗਿਣਤੀਯੋਗ ਬਣਾਉਣ ਲਈ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਜਦੋਂ ਅਸੀਂ ਆਬਜੈਕਟ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਲੂਪ ਕਰਦੇ ਹਾਂ Object.keys(), ਵਿਧੀ ਨੂੰ ਦੁਹਰਾਓ ਤੋਂ ਬਾਹਰ ਰੱਖਿਆ ਗਿਆ ਹੈ। ਇਹ ਪਹੁੰਚ ਸਾਡੇ ਡੇਟਾ ਦੀ ਇਕਸਾਰਤਾ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਦੀ ਹੈ ਅਤੇ ਲੂਪ ਦੇ ਅੰਦਰ ਵਾਧੂ ਸ਼ਰਤੀਆ ਜਾਂਚਾਂ ਦੀ ਲੋੜ ਤੋਂ ਬਚਦੀ ਹੈ।

ਇਕ ਹੋਰ ਮੁੱਖ ਹੱਲ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸ਼ਾਮਲ ਹੈ ES6 ਚਿੰਨ੍ਹ. ਚਿੰਨ੍ਹ ਗਣਨਾ ਜਾਂ ਦੁਹਰਾਓ ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿੱਚ ਦਖਲ ਦਿੱਤੇ ਬਿਨਾਂ ਵਸਤੂਆਂ ਵਿੱਚ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਜਾਂ ਵਿਧੀਆਂ ਨੂੰ ਜੋੜਨ ਦਾ ਇੱਕ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ। ਸਾਡੀ ਉਦਾਹਰਨ ਵਿੱਚ, ਇੱਕ ਸਿੰਬਲ ਕੁੰਜੀ ਨੂੰ ਵਿਧੀ ਨਿਰਧਾਰਤ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਇਹ ਲੁਕਿਆ ਹੋਇਆ ਹੈ Object.entries(), ਜਿਸਨੂੰ ਅਸੀਂ ਆਬਜੈਕਟ ਦੀਆਂ ਕੁੰਜੀਆਂ ਅਤੇ ਮੁੱਲਾਂ ਨੂੰ ਦੁਹਰਾਉਣ ਲਈ ਵਰਤਦੇ ਹਾਂ। ਇਹ ਤਕਨੀਕ ਉਜਾਗਰ ਕਰਦੀ ਹੈ ਕਿ ਕਿਵੇਂ ਪ੍ਰਤੀਕ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਆਬਜੈਕਟ-ਓਰੀਐਂਟਿਡ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਉਪਯੋਗੀ ਹੋ ਸਕਦੇ ਹਨ ਜਦੋਂ ਕੁਝ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਜਾਂ ਵਿਧੀਆਂ ਨੂੰ ਦੁਹਰਾਓ ਤਰਕ ਲਈ ਅਦਿੱਖ ਰਹਿਣਾ ਚਾਹੀਦਾ ਹੈ।

ਅਸੀਂ ਏ ਦੀ ਵਰਤੋਂ ਦੀ ਵੀ ਪੜਚੋਲ ਕੀਤੀ ਕਲਾਸ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਵਿਧੀਆਂ ਨੂੰ ਹੋਰ ਰਸਮੀ ਤੌਰ 'ਤੇ ਵੱਖ ਕਰਨ ਲਈ। ਇਹ ਵਿਧੀ ਇਕੋ ਢਾਂਚੇ ਦੇ ਅੰਦਰ ਡੇਟਾ (ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ) ਅਤੇ ਵਿਵਹਾਰ (ਵਿਧੀ) ਦੋਵਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਕੇ ਵਸਤੂ-ਮੁਖੀ ਸਿਧਾਂਤਾਂ ਨਾਲ ਇਕਸਾਰ ਕਰਦੀ ਹੈ। ਇਹ ਪਹੁੰਚ ਆਬਜੈਕਟ ਦੀ ਮੁੜ ਵਰਤੋਂ ਅਤੇ ਸੋਧ ਨੂੰ ਸਰਲ ਬਣਾਉਂਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਕੋਡ ਨੂੰ ਮੁੜ-ਲਿਖਣ ਤੋਂ ਬਿਨਾਂ ਕਲਾਸ ਦੀਆਂ ਕਈ ਉਦਾਹਰਨਾਂ ਬਣਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਮਿਲਦੀ ਹੈ। ਦੀ ਵਰਤੋਂ Object.keys() ਇੱਕ ਕਲਾਸ ਵਿਧੀ ਦੇ ਅੰਦਰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਸਿਰਫ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਪ੍ਰਭਾਵਿਤ ਹੁੰਦੀਆਂ ਹਨ, ਜਿਸ ਨਾਲ ਸਾਂਭ-ਸੰਭਾਲ ਅਤੇ ਕੋਡ ਪੜ੍ਹਨਯੋਗਤਾ ਦੋਵਾਂ ਵਿੱਚ ਵਾਧਾ ਹੁੰਦਾ ਹੈ।

ਸਾਡੇ ਹੱਲ ਦਾ ਅੰਤਮ ਹਿੱਸਾ ਟੈਸਟਿੰਗ 'ਤੇ ਕੇਂਦ੍ਰਿਤ ਹੈ ਮਜ਼ਾਕ, ਇੱਕ ਪ੍ਰਸਿੱਧ JavaScript ਟੈਸਟਿੰਗ ਫਰੇਮਵਰਕ। ਅਸੀਂ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਯੂਨਿਟ ਟੈਸਟ ਲਿਖੇ ਹਨ ਕਿ ਸਾਡੀਆਂ ਦੁਹਰਾਓ ਵਿਧੀਆਂ ਵੱਖ-ਵੱਖ ਲਾਗੂਕਰਨਾਂ ਵਿੱਚ ਉਮੀਦ ਮੁਤਾਬਕ ਪ੍ਰਦਰਸ਼ਨ ਕਰਦੀਆਂ ਹਨ। ਗੁੰਝਲਦਾਰ ਵਸਤੂਆਂ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਸੰਭਾਵੀ ਬੱਗ ਜਾਂ ਅਚਾਨਕ ਵਿਵਹਾਰ ਦੀ ਪਛਾਣ ਕਰਨ ਲਈ ਇਹ ਮਹੱਤਵਪੂਰਨ ਹੈ। ਵਰਗੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਟੈਸਟ() ਅਤੇ ਉਮੀਦ ਕਰੋ() ਜੈਸਟ ਵਿੱਚ ਨਾ ਸਿਰਫ ਸਾਡੇ ਕੋਡ ਦੀ ਸ਼ੁੱਧਤਾ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਦਾ ਹੈ ਬਲਕਿ ਪੂਰੀ ਤਰ੍ਹਾਂ ਜਾਂਚ ਨੂੰ ਉਤਸ਼ਾਹਿਤ ਕਰਕੇ ਸਾਫਟਵੇਅਰ ਵਿਕਾਸ ਵਿੱਚ ਵਧੀਆ ਅਭਿਆਸਾਂ ਨੂੰ ਵੀ ਉਤਸ਼ਾਹਿਤ ਕਰਦਾ ਹੈ।

// Solution 1: Using Object.defineProperty to Hide Methods from Iteration
const myObj = {};
Object.defineProperty(myObj, 'prop1', { value: 'one', writable: true, enumerable: true });
Object.defineProperty(myObj, 'prop2', { value: 'two', writable: true, enumerable: true });
Object.defineProperty(myObj, 'myMethod', {
  value: function() {
    Object.keys(this).forEach(prop => {
      this[prop] = this[prop].toUpperCase();
    });
  },
  enumerable: false
});

console.log(myObj.prop1, myObj.prop2);
myObj.myMethod();
console.log(myObj.prop1, myObj.prop2);

const METHOD_KEY = Symbol('myMethod');

const myObj = {
  prop1: 'one',
  prop2: 'two',
  [METHOD_KEY]: function() {
    Object.entries(this).forEach(([key, value]) => {
      if (typeof value === 'string') this[key] = value.toUpperCase();
    });
  }
};

console.log(myObj.prop1, myObj.prop2);
myObj[METHOD_KEY]();
console.log(myObj.prop1, myObj.prop2);

class MyObject {
  constructor() {
    this.prop1 = 'one';
    this.prop2 = 'two';
  }

  uppercaseProps() {
    Object.keys(this).forEach(key => {
      this[key] = this[key].toUpperCase();
    });
  }
}

const obj = new MyObject();
console.log(obj.prop1, obj.prop2);
obj.uppercaseProps();
console.log(obj.prop1, obj.prop2);

const { test, expect } = require('@jest/globals');

test('Solution 1: Should uppercase properties', () => {
  const obj = { prop1: 'one', prop2: 'two' };
  Object.keys(obj).forEach(key => obj[key] = obj[key].toUpperCase());
  expect(obj.prop1).toBe('ONE');
  expect(obj.prop2).toBe('TWO');
});

test('Solution 2: Should uppercase properties using class', () => {
  const obj = new MyObject();
  obj.uppercaseProps();
  expect(obj.prop1).toBe('ONE');
  expect(obj.prop2).toBe('TWO');
});

ਐਡਵਾਂਸਡ JavaScript ਪੈਟਰਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਬਜੈਕਟ ਦੁਹਰਾਓ ਚੁਣੌਤੀਆਂ ਨੂੰ ਹੱਲ ਕਰਨਾ

ਸੰਭਾਲਣ ਦਾ ਇੱਕ ਦਿਲਚਸਪ ਤਰੀਕਾ ਆਬਜੈਕਟ-ਅਧਾਰਿਤ JavaScript ਚੁਣੌਤੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਹੈ ਪ੍ਰੋਟੋਟਾਈਪ. JavaScript ਵਸਤੂਆਂ ਨੂੰ ਅਕਸਰ ਪ੍ਰੋਟੋਟਾਈਪਾਂ ਨਾਲ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ, ਜੋ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਉਦਾਹਰਨਾਂ ਵਿੱਚ ਸਾਂਝੇ ਢੰਗਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਪ੍ਰੋਟੋਟਾਈਪ ਦੇ ਅੰਦਰ ਮੁੜ ਵਰਤੋਂ ਯੋਗ ਤਰੀਕਿਆਂ ਨੂੰ ਰੱਖ ਕੇ, ਉਹ ਸੰਪੱਤੀ ਦੇ ਦੁਹਰਾਅ ਵਿੱਚ ਦਖਲ ਨਹੀਂ ਦੇਣਗੇ। ਇਹ ਤਕਨੀਕ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੀ ਹੈ ਕਿ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ ਸਿਰਫ਼ ਵਸਤੂ ਨਾਲ ਸਿੱਧੇ ਜੁੜੇ ਗੁਣਾਂ ਨੂੰ ਹੀ ਸੋਧਿਆ ਜਾਂਦਾ ਹੈ Object.keys() ਜਾਂ Object.entries(). ਇਸ ਤੋਂ ਇਲਾਵਾ, ਪ੍ਰੋਟੋਟਾਈਪ ਕੋਡ ਦੀ ਮੁੜ ਵਰਤੋਂਯੋਗਤਾ ਅਤੇ ਬਿਹਤਰ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਨੂੰ ਉਤਸ਼ਾਹਿਤ ਕਰਦੇ ਹਨ।

ਇੱਕ ਹੋਰ ਸ਼ਕਤੀਸ਼ਾਲੀ ਪਹੁੰਚ ਲੀਵਰਿੰਗ ਹੈ getter ਅਤੇ setter ਫੰਕਸ਼ਨ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੇ ਅਤੇ ਸੇਟਰ ਅਸਿੱਧੇ ਤੌਰ 'ਤੇ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਨ ਦਾ ਇੱਕ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ, ਜਿਸ ਨਾਲ ਤੁਸੀਂ ਦੁਹਰਾਓ ਦੌਰਾਨ ਜਾਂ ਐਕਸੈਸ ਕੀਤੇ ਜਾਣ ਵੇਲੇ ਉਹਨਾਂ ਦੇ ਵਿਵਹਾਰ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰ ਸਕਦੇ ਹੋ। ਇਸ ਪੈਟਰਨ ਨਾਲ, ਡਿਵੈਲਪਰ ਸਮਰਪਿਤ ਫੰਕਸ਼ਨਾਂ ਰਾਹੀਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਸੋਧਣ ਲਈ ਲਚਕਤਾ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦੇ ਹੋਏ ਤਰੀਕਿਆਂ ਦੇ ਅਣਇੱਛਤ ਸੋਧ ਨੂੰ ਰੋਕ ਸਕਦੇ ਹਨ। ਇਹ ਹੱਲ ਇਹ ਵੀ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਉਪਭੋਗਤਾਵਾਂ ਲਈ ਇੱਕ ਸਾਫ਼ API ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ ਆਬਜੈਕਟ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਐਨਕੈਪਸਲੇਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਅੰਤ ਵਿੱਚ, ਡਿਵੈਲਪਰ ਵਰਤਣ ਬਾਰੇ ਵਿਚਾਰ ਕਰ ਸਕਦੇ ਹਨ Object.freeze() ਜਾਂ Object.seal() ਵਸਤੂ ਦੀ ਪਰਿਵਰਤਨਸ਼ੀਲਤਾ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ. Object.freeze() ਕਿਸੇ ਵਸਤੂ ਨੂੰ ਅਟੱਲ ਬਣਾਉਂਦਾ ਹੈ, ਇਸ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚ ਕਿਸੇ ਵੀ ਤਬਦੀਲੀ ਨੂੰ ਰੋਕਦਾ ਹੈ, ਜੋ ਉਹਨਾਂ ਮਾਮਲਿਆਂ ਵਿੱਚ ਲਾਭਦਾਇਕ ਹੋ ਸਕਦਾ ਹੈ ਜਿੱਥੇ ਤੁਸੀਂ ਦੁਰਘਟਨਾਤਮਕ ਸੋਧਾਂ ਤੋਂ ਬਿਨਾਂ ਡੇਟਾ ਨੂੰ ਪੜ੍ਹਨਾ ਚਾਹੁੰਦੇ ਹੋ। ਦੂਜੇ ਹਥ੍ਥ ਤੇ, Object.seal() ਮੌਜੂਦਾ ਸੰਪਤੀਆਂ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਪਰ ਨਵੀਆਂ ਨੂੰ ਜੋੜਨ ਤੋਂ ਰੋਕਦਾ ਹੈ। ਇਹ ਪੈਟਰਨ ਨਾ ਸਿਰਫ਼ ਕੋਡ ਦੀ ਇਕਸਾਰਤਾ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਣ ਵਿੱਚ ਮਦਦ ਕਰਦੇ ਹਨ, ਸਗੋਂ ਆਬਜੈਕਟ ਵਿਵਹਾਰਾਂ 'ਤੇ ਸਖ਼ਤ ਨਿਯੰਤਰਣ ਵੀ ਲਾਗੂ ਕਰਦੇ ਹਨ, ਜਿਸ ਨਾਲ ਦੁਹਰਾਓ ਨੂੰ ਸੁਰੱਖਿਅਤ ਅਤੇ ਵਧੇਰੇ ਅਨੁਮਾਨ ਲਗਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।