12 Tricks JavaScript เบ—เบตเปˆ Tutorials เบชเปˆเบงเบ™เปƒเบซเบเปˆเบžเบฒเบ”

12 Tricks JavaScript เบ—เบตเปˆ Tutorials เบชเปˆเบงเบ™เปƒเบซเบเปˆเบžเบฒเบ”

เป€เบกเบทเปˆเบญเบ‚เป‰เบญเบเป€เบฅเบตเปˆเบกเบฎเบฝเบ™ JavaScript, เบชเบดเปˆเบ‡เบ—เปเบฒเบญเบดเบ”เบ—เบตเปˆเบ‚เป‰เบญเบเป€เบฎเบฑเบ”เปเบกเปˆเบ™เป€เบฎเบฑเบ”เบšเบฑเบ™เบŠเบตเบฅเบฒเบเบŠเบทเปˆเบ‚เบญเบ‡ tricks เบ—เบตเปˆเบŠเปˆเบงเบเปƒเบซเป‰เบ‚เป‰เบญเบเบ›เบฐเบซเบเบฑเบ”เป€เบงเบฅเบฒ. เบ‚เป‰เบฒโ€‹เบžเบฐโ€‹เป€เบˆเบปเป‰เบฒโ€‹เป„เบ”เป‰โ€‹เบžเบปเบšโ€‹เป€เบซเบฑเบ™โ€‹เป€เบ‚เบปเบฒโ€‹เป€เบˆเบปเป‰เบฒโ€‹เบˆเบฒเบโ€‹เป‚เบ„เบ‡โ€‹เบเบฒเบ™โ€‹เบญเบทเปˆเบ™เป†โ€‹, เปƒเบ™โ€‹เป€เบงเบฑเบšโ€‹เป„เบŠโ€‹เบ—เบตเปˆโ€‹เปเบ•เบโ€‹เบ•เปˆเบฒเบ‡โ€‹เบเบฑเบ™โ€‹เปเบฅเบฐโ€‹เปƒเบ™โ€‹เบ„เบนเปˆโ€‹เบกเบทโ€‹.

เปƒเบ™เบšเบปเบ”เบ„เบงเบฒเบกเบ™เบตเป‰, เบ‚เป‰เบญเบเบˆเบฐเบชเบฐเปเบ”เบ‡ 12 เบงเบดเบ—เบตเบ—เบตเปˆเบ”เบตเบ—เบตเปˆเบˆเบฐเบ›เบฑเบšเบ›เบธเบ‡เปเบฅเบฐเป€เบฅเบฑเปˆเบ‡เบฅเบฐเบซเบฑเบ” JavaScript เบ‚เบญเบ‡เบ—เปˆเบฒเบ™. เปƒเบ™เบเปเบฅเบฐเบ™เบตเบซเบผเบฒเบเบ—เบตเปˆเบชเบธเบ”, เบžเบงเบเป€เบ‚เบปเบฒเป€เบˆเบปเป‰เบฒเปเบกเปˆเบ™เบ—เบปเปˆเบงเป„เบ›.

เบžเบงเบเป€เบฎเบปเบฒเป€เบ•เบทเบญเบ™: เบชเปเบฒเบฅเบฑเบšเบœเบนเป‰เบญเปˆเบฒเบ™เบ—เบฑเบ‡เบซเบกเบปเบ”เบ‚เบญเบ‡ "Habr" - เบชเปˆเบงเบ™เบซเบผเบธเบ” 10 rubles เป€เบกเบทเปˆเบญเบฅเบปเบ‡เบ—เบฐเบšเบฝเบ™เปƒเบ™เบซเบผเบฑเบเบชเบนเบ” Skillbox เป‚เบ”เบเปƒเบŠเป‰เบฅเบฐเบซเบฑเบ”เบชเบปเปˆเบ‡เป€เบชเบตเบก "Habr".

Skillbox เปเบ™เบฐเบ™เปเบฒ: เบซเบผเบฑเบเบชเบนเบ”เบžเบฒเบเบ›เบฐเบ•เบดเบšเบฑเบ” "เบœเบนเป‰เบžเบฑเบ”เบ—เบฐเบ™เบฒเบกเบทเบ–เบท PRO".

เบเบฒเบ™เบเบฑเปˆเบ™เบ•เบญเบ‡เบ„เบธเบ™เบ„เปˆเบฒเบ—เบตเปˆเป€เบ›เบฑเบ™เป€เบญเบเบฐเบฅเบฑเบ

เบญเบฒเป€เบฃ

เบ›เบฐเป€เบžเบ”เบงเบฑเบ”เบ–เบธ Set เป„เบ”เป‰เบ–เบทเบเบ™เปเบฒเบชเบฐเป€เบซเบ™เบตเปƒเบ™ ES6, เบžเป‰เบญเบกเบเบฑเบšเบ•เบปเบงเบ›เบฐเบ•เบดเบšเบฑเบ”เบเบฒเบ™เปเบœเปˆเบเบฐเบˆเบฒเบ, เบžเบงเบเป€เบฎเบปเบฒเบชเบฒเบกเบฒเบ”เบ™เปเบฒเปƒเบŠเป‰เบกเบฑเบ™เป€เบžเบทเปˆเบญเบชเป‰เบฒเบ‡ array เปƒเบซเบกเปˆเบ—เบตเปˆเบกเบตเบžเบฝเบ‡เปเบ•เปˆเบ„เปˆเบฒเบ—เบตเปˆเป€เบ›เบฑเบ™เป€เบญเบเบฐเบฅเบฑเบ.

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

