ಹೆಚ್ಚಿನ ಟ್ಯುಟೋರಿಯಲ್‌ಗಳು ಮಿಸ್ ಆಗಿರುವ 12 ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಟ್ರಿಕ್ಸ್

ನಾನು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕಲಿಯಲು ಪ್ರಾರಂಭಿಸಿದಾಗ, ನಾನು ಮಾಡಿದ ಮೊದಲ ಕೆಲಸವೆಂದರೆ ಸಮಯವನ್ನು ಉಳಿಸಲು ಸಹಾಯ ಮಾಡುವ ತಂತ್ರಗಳ ಪಟ್ಟಿಯನ್ನು ಮಾಡುವುದು. ನಾನು ಅವುಗಳನ್ನು ಇತರ ಪ್ರೋಗ್ರಾಮರ್‌ಗಳಿಂದ, ವಿವಿಧ ಸೈಟ್‌ಗಳಲ್ಲಿ ಮತ್ತು ಕೈಪಿಡಿಗಳಲ್ಲಿ ಗುರುತಿಸಿದೆ.

ಈ ಲೇಖನದಲ್ಲಿ, ನಿಮ್ಮ JavaScript ಕೋಡ್ ಅನ್ನು ಸುಧಾರಿಸಲು ಮತ್ತು ವೇಗಗೊಳಿಸಲು 12 ಉತ್ತಮ ಮಾರ್ಗಗಳನ್ನು ನಾನು ನಿಮಗೆ ತೋರಿಸುತ್ತೇನೆ. ಹೆಚ್ಚಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ ಅವು ಸಾರ್ವತ್ರಿಕವಾಗಿವೆ.

ನಾವು ನೆನಪಿಸುತ್ತೇವೆ: ಎಲ್ಲಾ Habr ಓದುಗರಿಗೆ - Habr ಪ್ರೊಮೊ ಕೋಡ್ ಬಳಸಿಕೊಂಡು ಯಾವುದೇ ಸ್ಕಿಲ್‌ಬಾಕ್ಸ್ ಕೋರ್ಸ್‌ಗೆ ದಾಖಲಾಗುವಾಗ 10 ರೂಬಲ್ ರಿಯಾಯಿತಿ.

ಸ್ಕಿಲ್‌ಬಾಕ್ಸ್ ಶಿಫಾರಸು ಮಾಡುತ್ತದೆ: ಪ್ರಾಯೋಗಿಕ ಕೋರ್ಸ್ "ಮೊಬೈಲ್ ಡೆವಲಪರ್ ಪ್ರೊ".

ಅನನ್ಯ ಮೌಲ್ಯಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲಾಗುತ್ತಿದೆ

ಅರೇಗಳು

ಸೆಟ್ ಆಬ್ಜೆಕ್ಟ್ ಪ್ರಕಾರವನ್ನು ES6 ನಲ್ಲಿ ಪರಿಚಯಿಸಲಾಗಿದೆ, ಜೊತೆಗೆ..., ಸ್ಪ್ರೆಡ್ ಆಪರೇಟರ್, ನಾವು ಅನನ್ಯ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುವ ಹೊಸ ಶ್ರೇಣಿಯನ್ನು ರಚಿಸಲು ಇದನ್ನು ಬಳಸಬಹುದು.

const array = [1, 1, 2, 3, 5, 5, 1]
const uniqueArray = [...new Set(array)];
 
console.log(uniqueArray); // Result: [1, 2, 3, 5]

ಸಾಮಾನ್ಯ ಪರಿಸ್ಥಿತಿಯಲ್ಲಿ, ಅದೇ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ನಿರ್ವಹಿಸಲು ಹೆಚ್ಚಿನ ಕೋಡ್ ಅಗತ್ಯವಿದೆ.

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

ಚಕ್ರಗಳಲ್ಲಿ ಸಂಗ್ರಹ ರಚನೆಯ ಉದ್ದ

ಸೈಕಲ್‌ಗಳು

