ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ದೇಶದ ಮೂಲಕ ನೆಸ್ಟೆಡ್ ಅರೇ ಅನ್ನು ವಿಂಗಡಿಸುವುದು

ಮಾಸ್ಟರಿಂಗ್ ಅರೇ ವಿಂಗಡಣೆ: ದೇಶದ ಪ್ರಕಾರ ನಗರಗಳನ್ನು ಗುಂಪು ಮಾಡುವುದು

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

ನೀವು ದೇಶದ ಹೆಸರುಗಳು, ನಗರದ ಹೆಸರುಗಳು ಮತ್ತು ಅನುಗುಣವಾದ ದಿನಾಂಕಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿರುವಿರಿ ಎಂದು ಊಹಿಸಿ ಮತ್ತು ಆಯಾ ದೇಶದ ಅಡಿಯಲ್ಲಿ ಪ್ರತಿ ನಗರದ ಡೇಟಾವನ್ನು ಗುಂಪು ಮಾಡುವಾಗ ನೀವು ಈ ಶ್ರೇಣಿಯನ್ನು ದೇಶದಿಂದ ವಿಂಗಡಿಸಲು ಬಯಸುತ್ತೀರಿ. ಸ್ಪಷ್ಟವಾದ ಪ್ರಸ್ತುತಿಗಾಗಿ ಸಂಘಟಿಸಬೇಕಾದ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಇದು ಉಪಯುಕ್ತ ಕೌಶಲ್ಯವಾಗಿದೆ.

ಇದನ್ನು ಸಾಧಿಸಲು, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೇಟಾವನ್ನು ಸುಲಭವಾಗಿ ವಿಂಗಡಿಸಲು ಮತ್ತು ಪುನರ್ರಚಿಸಲು ಅನುಮತಿಸುವ ಹಲವಾರು ವಿಧಾನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ನೀವು ಕಾರ್ಯಗಳನ್ನು ಬಳಸಬಹುದು ವಿಂಗಡಿಸು() ಮತ್ತು ಕಡಿಮೆ () ಅಂಶಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಗುಂಪು ಮಾಡಲು, ಡೇಟಾ ಅರೇಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಸ್ಪಷ್ಟ ಮತ್ತು ಸಂಕ್ಷಿಪ್ತ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಈ ಟ್ಯುಟೋರಿಯಲ್ ದೇಶ ಅಥವಾ ನಗರದ ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡುವುದು ಅಥವಾ ದಿನಾಂಕ ಶ್ರೇಣಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವಂತಹ ವಿವಿಧ ಬಳಕೆದಾರ ಸಂವಹನಗಳಿಗೆ ಅಳವಡಿಸಿಕೊಳ್ಳಬಹುದಾದ, ನೆಸ್ಟೆಡ್ ಅರೇ ಅನ್ನು ದೇಶದ ಮೂಲಕ ವಿಂಗಡಿಸಲು ಮತ್ತು ಗುಂಪು ಮಾಡಲು ಸರಳವಾದ ವಿಧಾನದ ಮೂಲಕ ನಿಮಗೆ ಮಾರ್ಗದರ್ಶನ ನೀಡುತ್ತದೆ. ಹಂತಗಳಲ್ಲಿ ಧುಮುಕೋಣ!

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಅರೇಗಳ ಸಮರ್ಥ ವಿಂಗಡಣೆ ಮತ್ತು ಗುಂಪುಗಾರಿಕೆ

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

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

ಗುಂಪು ಮಾಡಿದ ನಂತರ, ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತದೆ Object.entries() ಫಲಿತಾಂಶದ ವಸ್ತುವನ್ನು ಮತ್ತೆ ಸರಣಿಯಾಗಿ ಪರಿವರ್ತಿಸುವ ವಿಧಾನ. ಈ ರೂಪಾಂತರವು ಅವಶ್ಯಕವಾಗಿದೆ ಏಕೆಂದರೆ ವಸ್ತುಗಳು ಸುಲಭವಾಗಿ ಕುಶಲತೆಯಿಂದ ಅಥವಾ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಅರೇಗಳಂತೆ ನಿರೂಪಿಸಲ್ಪಟ್ಟಿಲ್ಲ. ಡೇಟಾವನ್ನು ಮತ್ತೆ ರಚನೆಯ ಸ್ವರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸುವ ಮೂಲಕ, ನಾವು ಅದರ ಮೇಲೆ ಪುನರಾವರ್ತಿಸಬಹುದು ಅಥವಾ ಅದನ್ನು ಮನಬಂದಂತೆ ಇತರ ಕಾರ್ಯಗಳಿಗೆ ರವಾನಿಸಬಹುದು. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ಅನೇಕ ಕಾರ್ಯಗಳಿಗೆ ಅರೇಗಳ ಬಳಕೆಯನ್ನು ಆದ್ಯತೆ ನೀಡಲಾಗುತ್ತದೆ ಏಕೆಂದರೆ ಹೆಚ್ಚಿನ ಕಾರ್ಯಗಳೊಂದಿಗೆ ಅವುಗಳ ಹೊಂದಾಣಿಕೆ ಮತ್ತು ಪ್ರಯಾಣದ ಸುಲಭತೆ.