เปƒเบ™เบชเบฐเบ–เบฒเบ™เบฐเบเบฒเบ™เบ›เบปเบเบเบฐเบ•เบด, เบฅเบฐเบซเบฑเบ”เบซเบผเบฒเบเปเบกเปˆเบ™เบˆเปเบฒเป€เบ›เบฑเบ™เป€เบžเบทเปˆเบญเบ”เปเบฒเป€เบ™เบตเบ™เบเบฒเบ™เบ”เบฝเบงเบเบฑเบ™.

เป€เบ•เบฑเบเบ™เบดเบเบ™เบตเป‰เปƒเบŠเป‰เป„เบ”เป‰เบเบฑเบš arrays เบ—เบตเปˆเบกเบตเบ›เบฐเป€เบžเบ”เป€เบšเบทเป‰เบญเบ‡เบ•เบปเป‰เบ™: undefined, null, boolean, string เปเบฅเบฐ number. เบ–เป‰เบฒโ€‹เบซเบฒเบโ€‹เบงเปˆเบฒโ€‹เบ—เปˆเบฒเบ™โ€‹เบเปเบฒโ€‹เบฅเบฑเบ‡โ€‹เป€เบฎเบฑเบ”โ€‹เบงเบฝเบโ€‹เบฎเปˆเบงเบกโ€‹เบเบฑเบš array เบ—เบตเปˆโ€‹เบ›เบฐโ€‹เบเบญเบšโ€‹เบ”เป‰เบงเบโ€‹เบงเบฑเบ”โ€‹เบ–เบธโ€‹, เบซเบ™เป‰เบฒโ€‹เบ—เบตเปˆโ€‹, เบซเบผเบท arrays เป€เบžเบตเปˆเบกโ€‹เป€เบ•เบตเบกโ€‹, เบ—เปˆเบฒเบ™โ€‹เบˆเบฐโ€‹เบ•เป‰เบญเบ‡โ€‹เบเบฒเบ™โ€‹เบงเบดโ€‹เบ—เบตโ€‹เบเบฒเบ™โ€‹เบ—เบตเปˆโ€‹เปเบ•เบโ€‹เบ•เปˆเบฒเบ‡โ€‹เบเบฑเบ™โ€‹.

เบ„เบงเบฒเบกเบเบฒเบงเบ‚เบญเบ‡ cache array เปƒเบ™เบฎเบญเบšเบงเบฝเบ™

เบฎเบญเบšเบงเบฝเบ™

เป€เบกเบทเปˆเบญเบ—เปˆเบฒเบ™เบฎเบฝเบ™เบฎเบนเป‰เบชเปเบฒเบฅเบฑเบš loops, เบ—เปˆเบฒเบ™เบ›เบฐเบ•เบดเบšเบฑเบ”เบ•เบฒเบกเบ‚เบฑเป‰เบ™เบ•เบญเบ™เบกเบฒเบ”เบ•เบฐเบ–เบฒเบ™:

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

เปเบ™เบงเปƒเบ”เบเปเปˆเบ•เบฒเบก, เบ”เป‰เบงเบ syntax เบ™เบตเป‰, for loop เบเบงเบ”เป€เบšเบดเปˆเบ‡เบ„เบงเบฒเบกเบเบฒเบงเบ‚เบญเบ‡ array เปเบ•เปˆเบฅเบฐเบญเบฑเบ™เบŠเป‰เบณเป†.

เบšเบฒเบ‡เบ„เบฑเป‰เบ‡เบ™เบตเป‰เบชเบฒเบกเบฒเบ”เป€เบ›เบฑเบ™เบ›เบฐเป‚เบซเบเบ”, เปเบ•เปˆเปƒเบ™เบเปเบฅเบฐเบ™เบตเบซเบผเบฒเบเบ—เบตเปˆเบชเบธเบ”, เบกเบฑเบ™เบกเบตเบ›เบฐเบชเบดเบ”เบ—เบดเบžเบฒเบšเบซเบผเบฒเบเบ—เบตเปˆเบˆเบฐ cache เบ„เบงเบฒเบกเบเบฒเบงเบ‚เบญเบ‡ array, เป€เบŠเบดเปˆเบ‡เบˆเบฐเบ•เป‰เบญเบ‡เบเบฒเบ™เบซเบ™เบถเปˆเบ‡เบเบฒเบ™เป€เบ‚เบปเป‰เบฒเป€เบ–เบดเบ‡เบกเบฑเบ™. เบžเบงเบเป€เบฎเบปเบฒเบชเบฒเบกเบฒเบ”เป€เบฎเบฑเบ”เป„เบ”เป‰เป‚เบ”เบเบเบฒเบ™เบเปเบฒเบ™เบปเบ”เบ•เบปเบงเปเบ›เบ„เบงเบฒเบกเบเบฒเบงเบ—เบตเปˆเบžเบงเบเป€เบฎเบปเบฒเบเปเบฒเบ™เบปเบ”เบ•เบปเบงเปเบ› i, เป€เบŠเบฑเปˆเบ™เบ™เบตเป‰:

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