ನೀವು ಲೂಪ್‌ಗಳಿಗಾಗಿ ಕಲಿಯುವಾಗ, ನೀವು ಪ್ರಮಾಣಿತ ವಿಧಾನವನ್ನು ಅನುಸರಿಸುತ್ತೀರಿ:

for (let i = 0; i < array.length; i++){
  console.log(i);
}

ಆದಾಗ್ಯೂ, ಈ ಸಿಂಟ್ಯಾಕ್ಸ್‌ನೊಂದಿಗೆ, ಫಾರ್ ಲೂಪ್ ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯ ರಚನೆಯ ಉದ್ದವನ್ನು ಪದೇ ಪದೇ ಪರಿಶೀಲಿಸುತ್ತದೆ.

ಕೆಲವೊಮ್ಮೆ ಇದು ಉಪಯುಕ್ತವಾಗಬಹುದು, ಆದರೆ ಹೆಚ್ಚಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ ಇದು ರಚನೆಯ ಉದ್ದವನ್ನು ಸಂಗ್ರಹಿಸಲು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿರುತ್ತದೆ, ಇದಕ್ಕೆ ಒಂದು ಪ್ರವೇಶದ ಅಗತ್ಯವಿರುತ್ತದೆ. ಉದ್ದದ ವೇರಿಯೇಬಲ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೂಲಕ ನಾವು ಇದನ್ನು ಮಾಡಬಹುದು, ಅಲ್ಲಿ ನಾವು ವೇರಿಯಬಲ್ i ಅನ್ನು ಈ ರೀತಿ ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ:

for (let i = 0, length = array.length; i < length; i++){
  console.log(i);
}

ತಾತ್ವಿಕವಾಗಿ, ಮೇಲಿನಂತೆಯೇ ಬಹುತೇಕ ಒಂದೇ, ಆದರೆ ಲೂಪ್ ಗಾತ್ರವನ್ನು ಹೆಚ್ಚಿಸುವ ಮೂಲಕ ನಾವು ಗಮನಾರ್ಹ ಸಮಯ ಉಳಿತಾಯವನ್ನು ಪಡೆಯುತ್ತೇವೆ.

ಶಾರ್ಟ್ ಸರ್ಕ್ಯೂಟ್ ರೇಟಿಂಗ್ (ಮೆಕಾರ್ಥಿ ರೇಟಿಂಗ್)

ಷರತ್ತುಬದ್ಧ ನಿರ್ವಾಹಕರು

ತ್ರಯಾತ್ಮಕ ಆಪರೇಟರ್ ಸರಳವಾದ (ಮತ್ತು ಕೆಲವೊಮ್ಮೆ ಅಷ್ಟು ಸರಳವಲ್ಲ) ಷರತ್ತುಬದ್ಧ ಹೇಳಿಕೆಗಳನ್ನು ಬರೆಯಲು ವೇಗವಾದ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಮಾರ್ಗವಾಗಿದೆ:

x> 100? "100 ಕ್ಕಿಂತ ಹೆಚ್ಚು": "100 ಕ್ಕಿಂತ ಕಡಿಮೆ";
x> 100? (x>200? "200 ಕ್ಕಿಂತ ಹೆಚ್ಚು": "100-200 ನಡುವೆ"): "100 ಕ್ಕಿಂತ ಕಡಿಮೆ";

ಆದರೆ ಕೆಲವೊಮ್ಮೆ ತ್ರಯಾತ್ಮಕ ಆಪರೇಟರ್ ಕೂಡ ಅಗತ್ಯಕ್ಕಿಂತ ಹೆಚ್ಚು ಜಟಿಲವಾಗಿದೆ. ನಾವು 'ಮತ್ತು' && ಮತ್ತು 'ಅಥವಾ' ಬದಲಿಗೆ || ಕೆಲವು ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಇನ್ನೂ ಹೆಚ್ಚು ಸಂಕ್ಷಿಪ್ತ ರೀತಿಯಲ್ಲಿ ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು ಬೂಲಿಯನ್ ಆಪರೇಟರ್‌ಗಳು. ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ "ಶಾರ್ಟ್ ಸರ್ಕ್ಯೂಟ್" ಅಥವಾ "ಶಾರ್ಟ್ ಸರ್ಕ್ಯೂಟ್ ರೇಟಿಂಗ್" ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.

ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ

