Summary of some practical tips in JavaScript

const task1 = () => {
 ('Execute task1');
 return () >= 0.5;
}

const task2 = () => ('task1 Execute task2 after successful execution');
if (task1()) task2();

task1() && task2();

const task3 = () => ('task1 Execute task3 after execution failure');
task1() && task2() || task3();

task1() ? task2() : task3();

const ProfileItem = (props) => {
 const { name, value, render } = props;

 return (
  <div className="profile-item">
   <span className="item-name">{name}</span>
   <form action="">
    {/* Return different content based on whether there is render props */}
    {render && render(props) || <SimpleProfileItemContent value={value}/>}
   </form>
  </div>
 )
}

const pow = (x, y) => {
 y = y || 2;
 
 let result = 1;
 for (let i = 0, max = y; i < max; i++) {
  result *= x;
 }

 return result;
}

(pow(2)); // => 4
(pow(2, 3)); // => 8

// When the value of y is 0, y takes the value of 2(pow(2, 0)); // => 4

const pow = (x, y=2) => {
 let result = 1;
 for (let i = 0, max = y; i < max; i++) {
  result *= x;
 }

 return result;
}

(pow(2)); // => 4
(pow(2, 3)) // => 8
(pow(2, 0)); // => 1

function func() {
 for (let i = 0, max = ; i < max; i++) {
  (arguments[i]);
 }

 ((arguments)); // => false
 // Class arrays do not have set functions such as slice, forEach, map, etc. ( === undefined); // => true
}

func('Google', 'facebook', 'Microsoft'); 
// => 
// Google
// facebook
// Microsoft

function func() {
 const array = (arguments);
 ((0, 1));
}

func('Google', 'facebook', 'Microsoft'); // => [ 'Google' ]

function func() {
 ([...arguments])
}

func('Google', 'facebook', 'Microsoft'); // [ 'Google', 'facebook', 'Microsoft' ]

function func() {
 ((arguments))
}

func('Google', 'facebook', 'Microsoft'); // [ 'Google', 'facebook', 'Microsoft' ]

// Output 2 Starts 8 consecutive integersconst array = ({ length: 8}).map((ele, index) => index + 2);
(array); // => [ 2, 3, 4, 5, 6, 7, 8, 9 ] 
// The comment section points out that there is a simpler version, with its own mapping functionconst array = ({ length: 8}, (ele, index) => index + 2);
(array); // => [ 2, 3, 4, 5, 6, 7, 8, 9 ] 

// The default value must be set to the object parameters, otherwise an error will be reported when passing the parameters because the object is not deconstructed.const getUsers = ({
 offset=0,
 limit=1,
 orderBy="salary"
}={}) => {
 // Query the database according to the conditions to return user data ({ offset, limit, orderBy });
}

getUsers({ offset: 10, limit: 20,orderBy: 'age' }); // => { offset: 10, limit: 20, orderBy: 'age' }
getUsers();// => { offset: 0, limit: 1, orderBy: 'salary' }

(!!{}); // true
(!!0); // false
(!![]); // true
(!!undefined); // false

const httpGet = (url, retry) => {
 if (!!retry) {
  // Re-send timeout }
}

const me = {
  name: 'lyreal666',
  age: 23,
  speak() {
    (`Hello, I'm ly!`);
  }
}

const clonedMe = ((me));
(clonedMe); // => { name: 'lyreal666', age: 23 }
( === undefined); // => true

const me = {
  name: 'lyreal666',
  age: 23,
  speak() {
    (`Hello, I'm ly!`);
  }
}

const jsonStr = (me, (key, value) => key === 'name' ? 'Lao Yu' : value, 2);

(jsonStr);
/* =>
 {
  "name": "Lao Yu",
  "age": 23
 }
 */

const me = {
  name: 'lyreal666',
  age: 23,
  speak() {
    (`Hello, I'm ly!`);
  }
}

for (const [key, value] of (me)) {
  (`${key}: ${value}`);
}

/* =>
name: lyreal666
age: 23
speak: speak() {
    (`Hello, I'm ly!`);
  }
*/

const array = [1, 2, 3, 4];
 = 0;
(array); // => []

// Netizens pointed out that a better way is to directly assign empty arrayslet array = [1, 2, 3, 4];
array = [];

// ~ The operation rules of the operator can be simply written as inverse the result of adding one(~1); // => -2
(~0); // => -1
(~(-3)); // => 2
(~(-1)); // => 0

const number = -2;

// Determine whether a number is -1if (!~number) {
  // When number is -1 operation...}

// Invoke the function in brackets(function(window, $) {
  // Internal code}) (window, jQuery)

! function(window, $) {
  // Internal code} (window, jQuery)

// You can also use +, -, *, etc.+ function(window, $) {
  // Internal code} (window, jQuery)

// What's more magical is that you can also use new, typeof and other operatorsnew function(window, $) {
  // Internal code} (window, jQuery)；

([...new Set([1, 3, 1, 2, 2, 1])]); // => [ 1, 3, 2 ]

const array = [ 1, 2, 3, 4];
// Add(((p, c) => p + c)); // => 10
// Continuous(((p, c) => p * c)); // => 24

(~~3.14); // => 3
(~~(-2.5)); // => -2

(6.18 | 0); // => 6
(-3.6 | 0); // => -3

(9.9 >> 0); // => 9
(-2.1 >> 0); // => -2

// superagent is a very practical node module for sending http requests. It uses the process of return code |var type = status / 100 | 0;

// status / class
 = status;
 = type;

// basics
 = 1 == type;
 = 2 == type;
 = 4 == type;
 = 5 == type;
 = 4 == type || 5 == type;

(+'3.14'); // => 3.14
(typeof +'3.14') // => number

const sleep = (milliseconds) => {
    return new Promise((resolve, reject) => {
      setTimeout(() => resolve(), milliseconds);
    });
}

// Of course, you can consider using it to test! async function main() {
  const start = +new Date();
  await sleep(3000);
  const end = +new Date();
  (`Execute${end - start}`); // Execute 3002}();

const str1 = 'hello';
const str2 = ' world'

('Test + Stitch String');
for (let i = 0; i < 200000000; i++) {
  const joinedStr = str1 + str2;
}
('Test + Stitch String');

('Test template string splicing string');
// It is much more convenient to use scientific counting method than 8 0for (let i = 0; i < 2E8; i++) {
  const joinedStr =`${str1}${str2}`;
}
('Test template string splicing string')

/* =>
 Test + splicing string: 3238.037ms
 Test template string splicing string: 3680.225ms
 */

let a = 666;
let b = 999;
[a, b] = [b, a];
({ a, b }); // => { a: 999, b: 666 }

(().toString(16).substring(2)); // 13-bit => 45d9d0bb10b31(().toString(36).substring(2)); // 11Bit => zwcx1yewjvj

const array = [1, [2, [3, 4], 5], 6, 7];
(().split(',').map(ele => (ele))); // => [ 1, 2, 3, 4, 5, 6, 7 ]