เปƒเบ™เบซเบผเบฑเบเบเบฒเบ™, เป€เบเบทเบญเบšเบ„เบทเบเบฑเบ™เบเบฑเบšเบ‚เป‰เบฒเบ‡เป€เบ—เบดเบ‡, เปเบ•เปˆเป‚เบ”เบเบเบฒเบ™เป€เบžเบตเปˆเบกเบ‚เบฐเบซเบ™เบฒเบ”เบ‚เบญเบ‡ loop เบžเบงเบเป€เบฎเบปเบฒเบˆเบฐเป„เบ”เป‰เบฎเบฑเบšเบเบฒเบ™เบ›เบฐเบซเบเบฑเบ”เป€เบงเบฅเบฒเบ—เบตเปˆเบชเปเบฒเบ„เบฑเบ™.

เบ„เบฐเปเบ™เบ™เบงเบปเบ‡เบˆเบญเบ™เบชเบฑเป‰เบ™ (เบ„เบฐเปเบ™เบ™ McCarthy)

เบœเบนเป‰เบ›เบฐเบเบญเบšเบเบฒเบ™เบ—เบตเปˆเบกเบตเป€เบ‡เบทเปˆเบญเบ™เป„เบ‚

เบ•เบปเบงเบ›เบฐเบ•เบดเบšเบฑเบ”เบเบฒเบ™ ternary เปเบกเปˆเบ™เบงเบดเบ—เบตเบ—เบตเปˆเป„เบงเปเบฅเบฐเบกเบตเบ›เบฐเบชเบดเบ”เบ—เบดเบžเบฒเบšเบ—เบตเปˆเบˆเบฐเบ‚เบฝเบ™เบ‚เปเป‰เบ„เบงเบฒเบกเปเบšเบšเบ‡เปˆเบฒเบเป† (เปเบฅเบฐเบšเบฒเบ‡เบ„เบฑเป‰เบ‡เบเปเปˆเบšเปเปˆเบ‡เปˆเบฒเบเบ”เบฒเบ):

x> 100? โ€œเบซเบผเบฒเบเบเบงเปˆเบฒ 100โ€: โ€œเปœเป‰เบญเบเบเบงเปˆเบฒ 100โ€;
x> 100? (x>200? "more than 200": "เบฅเบฐเบซเบงเปˆเบฒเบ‡ 100-200"): "เบซเบ™เป‰เบญเบเบเบงเปˆเบฒ 100";

เปเบ•เปˆเบšเบฒเบ‡เบ„เบฑเป‰เบ‡เป€เบ–เบดเบ‡เปเบกเปˆเบ™เบงเปˆเบฒเบœเบนเป‰เบ›เบฐเบ•เบดเบšเบฑเบ”เบเบฒเบ™ ternary เปเบกเปˆเบ™เบชเบฑเบšเบชเบปเบ™เบซเบผเบฒเบเบเปˆเบงเบฒเบ—เบตเปˆเบ•เป‰เบญเบ‡เบเบฒเบ™. เบžเบงเบเป€เบฎเบปเบฒเบชเบฒเบกเบฒเบ”เปƒเบŠเป‰ 'and' && เปเบฅเบฐ 'or' เปเบ—เบ™ || เบ•เบปเบงเบ›เบฐเบ•เบดเบšเบฑเบ”เบเบฒเบ™ Boolean เป€เบžเบทเปˆเบญเบ›เบฐเป€เบกเบตเบ™เบเบฒเบ™เบชเบฐเปเบ”เบ‡เบญเบญเบเบšเบฒเบ‡เบขเปˆเบฒเบ‡เปƒเบ™เบ—เบฒเบ‡เบ—เบตเปˆเบŠเบฑเบ”เป€เบˆเบ™เบเบงเปˆเบฒ. เบกเบฑเบ™เบกเบฑเบเบˆเบฐเป€เบญเบตเป‰เบ™เบงเปˆเบฒ "เบงเบปเบ‡เบˆเบญเบ™เบชเบฑเป‰เบ™" เบซเบผเบท "เบเบฒเบ™เบˆเบฑเบ”เบญเบฑเบ™เบ”เบฑเบšเบงเบปเบ‡เบˆเบญเบ™เบชเบฑเป‰เบ™".

เบงเบดเบ—เบตเบเบฒเบ™เป€เบฎเบฑเบ”เบงเบฝเบเบ™เบตเป‰

เปƒเบซเป‰เป€เบงเบปเป‰เบฒเบงเปˆเบฒเบžเบงเบเป€เบฎเบปเบฒเบ•เป‰เบญเบ‡เบเบฒเบ™เบเบฑเบšเบ„เบทเบ™เบžเบฝเบ‡เปเบ•เปˆเบซเบ™เบถเปˆเบ‡เปƒเบ™เบชเบญเบ‡เป€เบ‡เบทเปˆเบญเบ™เป„เบ‚เบซเบผเบทเบซเบผเบฒเบเบเบงเปˆเบฒเบ™เบฑเป‰เบ™.

