ಷರತ್ತುಬದ್ಧ ಪರಿಶೀಲನೆಗಳಿಲ್ಲದೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಆಬ್ಜೆಕ್ಟ್ ಪ್ರಾಪರ್ಟಿ ಪುನರಾವರ್ತನೆಯನ್ನು ಉತ್ತಮಗೊಳಿಸುವುದು

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಮಾಸ್ಟರಿಂಗ್ ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರಾಪರ್ಟಿ ಪುನರಾವರ್ತನೆ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಆಬ್ಜೆಕ್ಟ್-ಆಧಾರಿತ ವಿಧಾನವನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳುವುದರಿಂದ ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಸಂಘಟಿತ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾಗಿದೆ. ಈ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸುವ ವಿಧಾನಗಳ ಜೊತೆಗೆ ವಸ್ತುಗಳಲ್ಲಿನ ಸಂಬಂಧಿತ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಗುಂಪು ಮಾಡುವುದು ಸಾಮಾನ್ಯ ಮಾದರಿಯಾಗಿದೆ. ಆದಾಗ್ಯೂ, ಪುನರಾವರ್ತನೆಯ ಸಮಯದಲ್ಲಿ ವಿಧಾನಗಳು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಗುಣಲಕ್ಷಣಗಳೊಂದಿಗೆ ಮಧ್ಯಪ್ರವೇಶಿಸಿದಾಗ ಇದು ಆಗಾಗ್ಗೆ ಸವಾಲುಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ.

ಒಂದು ವಿಶಿಷ್ಟ ಉದಾಹರಣೆಯು ಬಳಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ Object.keys() ವಸ್ತುವಿನ ಗುಣಲಕ್ಷಣಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸಲು. ಈ ಪುನರಾವರ್ತನೆಯ ಸಮಯದಲ್ಲಿ ವಿಧಾನಗಳನ್ನು ಹೊರಗಿಡುವ ಅಗತ್ಯವನ್ನು ಡೆವಲಪರ್‌ಗಳು ಆಗಾಗ್ಗೆ ಎದುರಿಸುತ್ತಾರೆ. ಇದು ಕಾರ್ಯಗಳನ್ನು ಬಿಟ್ಟುಬಿಡಲು ಷರತ್ತುಬದ್ಧ ಷರತ್ತು ಸೇರಿಸುವ ಅಗತ್ಯವಿದೆ, ಇದು ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ತೊಡಕಾಗಿ ಮಾಡುತ್ತದೆ ಮತ್ತು ಸಂಕೀರ್ಣ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ನಿರ್ವಹಿಸಲು ಕಷ್ಟವಾಗುತ್ತದೆ.

ನೆಸ್ಟೆಡ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಒಳಗೆ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಗುಂಪು ಮಾಡುವುದು, ಅವುಗಳನ್ನು ವಿಧಾನಗಳಿಂದ ಪ್ರತ್ಯೇಕಿಸುವುದು ಒಂದು ಪರ್ಯಾಯವಾಗಿದೆ. ಇದು ಅನಪೇಕ್ಷಿತ ಸಂವಹನಗಳನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಇದು ಮೂಲಕ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಪ್ರವೇಶಿಸುವಂತಹ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಉಲ್ಲೇಖವನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ myObj.props.prop1 ಬದಲಿಗೆ myObj.prop1. ಕೋಡ್ ಓದುವಿಕೆ ಮತ್ತು ಕ್ರಿಯಾತ್ಮಕತೆಯ ನಡುವಿನ ಈ ವ್ಯಾಪಾರವು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಆಸಕ್ತಿದಾಯಕ ಸಂದಿಗ್ಧತೆಯನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ.