ನಾವು ಎರಡು ಅಥವಾ ಹೆಚ್ಚಿನ ಷರತ್ತುಗಳಲ್ಲಿ ಒಂದನ್ನು ಮಾತ್ರ ಹಿಂತಿರುಗಿಸಲು ಬಯಸುತ್ತೇವೆ ಎಂದು ಹೇಳೋಣ.

&& ಬಳಸುವುದರಿಂದ ಮೊದಲ ತಪ್ಪು ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಪ್ರತಿ ಆಪರೇಂಡ್ ಸರಿ ಎಂದು ಮೌಲ್ಯಮಾಪನ ಮಾಡಿದರೆ, ನಂತರ ಮೌಲ್ಯಮಾಪನ ಮಾಡಿದ ಕೊನೆಯ ಅಭಿವ್ಯಕ್ತಿಯನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ.

let one = 1, two = 2, three = 3;
console.log(one && two && three); // Result: 3
 
console.log(0 && null); // Result: 0

ಬಳಸಿ || ಮೊದಲ ನಿಜವಾದ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಪ್ರತಿ ಆಪರೇಂಡ್ ತಪ್ಪು ಎಂದು ಮೌಲ್ಯಮಾಪನ ಮಾಡಿದರೆ, ಕೊನೆಯ ಮೌಲ್ಯಮಾಪನ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ.

let one = 1, two = 2, three = 3;
console.log(one || two || three); // Result: 1
 
console.log(0 || null); // Result: null

ಉದಾಹರಣೆಗೆ 1

ನಾವು ವೇರಿಯಬಲ್‌ನ ಉದ್ದವನ್ನು ಹಿಂತಿರುಗಿಸಲು ಬಯಸುತ್ತೇವೆ ಎಂದು ಹೇಳೋಣ, ಆದರೆ ಅದರ ಪ್ರಕಾರ ನಮಗೆ ತಿಳಿದಿಲ್ಲ.

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಫೂ ಸರಿಯಾದ ಪ್ರಕಾರವಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲು ನೀವು if/else ಅನ್ನು ಬಳಸಬಹುದು, ಆದರೆ ಈ ವಿಧಾನವು ತುಂಬಾ ಉದ್ದವಾಗಿರಬಹುದು. ಆದ್ದರಿಂದ, ನಮ್ಮ "ಶಾರ್ಟ್ ಸರ್ಕ್ಯೂಟ್" ತೆಗೆದುಕೊಳ್ಳುವುದು ಉತ್ತಮ.

return (foo || []).length;

ವೇರಿಯೇಬಲ್ ಫೂ ಸೂಕ್ತವಾದ ಉದ್ದವನ್ನು ಹೊಂದಿದ್ದರೆ, ಅದನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ. ಇಲ್ಲದಿದ್ದರೆ ನಾವು 0 ಅನ್ನು ಪಡೆಯುತ್ತೇವೆ.

ಉದಾಹರಣೆಗೆ 2

ನೆಸ್ಟೆಡ್ ವಸ್ತುವನ್ನು ಪ್ರವೇಶಿಸುವಲ್ಲಿ ನೀವು ಸಮಸ್ಯೆಗಳನ್ನು ಹೊಂದಿದ್ದೀರಾ? ಒಂದು ವಸ್ತು ಅಥವಾ ಅದರ ಉಪಗುಣಗಳಲ್ಲಿ ಯಾವುದಾದರೂ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿಲ್ಲದಿರಬಹುದು ಮತ್ತು ಇದು ಸಮಸ್ಯೆಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.