เบเบฒเบ™โ€‹เบ™เปเบฒโ€‹เปƒเบŠเป‰ && เบˆเบฐโ€‹เบเบฑเบšโ€‹เบ„เบทเบ™โ€‹เบ„เปˆเบฒโ€‹เบ—เปเบฒโ€‹เบญเบดเบ”โ€‹เบ—เบตเปˆโ€‹เบšเปเปˆโ€‹เบ–เบทเบโ€‹เบ•เป‰เบญเบ‡. เบ–เป‰เบฒเปเบ•เปˆเบฅเบฐ operand เบ›เบฐเป€เบกเบตเบ™เป€เบ›เบฑเบ™ true, เบซเบผเบฑเบ‡เบˆเบฒเบเบ™เบฑเป‰เบ™เบเบฒเบ™เบชเบฐเปเบ”เบ‡เบญเบญเบเบชเบธเบ”เบ—เป‰เบฒเบเบ—เบตเปˆเบ–เบทเบเบ›เบฐเป€เบกเบตเบ™เบˆเบฐเบ–เบทเบเบชเบปเปˆเบ‡เบ„เบทเบ™.

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

เบเบฒเบ™เบ™เปเบฒเปƒเบŠเป‰ || เบˆเบฐเบเบฑเบšเบ„เบทเบ™เบ„เปˆเบฒเบ—เบตเปˆเปเบ—เป‰เบˆเบดเบ‡เบ—เปเบฒเบญเบดเบ”. เบ–เป‰เบฒเปเบ•เปˆเบฅเบฐ operand เบ›เบฐเป€เบกเบตเบ™เป€เบ›เบฑเบ™เบœเบดเบ”, เบซเบผเบฑเบ‡เบˆเบฒเบเบ™เบฑเป‰เบ™เบกเบนเบ™เบ„เปˆเบฒเบเบฒเบ™เบ›เบฐเป€เบกเบตเบ™เบชเบธเบ”เบ—เป‰เบฒเบเบˆเบฐเบ–เบทเบเบชเบปเปˆเบ‡เบ„เบทเบ™.

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

เบ•เบปเบงเบขเปˆเบฒเบ‡ 1

เบชเบปเบกเบกเบธเบ”เบงเปˆเบฒเบžเบงเบเป€เบฎเบปเบฒเบ•เป‰เบญเบ‡เบเบฒเบ™เบเบฑเบšเบ„เบทเบ™เบ„เบงเบฒเบกเบเบฒเบงเบ‚เบญเบ‡เบ•เบปเบงเปเบ›, เปเบ•เปˆเบžเบงเบเป€เบฎเบปเบฒเบšเปเปˆเบฎเบนเป‰เบ›เบฐเป€เบžเบ”เบ‚เบญเบ‡เบกเบฑเบ™.

เปƒเบ™เบเปเบฅเบฐเบ™เบตเบ™เบตเป‰, เบ—เปˆเบฒเบ™เบชเบฒเบกเบฒเบ”เปƒเบŠเป‰ if/else เป€เบžเบทเปˆเบญเบเบงเบ”เป€เบšเบดเปˆเบ‡เบงเปˆเบฒ foo เปเบกเปˆเบ™เบ›เบฐเป€เบžเบ”เบ—เบตเปˆเบ–เบทเบเบ•เป‰เบญเบ‡, เปเบ•เปˆเบงเบดเบ—เบตเบ™เบตเป‰เบญเบฒเบ”เบˆเบฐเบเบฒเบงเป€เบเบตเบ™เป„เบ›. เบ”เบฑเปˆเบ‡เบ™เบฑเป‰เบ™, เบกเบฑเบ™เบ”เบตเบเบงเปˆเบฒเบ—เบตเปˆเบˆเบฐเป€เบญเบปเบฒ "เบงเบปเบ‡เบˆเบญเบ™เบชเบฑเป‰เบ™" เบ‚เบญเบ‡เบžเบงเบเป€เบฎเบปเบฒ.

return (foo || []).length;

เบ–เป‰เบฒ foo เบ•เบปเบงเบ›เปˆเบฝเบ™เปเบ›เบ‡เบกเบตเบ„เบงเบฒเบกเบเบฒเบงเบ—เบตเปˆเป€เบซเบกเบฒเบฐเบชเบปเบก, เบซเบผเบฑเบ‡เบˆเบฒเบเบ™เบฑเป‰เบ™เบกเบฑเบ™เบˆเบฐเบ–เบทเบเบชเบปเปˆเบ‡เบ„เบทเบ™. เบ–เป‰เบฒเบšเปเปˆเบ”เบฑเปˆเบ‡เบ™เบฑเป‰เบ™เบžเบงเบเป€เบฎเบปเบฒเบˆเบฐเป„เบ”เป‰เบฎเบฑเบš 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 เบˆเบฐเบชเบปเปˆเบ‡เบเบฑเบš this.state.data เป‚เบ”เบเบšเปเปˆเบ„เปเบฒเบ™เบถเบ‡เป€เบ–เบดเบ‡เบงเปˆเบฒเบกเบฑเบ™เบˆเบฐเบšเปเปˆเบ–เบทเบเบเปเบฒเบ™เบปเบ”เบซเบผเบทเบšเปเปˆ.

เบฅเบฐเบšเบปเบšเบ•เปˆเบญเบ‡เป‚เบชเป‰เบ—เบฒเบ‡เป€เบฅเบทเบญเบ