ಈ ಲೇಖನದಲ್ಲಿ, ಕೋಡ್ ಅನ್ನು ಸೊಗಸಾದ ಮತ್ತು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಇರಿಸಿಕೊಂಡು ಈ ಸವಾಲುಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಪ್ರಾಯೋಗಿಕ ವಿಧಾನಗಳನ್ನು ನಾವು ಅನ್ವೇಷಿಸುತ್ತೇವೆ. ಷರತ್ತುಗಳ ಮೇಲೆ ಹೆಚ್ಚು ಅವಲಂಬಿಸದೆ ವಸ್ತು ಗುಣಲಕ್ಷಣಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸಲು ನಾವು ವಿಭಿನ್ನ ತಂತ್ರಗಳನ್ನು ನೋಡುತ್ತೇವೆ. ಕೊನೆಯಲ್ಲಿ, ಅನಗತ್ಯ ಸಂಕೀರ್ಣತೆಗಳನ್ನು ತಪ್ಪಿಸುವ ಹೆಚ್ಚು ವಸ್ತು-ಆಧಾರಿತ ಶೈಲಿಯಲ್ಲಿ ವಸ್ತುಗಳನ್ನು ರಚಿಸುವ ಒಳನೋಟಗಳನ್ನು ನೀವು ಪಡೆಯುತ್ತೀರಿ.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಆಬ್ಜೆಕ್ಟ್ ಪ್ರಾಪರ್ಟೀಸ್ ಅನ್ನು ಪುನರಾವರ್ತನೆ ಮಾಡಲು ಪರಿಹಾರಗಳನ್ನು ಅನ್ವೇಷಿಸುವುದು

ನಾವು ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವ ಗುರಿಯನ್ನು ಹೊಂದಿವೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್: ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಮಾರ್ಪಡಿಸದೆ ಅಥವಾ ವಿಧಾನಗಳೊಂದಿಗೆ ಸಂವಹನ ಮಾಡದೆಯೇ ವಸ್ತುವಿನ ಗುಣಲಕ್ಷಣಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುವುದು ಹೇಗೆ. ಮೊದಲ ಪರಿಹಾರದಲ್ಲಿ, ನಾವು ಬಳಸುತ್ತೇವೆ Object.defineProperty ವಿಧಾನವನ್ನು ಎಣಿಸಲಾಗದಂತೆ ಮಾಡಲು. ನಾವು ಬಳಸುವ ವಸ್ತುವಿನ ಗುಣಲಕ್ಷಣಗಳ ಮೇಲೆ ಲೂಪ್ ಮಾಡಿದಾಗ ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ Object.keys(), ವಿಧಾನವನ್ನು ಪುನರಾವರ್ತನೆಯಿಂದ ಹೊರಗಿಡಲಾಗಿದೆ. ಈ ವಿಧಾನವು ನಮ್ಮ ಡೇಟಾದ ಸಮಗ್ರತೆಯನ್ನು ಸಂರಕ್ಷಿಸುತ್ತದೆ ಮತ್ತು ಲೂಪ್‌ನಲ್ಲಿ ಹೆಚ್ಚುವರಿ ಷರತ್ತುಬದ್ಧ ಪರಿಶೀಲನೆಗಳ ಅಗತ್ಯವನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.

ಮತ್ತೊಂದು ಪ್ರಮುಖ ಪರಿಹಾರವು ಬಳಕೆಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ ES6 ಚಿಹ್ನೆಗಳು. ಎಣಿಕೆ ಅಥವಾ ಪುನರಾವರ್ತನೆ ಪ್ರಕ್ರಿಯೆಗಳೊಂದಿಗೆ ಮಧ್ಯಪ್ರವೇಶಿಸದೆಯೇ ವಸ್ತುಗಳಿಗೆ ಗುಣಲಕ್ಷಣಗಳು ಅಥವಾ ವಿಧಾನಗಳನ್ನು ಸೇರಿಸಲು ಚಿಹ್ನೆಗಳು ಒಂದು ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತವೆ. ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ಸಿಂಬಲ್ ಕೀಗೆ ವಿಧಾನವನ್ನು ನಿಯೋಜಿಸುವುದರಿಂದ ಅದು ಮರೆಮಾಡಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ Object.entries(), ಆಬ್ಜೆಕ್ಟ್‌ನ ಕೀಗಳು ಮತ್ತು ಮೌಲ್ಯಗಳೆರಡರಲ್ಲೂ ನಾವು ಪುನರಾವರ್ತಿಸಲು ಬಳಸುತ್ತೇವೆ. ಕೆಲವು ಗುಣಲಕ್ಷಣಗಳು ಅಥವಾ ವಿಧಾನಗಳು ಪುನರಾವರ್ತನೆ ತರ್ಕಕ್ಕೆ ಅಗೋಚರವಾಗಿ ಉಳಿಯಬೇಕಾದರೆ ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಚಿಹ್ನೆಗಳು ಹೇಗೆ ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಬಹುದು ಎಂಬುದನ್ನು ಈ ತಂತ್ರವು ಎತ್ತಿ ತೋರಿಸುತ್ತದೆ.