ಉದಾಹರಣೆಗೆ, ನಾವು this.state ನಲ್ಲಿ ಡೇಟಾ ಆಸ್ತಿಯನ್ನು ಪ್ರವೇಶಿಸಲು ಬಯಸಿದ್ದೇವೆ, ಆದರೆ ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಪಡೆಯುವ ವಿನಂತಿಯನ್ನು ಹಿಂದಿರುಗಿಸುವವರೆಗೆ ಡೇಟಾವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗುವುದಿಲ್ಲ.

ನಾವು ಅದನ್ನು ಎಲ್ಲಿ ಬಳಸುತ್ತೇವೆ ಎಂಬುದರ ಆಧಾರದ ಮೇಲೆ, this.state.data ಗೆ ಕರೆ ಮಾಡುವುದರಿಂದ ಅಪ್ಲಿಕೇಶನ್ ಪ್ರಾರಂಭವಾಗುವುದನ್ನು ತಡೆಯಬಹುದು. ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು, ನಾವು ಇದನ್ನು ಷರತ್ತುಬದ್ಧ ಅಭಿವ್ಯಕ್ತಿಯಲ್ಲಿ ಕಟ್ಟಬಹುದು:

if (this.state.data) {
  return this.state.data;
} else {
  return 'Fetching Data';
}

"ಅಥವಾ" ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸುವುದು ಉತ್ತಮ ಆಯ್ಕೆಯಾಗಿದೆ.

return (this.state.data || 'Fetching Data');

&& ಬಳಸಲು ನಾವು ಮೇಲಿನ ಕೋಡ್ ಅನ್ನು ಬದಲಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. 'ದತ್ತಾಂಶವನ್ನು ಪಡೆಯುವುದು' && this.state.data ಆಪರೇಟರ್ ಈ.state.data ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸದಿದ್ದರೂ ಅಥವಾ ಇಲ್ಲದಿದ್ದರೂ ಅದನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ಐಚ್ಛಿಕ ಸರಣಿ

ಮರದ ರಚನೆಯಲ್ಲಿ ಆಸ್ತಿಯನ್ನು ಆಳವಾಗಿ ಹಿಂದಿರುಗಿಸಲು ಪ್ರಯತ್ನಿಸುವಾಗ ಐಚ್ಛಿಕ ಸರಪಳಿಯನ್ನು ಬಳಸಲು ಒಬ್ಬರು ಸಲಹೆ ನೀಡಬಹುದು. ಹಾಗಾದರೆ, ಪ್ರಶ್ನಾರ್ಥಕ ಚಿಹ್ನೆ? ಆಸ್ತಿಯನ್ನು ಹಿಂಪಡೆಯಲು ಬಳಸಬಹುದು, ಅದು ಶೂನ್ಯವಾಗಿಲ್ಲದಿದ್ದರೆ ಮಾತ್ರ.

ಉದಾಹರಣೆಗೆ, this.state.data?..() ಅನ್ನು ಪಡೆಯಲು ನಾವು ಮೇಲಿನ ಉದಾಹರಣೆಯನ್ನು ಮರುಪರಿಶೀಲಿಸಬಹುದು. ಅಂದರೆ, ಮೌಲ್ಯವು ಶೂನ್ಯವಾಗಿಲ್ಲದಿದ್ದರೆ ಮಾತ್ರ ಡೇಟಾವನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ.

ಅಥವಾ, ರಾಜ್ಯವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದು ಮುಖ್ಯವಾದರೆ, ನಾವು this.state?.data ಅನ್ನು ಹಿಂತಿರುಗಿಸಬಹುದು.

ಬೂಲಿಯನ್‌ಗೆ ಪರಿವರ್ತಿಸಿ

ಕೌಟುಂಬಿಕತೆ ಪರಿವರ್ತನೆ