เบ„เบปเบ™ เปœเบถเปˆเบ‡ เบญเบฒเบ”เบˆเบฐเปเบ™เบฐ เบ™เบณ เปƒเบซเป‰เปƒเบŠเป‰เบฅเบฐเบšเบปเบšเบ•เปˆเบญเบ‡เป‚เบชเป‰เบ—เบฒเบ‡เป€เบฅเบทเบญเบเปƒเบ™เป€เบงเบฅเบฒเบ—เบตเปˆเบžเบฐเบเบฒเบเบฒเบกเบชเบปเปˆเบ‡เบ„เบทเบ™เบŠเบฑเบšเบชเบดเบ™เป€เบฅเบดเบเป€เบ‚เบปเป‰เบฒเป„เบ›เปƒเบ™เป‚เบ„เบ‡เบชเป‰เบฒเบ‡เบ•เบปเป‰เบ™เป„เบกเป‰. เบ”เบฑเปˆเบ‡เบ™เบฑเป‰เบ™, เป€เบ„เบทเปˆเบญเบ‡เบซเบกเบฒเบเบ„เปเบฒเบ–เบฒเบก? เบชเบฒเบกเบฒเบ”เปƒเบŠเป‰เป€เบžเบทเปˆเบญเบ”เบถเบ‡เบŠเบฑเบšเบชเบดเบ™เบžเบฝเบ‡เปเบ•เปˆเบ–เป‰เบฒเบกเบฑเบ™เบšเปเปˆเปเบกเปˆเบ™ null.

เบ•เบปเบงเบขเปˆเบฒเบ‡, เบžเบงเบเป€เบฎเบปเบฒเบชเบฒเบกเบฒเบ” refactor เบ•เบปเบงเบขเปˆเบฒเบ‡เบ‚เป‰เบฒเบ‡เป€เบ—เบดเบ‡เป€เบžเบทเปˆเบญเปƒเบซเป‰เป„เบ”เป‰ this.state.data?..(). เบ™เบฑเป‰เบ™เปเบกเปˆเบ™, เบ‚เปเป‰เบกเบนเบ™เบ–เบทเบเบชเบปเปˆเบ‡เบ„เบทเบ™เบžเบฝเบ‡เปเบ•เปˆเบ–เป‰เบฒเบ„เปˆเบฒเบšเปเปˆเปเบกเปˆเบ™ null.

เบซเบผเบท, เบ–เป‰เบฒเบกเบฑเบ™เบชเบณเบ„เบฑเบ™เบงเปˆเบฒเบฅเบฑเบ”เบ–เบทเบเบเบณเบ™เบปเบ”เบซเบผเบทเบšเปเปˆ, เบžเบงเบเป€เบฎเบปเบฒเบชเบฒเบกเบฒเบ”เบชเบปเปˆเบ‡ this.state?.data.

เบ›เปˆเบฝเบ™เป€เบ›เบฑเบ™ Boolean

เบ›เบฐเป€เบžเบ”เบเบฒเบ™เปเบ›เบ‡

เบ™เบญเบเป€เบซเบ™เบทเบญเบˆเบฒเบเบเบฒเบ™เบ—เปเบฒเบ‡เบฒเบ™เบ‚เบญเบ‡ boolean เบ›เบปเบเบเบฐเบ•เบดเปเบกเปˆเบ™ true เปเบฅเบฐ false, JavaScript เบเบฑเบ‡เบ›เบฐเบ•เบดเบšเบฑเบ”เบ„เปˆเบฒเบญเบทเปˆเบ™เป†เบ—เบฑเบ‡เบซเบกเบปเบ”เป€เบ›เบฑเบ™เบ„เบงเบฒเบกเบˆเบดเบ‡เบซเบผเบท falsy.

เบˆเบปเบ™เบเปˆเบงเบฒเบชเบฑเบ‡เป€เบเบ”เป€เบซเบฑเบ™เบ–เป‰เบฒเบšเปเปˆเบ”เบฑเปˆเบ‡เบ™เบฑเป‰เบ™, เบ„เปˆเบฒเบ—เบฑเบ‡เบซเบกเบปเบ”เปƒเบ™ JavaScript เปเบกเปˆเบ™เบ„เบงเบฒเบกเบˆเบดเบ‡, เบเบปเบเป€เบงเบฑเป‰เบ™ 0, "", null, undefined, NaN เปเบฅเบฐ, เปเบ™เปˆเบ™เบญเบ™, false. เบญเบฑเบ™เบชเบธเบ”เบ—เป‰เบฒเบเปเบกเปˆเบ™เบ›เบญเบก.

เบžเบงเบโ€‹เป€เบฎเบปเบฒโ€‹เบชเบฒโ€‹เบกเบฒเบ”โ€‹เบชเบฐโ€‹เบซเบผเบฑเบšโ€‹เบฅเบฐโ€‹เบซเบงเปˆเบฒเบ‡โ€‹เบ—เบฑเบ‡โ€‹เบชเบญเบ‡โ€‹เป„เบ”เป‰โ€‹เบขเปˆเบฒเบ‡โ€‹เบ‡เปˆเบฒเบโ€‹เบ”เบฒเบโ€‹เป‚เบ”เบโ€‹เบเบฒเบ™โ€‹เบ™เปเบฒโ€‹เปƒเบŠเป‰ ! operator, เป€เบŠเบดเปˆเบ‡โ€‹เบเบฑเบ‡โ€‹เบ›เปˆเบฝเบ™โ€‹เบ›เบฐโ€‹เป€เบžเบ”โ€‹เป€เบ›เบฑเบ™ boolean.

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"