ನಾವು a ನ ಬಳಕೆಯನ್ನು ಸಹ ಅನ್ವೇಷಿಸಿದ್ದೇವೆ ವರ್ಗ ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ವಿಧಾನಗಳನ್ನು ಹೆಚ್ಚು ಔಪಚಾರಿಕವಾಗಿ ಪ್ರತ್ಯೇಕಿಸಲು. ಈ ವಿಧಾನವು ಒಂದೇ ರಚನೆಯೊಳಗೆ ಡೇಟಾ (ಪ್ರಾಪರ್ಟೀಸ್) ಮತ್ತು ನಡವಳಿಕೆ (ವಿಧಾನಗಳು) ಎರಡನ್ನೂ ಆವರಿಸುವ ಮೂಲಕ ವಸ್ತು-ಆಧಾರಿತ ತತ್ವಗಳೊಂದಿಗೆ ಹೊಂದಾಣಿಕೆ ಮಾಡುತ್ತದೆ. ಈ ವಿಧಾನವು ವಸ್ತುವಿನ ಮರುಬಳಕೆ ಮತ್ತು ಮಾರ್ಪಾಡುಗಳನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ, ಮರು-ಬರೆಯುವ ಕೋಡ್ ಇಲ್ಲದೆಯೇ ಡೆವಲಪರ್‌ಗಳು ವರ್ಗದ ಅನೇಕ ನಿದರ್ಶನಗಳನ್ನು ರಚಿಸಲು ಅನುಮತಿಸುತ್ತದೆ. ಬಳಕೆ 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');
});

ಸುಧಾರಿತ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮಾದರಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಆಬ್ಜೆಕ್ಟ್ ಪುನರಾವರ್ತನೆ ಸವಾಲುಗಳನ್ನು ಪರಿಹರಿಸುವುದು

ನಿರ್ವಹಿಸಲು ಒಂದು ಆಸಕ್ತಿದಾಯಕ ಮಾರ್ಗ ವಸ್ತು-ಆಧಾರಿತ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸವಾಲುಗಳನ್ನು ಬಳಸುವುದು ಮೂಲಮಾದರಿಗಳು. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಮೂಲಮಾದರಿಗಳಿಗೆ ಲಿಂಕ್ ಮಾಡಲಾಗುತ್ತದೆ, ಇದು ಡೆವಲಪರ್‌ಗಳಿಗೆ ನಿದರ್ಶನಗಳಾದ್ಯಂತ ಹಂಚಿಕೆಯ ವಿಧಾನಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಮೂಲಮಾದರಿಯೊಳಗೆ ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ವಿಧಾನಗಳನ್ನು ಇರಿಸುವ ಮೂಲಕ, ಅವರು ಆಸ್ತಿ ಪುನರಾವರ್ತನೆಗೆ ಅಡ್ಡಿಯಾಗುವುದಿಲ್ಲ. ಬಳಸುವಾಗ ವಸ್ತುವಿಗೆ ನೇರವಾಗಿ ಲಗತ್ತಿಸಲಾದ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಮಾತ್ರ ಮಾರ್ಪಡಿಸಲಾಗಿದೆ ಎಂದು ಈ ತಂತ್ರವು ಖಚಿತಪಡಿಸುತ್ತದೆ Object.keys() ಅಥವಾ Object.entries(). ಹೆಚ್ಚುವರಿಯಾಗಿ, ಮೂಲಮಾದರಿಗಳು ಕೋಡ್ ಮರುಬಳಕೆ ಮತ್ತು ಉತ್ತಮ ಮೆಮೊರಿ ನಿರ್ವಹಣೆಯನ್ನು ಪ್ರೋತ್ಸಾಹಿಸುತ್ತವೆ.