ಸಾಮಾನ್ಯ ಬೂಲಿಯನ್ ಕಾರ್ಯಗಳು ಸರಿ ಮತ್ತು ತಪ್ಪು ಜೊತೆಗೆ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಎಲ್ಲಾ ಇತರ ಮೌಲ್ಯಗಳನ್ನು ಸತ್ಯ ಅಥವಾ ತಪ್ಪು ಎಂದು ಪರಿಗಣಿಸುತ್ತದೆ.

ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಗಮನಿಸುವವರೆಗೆ, 0, "", ಶೂನ್ಯ, ವ್ಯಾಖ್ಯಾನಿಸದ, NaN ಮತ್ತು ಸಹಜವಾಗಿ ತಪ್ಪು ಹೊರತುಪಡಿಸಿ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ಎಲ್ಲಾ ಮೌಲ್ಯಗಳು ಸತ್ಯವಾಗಿರುತ್ತವೆ. ಎರಡನೆಯದು ಸುಳ್ಳು.

! ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ಎರಡರ ನಡುವೆ ಸುಲಭವಾಗಿ ಬದಲಾಯಿಸಬಹುದು, ಇದು ಪ್ರಕಾರವನ್ನು ಬೂಲಿಯನ್ ಆಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ.

const isTrue  = !0;
const isFalse = !1;
const alsoFalse = !!0;
 
console.log(true); // Result: true
console.log(typeof true); // Result: "boolean"

ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಪರಿವರ್ತಿಸಿ

ಕೌಟುಂಬಿಕತೆ ಪರಿವರ್ತನೆ

ಪೂರ್ಣಾಂಕದಿಂದ ಸ್ಟ್ರಿಂಗ್‌ಗೆ ತ್ವರಿತ ಪರಿವರ್ತನೆಯನ್ನು ಈ ಕೆಳಗಿನಂತೆ ಮಾಡಬಹುದು.

const val = 1 + "";
 
console.log(val); // Result: "1"
console.log(typeof val); // Result: "string"

ಪೂರ್ಣಾಂಕಕ್ಕೆ ಪರಿವರ್ತಿಸಿ

ಕೌಟುಂಬಿಕತೆ ಪರಿವರ್ತನೆ

ನಾವು ರಿವರ್ಸ್ ರೂಪಾಂತರವನ್ನು ಈ ರೀತಿ ನಿರ್ವಹಿಸುತ್ತೇವೆ.

let int = "15";
int = +int;
 
console.log(int); // Result: 15
console.log(typeof int); Result: "number"

ಕೆಳಗೆ ತೋರಿಸಿರುವಂತೆ ಬೂಲಿಯನ್ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಸಾಮಾನ್ಯ ಸಂಖ್ಯಾ ಮೌಲ್ಯಗಳಿಗೆ ಪರಿವರ್ತಿಸಲು ಈ ವಿಧಾನವನ್ನು ಸಹ ಬಳಸಬಹುದು:

console.log(+true);  // Return: 1
console.log(+false); // Return: 0

ಸಂಕಲನ ಆಪರೇಟರ್ ಬದಲಿಗೆ + ಅನ್ನು ಸಂಯೋಜಕ ಆಪರೇಟರ್ ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸುವ ಸಂದರ್ಭಗಳು ಇರಬಹುದು. ಇದನ್ನು ತಪ್ಪಿಸಲು, ನೀವು ಟಿಲ್ಡೆಗಳನ್ನು ಬಳಸಬೇಕು: ~~. ಈ ಆಪರೇಟರ್ -n-1 ಗೆ ಸಮನಾಗಿರುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ~15 -16 ಗೆ ಸಮಾನವಾಗಿರುತ್ತದೆ.

ಸತತವಾಗಿ ಎರಡು ಟಿಲ್ಡ್‌ಗಳನ್ನು ಬಳಸುವುದು ಕಾರ್ಯಾಚರಣೆಯನ್ನು ನಿರಾಕರಿಸುತ್ತದೆ ಏಕೆಂದರೆ - (- - n - 1) - 1 = n + 1 - 1 = n. ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ~-16 15 ಕ್ಕೆ ಸಮಾನವಾಗಿರುತ್ತದೆ.