ಅಂತಿಮ ಹಂತಗಳಲ್ಲಿ, ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಕ್ರಿಯಾತ್ಮಕತೆಗಾಗಿ ಪರೀಕ್ಷಿಸಲಾಗುತ್ತದೆ. ಬ್ಯಾಕ್-ಎಂಡ್ ಪರಿಹಾರಕ್ಕಾಗಿ Node.js, ವಿಂಗಡಣೆ ಮತ್ತು ಗುಂಪು ಮಾಡುವ ಕಾರ್ಯಗಳ ಸರಿಯಾದತೆಯನ್ನು ಮೌಲ್ಯೀಕರಿಸಲು ನಾವು ಜೆಸ್ಟ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಯುನಿಟ್ ಪರೀಕ್ಷೆಗಳನ್ನು ಬಳಸುತ್ತೇವೆ. ಪರೀಕ್ಷೆಗಳು ನಗರಗಳನ್ನು ತಮ್ಮ ದೇಶಗಳ ಅಡಿಯಲ್ಲಿ ಸರಿಯಾಗಿ ಗುಂಪು ಮಾಡಲಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಔಟ್‌ಪುಟ್ ಸ್ವರೂಪವು ನಿರೀಕ್ಷಿತ ರಚನೆಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಸರ್ವರ್‌ನಲ್ಲಿ ಅಥವಾ ಬ್ರೌಸರ್‌ನಲ್ಲಿ ಪರಿಹಾರವು ಬಹು ಪರಿಸರದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಖಾತರಿಪಡಿಸಲು ಪರೀಕ್ಷೆಗೆ ಈ ಗಮನವು ಮುಖ್ಯವಾಗಿದೆ. ಸಂಯೋಜನೆಯ ಮೂಲಕ ಸಮರ್ಥ ರಚನೆಯ ವಿಧಾನಗಳು ಮತ್ತು ಸರಿಯಾದ ಪರೀಕ್ಷೆ, ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಸಂಕೀರ್ಣ ಡೇಟಾವನ್ನು ವಿಂಗಡಿಸುವ ಮತ್ತು ಗುಂಪು ಮಾಡುವ ಸಮಸ್ಯೆಗೆ ವಿಶ್ವಾಸಾರ್ಹ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಪರಿಹಾರವನ್ನು ಒದಗಿಸುತ್ತವೆ.

// Original array of country, city, and date data
const data = [
  ['Spain', 'Madrid', '10-12-2024'],
  ['Spain', 'Barcelona', '10-15-2024'],
  ['Suisse', 'Berne', '10-18-2024'],
  ['France', 'Paris', '10-22-2024'],
  ['France', 'Lyon', '10-24-2024']
];

// Step 1: Sort the array by country name (first item)
data.sort((a, b) => a[0].localeCompare(b[0]));

// Step 2: Group cities by their respective countries using reduce
const groupedData = data.reduce((result, item) => {
  const [country, city, date] = item;
  if (!result[country]) {
    result[country] = [];
  }
  result[country].push([city, date]);
  return result;
}, {});

// Step 3: Convert the grouped object back into an array format
const orderedArray = Object.entries(groupedData);
console.log(orderedArray);

const data = [
  ['Spain', 'Madrid', '10-12-2024'],
  ['Suisse', 'Berne', '10-18-2024'],
  ['France', 'Paris', '10-22-2024'],
  ['France', 'Lyon', '10-24-2024'],
  ['Spain', 'Barcelona', '10-15-2024']
];

// Step 1: Sort data by country (first column)
const sortedData = data.sort((a, b) => a[0].localeCompare(b[0]));

// Step 2: Group data by country using map and reduce functions
const groupedData = sortedData.reduce((acc, current) => {
  const [country, city, date] = current;
  if (!acc[country]) {
    acc[country] = [];
  }
  acc[country].push([city, date]);
  return acc;
}, {});

// Step 3: Return the formatted array
const resultArray = Object.entries(groupedData);
console.log(resultArray);

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

test('Should correctly group cities by country', () => {
  const data = [
    ['Spain', 'Madrid', '10-12-2024'],
    ['France', 'Paris', '10-22-2024']
  ];
  const groupedData = sortAndGroup(data);
  expect(groupedData).toEqual([
    ['Spain', [['Madrid', '10-12-2024']]],
    ['France', [['Paris', '10-22-2024']]]
  ]);
});

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಅರೇಗಳನ್ನು ವಿಂಗಡಿಸಲು ಸುಧಾರಿತ ತಂತ್ರಗಳು

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

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

ಪರಿಗಣಿಸಬೇಕಾದ ಇನ್ನೊಂದು ಅಂಶವೆಂದರೆ ಬಳಕೆ ಡೇಟಾ ಮೌಲ್ಯೀಕರಣ ರಚನೆಯನ್ನು ವಿಂಗಡಿಸುವ ಮೊದಲು. ಈ ಹಂತವು ಯಾವುದೇ ಭ್ರಷ್ಟ ಅಥವಾ ಅಮಾನ್ಯವಾದ ಡೇಟಾ ರಚನೆಯೊಳಗೆ ಬರುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಬಳಕೆದಾರರು ಆಕಸ್ಮಿಕವಾಗಿ ಅಮಾನ್ಯ ದಿನಾಂಕವನ್ನು ನಮೂದಿಸಿದರೆ ಅಥವಾ ನಗರದ ಹೆಸರನ್ನು ಖಾಲಿ ಬಿಟ್ಟರೆ, ಡೇಟಾ ಮೌಲ್ಯೀಕರಣ ಪ್ರಕ್ರಿಯೆಯು ದೋಷವನ್ನು ಫ್ಲ್ಯಾಗ್ ಮಾಡಬಹುದು ಅಥವಾ ವಿಂಗಡಿಸುವ ತರ್ಕವನ್ನು ಅನ್ವಯಿಸುವ ಮೊದಲು ಅಮಾನ್ಯ ನಮೂದುಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಫಿಲ್ಟರ್ ಮಾಡಬಹುದು. ಸಿಸ್ಟಮ್ನ ಡೇಟಾದ ಸಮಗ್ರತೆ ಮತ್ತು ನಿಖರತೆಯನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳಲು ಈ ಹಂತವು ಮುಖ್ಯವಾಗಿದೆ.