ಮತ್ತೊಂದು ಶಕ್ತಿಯುತ ವಿಧಾನವೆಂದರೆ ಹತೋಟಿ getter ಮತ್ತು setter ಕಾರ್ಯಗಳು. ಗೆಟರ್‌ಗಳು ಮತ್ತು ಸೆಟ್ಟರ್‌ಗಳು ಗುಣಲಕ್ಷಣಗಳೊಂದಿಗೆ ಪರೋಕ್ಷವಾಗಿ ಸಂವಹನ ನಡೆಸಲು ಒಂದು ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತವೆ, ಪುನರಾವರ್ತನೆಯ ಸಮಯದಲ್ಲಿ ಅಥವಾ ಪ್ರವೇಶಿಸಿದಾಗ ಅವರ ನಡವಳಿಕೆಯನ್ನು ನಿಯಂತ್ರಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಈ ಮಾದರಿಯೊಂದಿಗೆ, ಡೆವಲಪರ್‌ಗಳು ಮೀಸಲಾದ ಕಾರ್ಯಗಳ ಮೂಲಕ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಮಾರ್ಪಡಿಸಲು ನಮ್ಯತೆಯನ್ನು ನೀಡುವಾಗ ವಿಧಾನಗಳ ಉದ್ದೇಶವಿಲ್ಲದ ಮಾರ್ಪಾಡುಗಳನ್ನು ತಡೆಯಬಹುದು. ಈ ಪರಿಹಾರವು ಬಳಕೆದಾರರಿಗೆ ಕ್ಲೀನ್ API ಅನ್ನು ನಿರ್ವಹಿಸುವಾಗ ಆಬ್ಜೆಕ್ಟ್ ಗುಣಲಕ್ಷಣಗಳು ಸುತ್ತುವರಿದಿರುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಕೊನೆಯದಾಗಿ, ಡೆವಲಪರ್‌ಗಳು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಬಹುದು Object.freeze() ಅಥವಾ Object.seal() ವಸ್ತುವಿನ ರೂಪಾಂತರವನ್ನು ನಿರ್ವಹಿಸಲು. Object.freeze() ಒಂದು ವಸ್ತುವನ್ನು ಬದಲಾಗದಂತೆ ಮಾಡುತ್ತದೆ, ಅದರ ಗುಣಲಕ್ಷಣಗಳಿಗೆ ಯಾವುದೇ ಬದಲಾವಣೆಗಳನ್ನು ತಡೆಯುತ್ತದೆ, ಆಕಸ್ಮಿಕ ಮಾರ್ಪಾಡುಗಳಿಲ್ಲದೆ ನೀವು ಡೇಟಾವನ್ನು ಓದಲು ಬಯಸುವ ಸಂದರ್ಭಗಳಲ್ಲಿ ಇದು ಉಪಯುಕ್ತವಾಗಿರುತ್ತದೆ. ಮತ್ತೊಂದೆಡೆ, Object.seal() ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಗುಣಲಕ್ಷಣಗಳನ್ನು ನವೀಕರಿಸಲು ಅನುಮತಿಸುತ್ತದೆ ಆದರೆ ಹೊಸದನ್ನು ಸೇರಿಸುವುದನ್ನು ತಡೆಯುತ್ತದೆ. ಈ ಮಾದರಿಗಳು ಕೋಡ್ ಸಮಗ್ರತೆಯನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುವುದಲ್ಲದೆ ವಸ್ತು ನಡವಳಿಕೆಗಳ ಮೇಲೆ ಕಟ್ಟುನಿಟ್ಟಾದ ನಿಯಂತ್ರಣವನ್ನು ಜಾರಿಗೊಳಿಸುತ್ತದೆ, ಪುನರಾವರ್ತನೆಯನ್ನು ಸುರಕ್ಷಿತ ಮತ್ತು ಹೆಚ್ಚು ಊಹಿಸಬಹುದಾದಂತೆ ಮಾಡುತ್ತದೆ.