const int = ~~"15"
console.log(int); // Result: 15
console.log(typeof int); Result: "number"

<ತ್ವರಿತ ಶಕ್ತಿಗಳು

ಕಾರ್ಯಾಚರಣೆ

ES7 ನಿಂದ ಪ್ರಾರಂಭಿಸಿ, ನೀವು ಘಾತಾಂಕ ಆಪರೇಟರ್ ** ಅನ್ನು ಅಧಿಕಾರಗಳಿಗೆ ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಬಳಸಬಹುದು. ಇದು Math.pow(2, 3) ಅನ್ನು ಬಳಸುವುದಕ್ಕಿಂತ ಹೆಚ್ಚು ವೇಗವಾಗಿರುತ್ತದೆ. ಇದು ಸರಳವೆಂದು ತೋರುತ್ತದೆ, ಆದರೆ ಈ ಹಂತವನ್ನು ತಂತ್ರಗಳ ಪಟ್ಟಿಯಲ್ಲಿ ಸೇರಿಸಲಾಗಿದೆ, ಏಕೆಂದರೆ ಇದನ್ನು ಎಲ್ಲೆಡೆ ಉಲ್ಲೇಖಿಸಲಾಗಿಲ್ಲ.

console.log(2 ** 3); // Result: 8

ಇದನ್ನು ^ ಚಿಹ್ನೆಯೊಂದಿಗೆ ಗೊಂದಲಗೊಳಿಸಬಾರದು, ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಘಾತಕ್ಕೆ ಬಳಸಲಾಗುತ್ತದೆ. ಆದರೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಇದು XOR ಆಪರೇಟರ್ ಆಗಿದೆ.

ES7 ಗಿಂತ ಮೊದಲು, ** ಶಾರ್ಟ್‌ಕಟ್ ಅನ್ನು ಬಿಟ್‌ವೈಸ್ ಲೆಫ್ಟ್ ಶಿಫ್ಟ್ ಆಪರೇಟರ್ ಬಳಸಿ ಬೇಸ್ 2 ರ ಶಕ್ತಿಗಳಿಗೆ ಮಾತ್ರ ಬಳಸಬಹುದಾಗಿದೆ <<:

Math.pow(2, n);
2 << (n - 1);
2**n;

ಉದಾಹರಣೆಗೆ, 2 << 3 = 16 2 ** 4 = 16 ಗೆ ಸಮನಾಗಿರುತ್ತದೆ.

ಪೂರ್ಣಾಂಕಕ್ಕೆ ಫ್ಲೋಟ್ ಮಾಡಿ

ಕಾರ್ಯಾಚರಣೆಗಳು / ಪ್ರಕಾರದ ಪರಿವರ್ತನೆ

ನೀವು ಫ್ಲೋಟ್ ಅನ್ನು ಪೂರ್ಣಾಂಕಕ್ಕೆ ಪರಿವರ್ತಿಸಬೇಕಾದರೆ, ನೀವು Math.floor(), Math.ceil() ಅಥವಾ Math.round() ಅನ್ನು ಬಳಸಬಹುದು. ಆದರೆ ವೇಗವಾದ ಮಾರ್ಗವಿದೆ, ಇದಕ್ಕಾಗಿ ನಾವು |, ಅಂದರೆ OR ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ.

console.log(23.9 | 0);  // Result: 23
console.log(-23.9 | 0); // Result: -23