เบงเบดเบ—เบตเบเบฒเบ™เบ™เบตเป‰เบเบฑเบ‡เบชเบฒเบกเบฒเบ”เบ–เบทเบเบ™เปเบฒเปƒเบŠเป‰เป€เบžเบทเปˆเบญเบ›เปˆเบฝเบ™เบ›เบฐเป€เบžเบ”เบ‚เปเป‰เบกเบนเบ™ boolean เป€เบ›เบฑเบ™เบ„เปˆเบฒเบ•เบปเบงเป€เบฅเบเบ›เบปเบเบเบฐเบ•เบด, เบ”เบฑเปˆเบ‡เบ—เบตเปˆเบชเบฐเปเบ”เบ‡เบ‚เป‰เบฒเบ‡เบฅเบธเปˆเบกเบ™เบตเป‰:

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

เบญเบฒเบ”เบˆเบฐเบกเบตเบชเบฐเบ–เบฒเบ™เบฐเบเบฒเบ™เบ—เบตเปˆ + เบˆเบฐเบ–เบทเบเบ•เบตเบ„เบงเบฒเบกเบงเปˆเบฒเป€เบ›เบฑเบ™เบ•เบปเบงเบ›เบฐเบ•เบดเบšเบฑเบ”เบเบฒเบ™เบชเบปเบกเบ—เบปเบšเปเบ—เบ™เบ—เบตเปˆเบˆเบฐเป€เบ›เบฑเบ™เบ•เบปเบงเบ›เบฐเบ•เบดเบšเบฑเบ”เบเบฒเบ™เป€เบžเบตเปˆเบกเป€เบ•เบตเบก. เป€เบžเบทเปˆเบญเบซเบผเบตเบเป€เบงเบฑเป‰เบ™เบเบฒเบ™เบ™เบตเป‰, เบ—เปˆเบฒเบ™เบ„เบงเบ™เปƒเบŠเป‰ tildes: ~~. เป‚เบ•เบ›เบฐเบ•เบดเบšเบฑเบ”เบเบฒเบ™เบ™เบตเป‰เปเบกเปˆเบ™เป€เบ—เบปเปˆเบฒเบเบฑเบš -n-1. เบ•เบปเบงเบขเปˆเบฒเบ‡, ~15 เป€เบ—เบปเปˆเบฒเบเบฑเบš -16.

เบเบฒเบ™เปƒเบŠเป‰เบชเบญเบ‡ tildes เบ•เบดเบ”เบ•เปเปˆเบเบฑเบ™เบˆเบฐเบ›เบฐเบ•เบดเป€เบชเบ”เบเบฒเบ™เบ”เปเบฒเป€เบ™เบตเบ™เบ‡เบฒเบ™เป€เบžเบฒเบฐเบงเปˆเบฒ - (- - n - 1) - 1 = n + 1 - 1 = n. เปƒเบ™เบ„เปเบฒเบชเบฑเบšเบ•เปˆเบฒเบ‡เป†เบญเบทเปˆเบ™เป†, ~-16 เป€เบ—เบปเปˆเบฒเบเบฑเบš 15.

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

<Quick Powers

เบเบฒเบ™เบ”เปเบฒเป€เบ™เบตเบ™เบ‡เบฒเบ™

เป€เบฅเบตเปˆเบกเบ•เบปเป‰เบ™เปƒเบ™ ES7, เบ—เปˆเบฒเบ™เบชเบฒเบกเบฒเบ”เบ™เปเบฒเปƒเบŠเป‰เบ•เบปเบงเบ›เบฐเบ•เบดเบšเบฑเบ”เบเบฒเบ™ exponential ** เป€เบ›เบฑเบ™ shorthand เบชเปเบฒเบฅเบฑเบšเบญเปเบฒเบ™เบฒเบ”. เบญเบฑเบ™เบ™เบตเป‰เป„เบงเบเบงเปˆเบฒเบเบฒเบ™เปƒเบŠเป‰ Math.pow(2, 3). เบกเบฑเบ™เป€เบšเบดเปˆเบ‡เบ„เบทเบงเปˆเบฒเบ‡เปˆเบฒเบเบ”เบฒเบ, เปเบ•เปˆเบˆเบธเบ”เบ™เบตเป‰เปเบกเปˆเบ™เบฅเบงเบกเบขเบนเปˆเปƒเบ™เบšเบฑเบ™เบŠเบตเบฅเบฒเบเบŠเบทเปˆเบ‚เบญเบ‡เป€เบ•เบฑเบเบ™เบดเบ, เป€เบ™เบทเปˆเบญเบ‡เบˆเบฒเบเบงเปˆเบฒเบกเบฑเบ™เบšเปเปˆเป„เบ”เป‰เบ–เบทเบเบเปˆเบฒเบงเป€เบ–เบดเบ‡เบขเบนเปˆเบ—เบปเปˆเบงเบ—เบธเบเปเบซเปˆเบ‡.

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