ನಡವಳಿಕೆ | ನೀವು ಧನಾತ್ಮಕ ಅಥವಾ ಋಣಾತ್ಮಕ ಸಂಖ್ಯೆಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುತ್ತೀರಾ ಎಂಬುದರ ಮೇಲೆ ಹೆಚ್ಚಾಗಿ ಅವಲಂಬಿತವಾಗಿದೆ, ಆದ್ದರಿಂದ ನೀವು ಏನು ಮಾಡುತ್ತಿದ್ದೀರಿ ಎಂಬುದರ ಬಗ್ಗೆ ನಿಮಗೆ ವಿಶ್ವಾಸವಿದ್ದರೆ ಮಾತ್ರ ಈ ವಿಧಾನವು ಸೂಕ್ತವಾಗಿದೆ.

ಎನ್ | 0 ದಶಮಾಂಶ ವಿಭಜಕದ ನಂತರ ಎಲ್ಲವನ್ನೂ ತೆಗೆದುಹಾಕುತ್ತದೆ, ಫ್ಲೋಟ್ ಅನ್ನು ಪೂರ್ಣಾಂಕಕ್ಕೆ ಮೊಟಕುಗೊಳಿಸುತ್ತದೆ.

ನೀವು ~~ ಬಳಸಿಕೊಂಡು ಅದೇ ಪೂರ್ಣಾಂಕದ ಪರಿಣಾಮವನ್ನು ಪಡೆಯಬಹುದು. ಪೂರ್ಣಾಂಕಕ್ಕೆ ಬಲವಂತದ ಪರಿವರ್ತನೆಯ ನಂತರ, ಮೌಲ್ಯವು ಬದಲಾಗದೆ ಉಳಿಯುತ್ತದೆ.

ಟ್ರೇಲಿಂಗ್ ಸಂಖ್ಯೆಗಳನ್ನು ತೆಗೆದುಹಾಕಲಾಗುತ್ತಿದೆ

ಸಂಖ್ಯೆಯಿಂದ ಯಾವುದೇ ಸಂಖ್ಯೆಯ ಅಂಕೆಗಳನ್ನು ತೆಗೆದುಹಾಕಲು OR ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಬಹುದು. ಇದರರ್ಥ ನಾವು ಇಲ್ಲಿ ರೀತಿಯ ಪ್ರಕಾರಗಳನ್ನು ಪರಿವರ್ತಿಸುವ ಅಗತ್ಯವಿಲ್ಲ:

let str = "1553";
Number(str.substring(0, str.length - 1));

ಬದಲಿಗೆ ನಾವು ಸರಳವಾಗಿ ಬರೆಯುತ್ತೇವೆ:

console.log(1553 / 10   | 0)  // Result: 155
console.log(1553 / 100  | 0)  // Result: 15
console.log(1553 / 1000 | 0)  // Result: 1

ಸ್ವಯಂಚಾಲಿತ ಲಿಂಕ್ ಮಾಡುವಿಕೆ

ತರಗತಿಗಳು

ES6 ಬಾಣದ ಸಂಕೇತಗಳನ್ನು ವರ್ಗ ವಿಧಾನಗಳಲ್ಲಿ ಬಳಸಬಹುದು, ಮತ್ತು ಬೈಂಡಿಂಗ್ ಅನ್ನು ಸೂಚಿಸಲಾಗಿದೆ. ಇದರರ್ಥ ನೀವು ಈ ರೀತಿಯ ಪುನರಾವರ್ತಿತ ಅಭಿವ್ಯಕ್ತಿಗಳಿಗೆ ವಿದಾಯ ಹೇಳಬಹುದು.myMethod = this.myMethod.bind(ಇದು)!

import React, { Component } from React;
 
export default class App extends Compononent {
  constructor(props) {
  super(props);
  this.state = {};
  }
 
myMethod = () => {
    // This method is bound implicitly!
  }
 
render() {
    return (
      <>
        <div>
          {this.myMethod()}
        </div>
      </>
    )
  }
};

ಅರೇ ಟ್ರಿಮ್ಮಿಂಗ್

ಅರೇಗಳು

ನೀವು ರಚನೆಯಿಂದ ಮೌಲ್ಯಗಳನ್ನು ತೆಗೆದುಹಾಕಬೇಕಾದರೆ, ಸ್ಪ್ಲೈಸ್ () ಗಿಂತ ವೇಗವಾದ ವಿಧಾನಗಳಿವೆ.

ಉದಾಹರಣೆಗೆ, ಮೂಲ ರಚನೆಯ ಗಾತ್ರ ನಿಮಗೆ ತಿಳಿದಿದ್ದರೆ, ನೀವು ಅದರ ಉದ್ದದ ಆಸ್ತಿಯನ್ನು ಈ ಕೆಳಗಿನಂತೆ ಅತಿಕ್ರಮಿಸಬಹುದು:

let array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
array.length = 4;
 
console.log(array); // Result: [0, 1, 2, 3]

ಆದರೆ ಇನ್ನೊಂದು ವಿಧಾನವಿದೆ, ಮತ್ತು ವೇಗವಾದದ್ದು. ವೇಗವು ನಿಮಗೆ ಮುಖ್ಯವಾಗಿದ್ದರೆ, ನಮ್ಮ ಆಯ್ಕೆಗಳು ಇಲ್ಲಿವೆ:

let array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
array = array.slice(0, 4);
 
console.log(array); // Result: [0, 1, 2, 3]

ರಚನೆಯ ಕೊನೆಯ ಮೌಲ್ಯ(ಗಳನ್ನು) ಮುದ್ರಿಸಲಾಗುತ್ತಿದೆ

ಅರೇಗಳು
ಈ ತಂತ್ರಕ್ಕೆ ಸ್ಲೈಸ್ () ವಿಧಾನವನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ.

let array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
 
console.log(array.slice(-1)); // Result: [9]
console.log(array.slice(-2)); // Result: [8, 9]
console.log(array.slice(-3)); // Result: [7, 8, 9]

JSON ಕೋಡ್ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಲಾಗುತ್ತಿದೆ

JSON

ನೀವು ಈಗಾಗಲೇ JSON.stringify ಅನ್ನು ಬಳಸಿರಬಹುದು. ಇದು ನಿಮ್ಮ JSON ಅನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದೆಯೇ?

stringify() ವಿಧಾನವು ಎರಡು ಐಚ್ಛಿಕ ನಿಯತಾಂಕಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ: ರಿಪ್ಲೇಸರ್ ಫಂಕ್ಷನ್, ಇದನ್ನು JSON ಡಿಸ್ಪ್ಲೇ ಮಾಡುವುದನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು ಬಳಸಬಹುದು ಮತ್ತು ಸ್ಪೇಸ್ ಮೌಲ್ಯ.

console.log(JSON.stringify({ alpha: 'A', beta: 'B' }, null, 't'));
 
// Result:
// '{
//     "alpha": A,
//     "beta": B
// }'

ಅಷ್ಟೆ, ಈ ಎಲ್ಲಾ ತಂತ್ರಗಳು ಉಪಯುಕ್ತವಾಗಿವೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ. ನಿಮಗೆ ಯಾವ ತಂತ್ರಗಳು ಗೊತ್ತು? ಅವುಗಳನ್ನು ಕಾಮೆಂಟ್‌ಗಳಲ್ಲಿ ಬರೆಯಿರಿ.

ಸ್ಕಿಲ್‌ಬಾಕ್ಸ್ ಶಿಫಾರಸು ಮಾಡುತ್ತದೆ:

• ಎರಡು ವರ್ಷಗಳ ಪ್ರಾಯೋಗಿಕ ಕೋರ್ಸ್ "ನಾನು PRO ವೆಬ್ ಡೆವಲಪರ್".
• ಆನ್‌ಲೈನ್ ಕೋರ್ಸ್ "0 ರಿಂದ C# ಡೆವಲಪರ್".
• ಪ್ರಾಯೋಗಿಕ ಒಂದು ವರ್ಷದ ಕೋರ್ಸ್ "0 ರಿಂದ PRO ವರೆಗೆ PHP ಡೆವಲಪರ್".

ಮೂಲ: www.habr.com