เบกเบฑเบ™โ€‹เบšเปเปˆโ€‹เบ„เบงเบ™โ€‹เบชเบฑเบšเบชเบปเบ™โ€‹เบเบฑเบšโ€‹เบชเบฑเบ™เบเบฐเบฅเบฑเบ^เบŠเบถเปˆเบ‡โ€‹เปƒเบŠเป‰โ€‹เบ—เบปเปˆเบงโ€‹เป„เบ›โ€‹เบชเบณเบฅเบฑเบšโ€‹เบเบฒเบ™โ€‹เป€เบฅเบโ€‹เบเบณเบฅเบฑเบ‡. เปเบ•เปˆเปƒเบ™ JavaScript เบ™เบตเป‰เปเบกเปˆเบ™เบ•เบปเบงเบ›เบฐเบ•เบดเบšเบฑเบ”เบเบฒเบ™ XOR.

เบเปˆเบญเบ™ ES7, เบ—เบฒเบ‡เบฅเบฑเบ” ** เบชเบฒเบกเบฒเบ”เปƒเบŠเป‰เป„เบ”เป‰เบžเบฝเบ‡เปเบ•เปˆเบชเปเบฒเบฅเบฑเบšเบžเบฐเบฅเบฑเบ‡เบ‡เบฒเบ™เบ‚เบญเบ‡เบžเบทเป‰เบ™เบ–เบฒเบ™ 2 เป‚เบ”เบเปƒเบŠเป‰เบ•เบปเบงเบ›เบฐเบ•เบดเบšเบฑเบ”เบเบฒเบ™ shift เบŠเป‰เบฒเบ bitwise <<:

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

เบ•เบปเบงเบขเปˆเบฒเบ‡: 2 << 3 = 16 เป€เบ—เบปเปˆเบฒเบเบฑเบš 2**4 = 16.

เป€เบฅเบทเปˆเบญเบ™เป€เบ›เบฑเบ™เบˆเบณเบ™เบงเบ™เป€เบ•เบฑเบก

เบเบฒเบ™เบ”เปเบฒเป€เบ™เบตเบ™เบ‡เบฒเบ™ / เบ›เบฐเป€เบžเบ”เบเบฒเบ™เบ›เปˆเบฝเบ™เปเบ›เบ‡

เบ–เป‰เบฒเบ—เปˆเบฒเบ™เบ•เป‰เบญเบ‡เบเบฒเบ™เปเบ›เบ‡ float เป€เบ›เบฑเบ™เบˆเปเบฒเบ™เบงเบ™เป€เบ•เบฑเบก, เบ—เปˆเบฒเบ™เบชเบฒเบกเบฒเบ”เบ™เปเบฒเปƒเบŠเป‰ Math.floor(), Math.ceil() เบซเบผเบท Math.round(). เปเบ•เปˆเบกเบตเบงเบดเบ—เบตเบ—เบตเปˆเป„เบงเบเบงเปˆเบฒ, เบชเปเบฒเบฅเบฑเบšเบ™เบตเป‰เบžเบงเบเป€เบฎเบปเบฒเปƒเบŠเป‰ |, เบ™เบฑเป‰เบ™เปเบกเปˆเบ™, OR operator.

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

เบžเบถเบ”เบ•เบดเบเบณ | เบชเปˆเบงเบ™เปƒเบซเบเปˆเปเบกเปˆเบ™เบ‚เบถเป‰เบ™เบเบฑเบšเบงเปˆเบฒเบ—เปˆเบฒเบ™เบเปเบฒเบฅเบฑเบ‡เบˆเบฑเบ”เบเบฒเบ™เบเบฑเบšเบ•เบปเบงเป€เบฅเบเปƒเบ™เบ—เบฒเบ‡เบšเบงเบเบซเบผเบทเบ—เบฒเบ‡เบฅเบปเบš, เบ”เบฑเปˆเบ‡เบ™เบฑเป‰เบ™เบงเบดเบ—เบตเบเบฒเบ™เบ™เบตเป‰เปเบกเปˆเบ™เป€เบซเบกเบฒเบฐเบชเบปเบกเบžเบฝเบ‡เปเบ•เปˆเบ–เป‰เบฒเบ—เปˆเบฒเบ™เบซเบกเบฑเป‰เบ™เปƒเบˆเปƒเบ™เบชเบดเปˆเบ‡เบ—เบตเปˆเบ—เปˆเบฒเบ™เบเปเบฒเบฅเบฑเบ‡เป€เบฎเบฑเบ”.

n | 0 เป€เบญเบปเบฒเบ—เบธเบเบขเปˆเบฒเบ‡เบญเบญเบเบซเบผเบฑเบ‡เบˆเบฒเบเบ•เบปเบงเบ‚เบฑเป‰เบ™เบ—เบปเบ”เบชเบฐเบ™เบดเบเบปเบก, เบ•เบฑเบ” float เป„เบ›เป€เบ›เบฑเบ™เบˆเปเบฒเบ™เบงเบ™เป€เบ•เบฑเบก.

เป€เบˆเบปเป‰เบฒเบชเบฒเบกเบฒเบ”เป„เบ”เป‰เบฎเบฑเบšเบœเบปเบ™เบฎเบญเบšเบ”เบฝเบงเบเบฑเบ™เป‚เบ”เบเปƒเบŠเป‰ ~~. เบซเบผเบฑเบ‡โ€‹เบˆเบฒเบโ€‹เบเบฒเบ™โ€‹เบšเบฑเบ‡โ€‹เบ„เบฑเบšโ€‹เปƒเบซเป‰โ€‹เบ›เปˆเบฝเบ™โ€‹เป€เบ›เบฑเบ™โ€‹เบˆเปเบฒโ€‹เบ™เบงเบ™โ€‹เป€เบ•เบฑเบกโ€‹, เบกเบนเบ™โ€‹เบ„เปˆเบฒโ€‹เบเบฑเบ‡โ€‹เบ„เบปเบ‡โ€‹เบšเปเปˆโ€‹เบกเบตโ€‹เบเบฒเบ™โ€‹เบ›เปˆเบฝเบ™โ€‹เปเบ›เบ‡โ€‹.

เบเบฒเบ™เบ–เบญเบ™เบ•เบปเบงเป€เบฅเบเบ•เปเปˆเบ—เป‰เบฒเบ

เบ•เบปเบงเบ›เบฐเบ•เบดเบšเบฑเบ”เบเบฒเบ™ 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 เบชเบฒเบกเบฒเบ”เบ–เบทเบเบ™เปเบฒเปƒเบŠเป‰เปƒเบ™เบงเบดเบ—เบตเบเบฒเบ™เบซเป‰เบญเบ‡เบฎเบฝเบ™, เปเบฅเบฐเบเบฒเบ™เบœเบนเบเบกเบฑเบ”เปเบกเปˆเบ™เบซเบกเบฒเบเป€เบ–เบดเบ‡. เบ™เบตเป‰เปเบฒเบเบ„เบงเบฒเบกเบงเปˆเบฒเป€เบˆเบปเป‰เบฒเบชเบฒเบกเบฒเบ”เบšเบญเบเบฅเบฒเบเบฑเบšเบเบฒเบ™เบชเบฐเปเบ”เบ‡เบŠเปเป‰เบฒเบ„เบทเบ™เป€เบŠเบฑเปˆเบ™ this.myMethod = this.myMethod.bind(this)!

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>
      </>
    )
  }
};

เบเบฒเบ™เบ•เบฑเบ”เบญเบฐเป€เบฃ

เบญเบฒเป€เบฃ

เบ–เป‰เบฒโ€‹เบซเบฒเบโ€‹เบงเปˆเบฒโ€‹เบ—เปˆเบฒเบ™โ€‹เบ•เป‰เบญเบ‡โ€‹เบเบฒเบ™โ€‹เบฅเบปเบšโ€‹เบ„เปˆเบฒโ€‹เบˆเบฒเบ arrayโ€‹, เบกเบตโ€‹เบงเบดโ€‹เบ—เบตโ€‹เบเบฒเบ™โ€‹เป„เบงโ€‹เบโ€‹เปˆโ€‹เบงเบฒ splice().

เบ•เบปเบงเบขเปˆเบฒเบ‡, เบ–เป‰เบฒเบ—เปˆเบฒเบ™เบฎเบนเป‰เบ‚เบฐเบซเบ™เบฒเบ”เบ‚เบญเบ‡ array เบ•เบปเป‰เบ™เบชเบฐเบšเบฑเบš, เบ—เปˆเบฒเบ™เบชเบฒเบกเบฒเบ” override เบ„เบธเบ™เบชเบปเบกเบšเบฑเบ”เบ„เบงเบฒเบกเบเบฒเบงเบ‚เบญเบ‡เบกเบฑเบ™เบ”เบฑเปˆเบ‡เบ•เปเปˆเป„เบ›เบ™เบตเป‰:

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]

เบเบฒเบ™เบžเบดเบกเบ„เปˆเบฒเบชเบธเบ”เบ—เป‰เบฒเบเบ‚เบญเบ‡เบญเบฒเป€เบฃ

เบญเบฒเป€เบฃ
เป€เบ•เบฑเบเบ™เบดเบเบ™เบตเป‰เบฎเบฝเบเบฎเป‰เบญเบ‡เปƒเบซเป‰เบกเบตเบเบฒเบ™เบ™เปเบฒเปƒเบŠเป‰เบงเบดเบ—เบตเบเบฒเบ™ slice() เป„เบ”เป‰.

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
// }'

เบ™เบฑเป‰เบ™เปเบกเปˆเบ™เบ—เบฑเบ‡เบซเบกเบปเบ”, เบ‚เป‰เบฒเบžเบฐเป€เบˆเบปเป‰เบฒเบซเบงเบฑเบ‡เบงเปˆเบฒเป€เบ•เบฑเบเบ™เบดเบเบ—เบฑเบ‡เบซเบกเบปเบ”เป€เบซเบผเบปเปˆเบฒเบ™เบตเป‰เป€เบ›เบฑเบ™เบ›เบฐเป‚เบซเบเบ”. เป€เบˆเบปเป‰เบฒเบฎเบนเป‰เป€เบ„เบฑเบ”เบฅเบฑเบšเบญเบฑเบ™เปƒเบ”? เบ‚เบฝเบ™เปƒเบซเป‰เป€เบ‚เบปเบฒเป€เบˆเบปเป‰เบฒเปƒเบ™เบ„เปเบฒเป€เบซเบฑเบ™.

Skillbox เปเบ™เบฐเบ™เปเบฒ:

เปเบซเบผเปˆเบ‡เบ‚เปเป‰เบกเบนเบ™: www.habr.com

เป€เบžเบตเปˆเบกเบ„เบงเบฒเบกเบ„เบดเบ”เป€เบซเบฑเบ™