ES6 - Deep

ES6-practise.js

// Run using quokka - vscode

// Arrays
var init = [1,2,3,4,5]

var [a,b,c] = init
// for a, b, c map one to one and skip rest
a
b
c
init


var [a,b,...c] = init
// for a, b map one to one and pass rest to c
a
b
c
init

// Objects
init = {a,b,c}
init

var {b, a, c} = {a,b,c}
// map one to one irrespective of order but field name
a
b
c

var {b, a, k} = {a,b,c}
// map one to one irrespective of order but field name, sorry no k found
// and no one wants c
a
b
c
k

var {b, a, ...k} = {a,b,c}
// dot be sad K, you can hold c, he need you
a
b
c
k
console.log(k.c)

var {b, a, ...k} = {a,b,...c}
// dot be sad K, you can hold c, he need you
a
b
c
// oops
k

var {b, a, k} = {a,b,...c}
// dot be sad K, you can hold c, he need you
a
b
c
// oops
k

var [a, b, k] = [a,b,c]
// map one to one irrespective of name but order
a
b
c
k

var [a, b, ...k] = [a,b,c]
// map one to one irrespective of name but order
a
b
c
k

var [a, b, ...k] = [a,b,...c]
// map one to one irrespective of name but order
a
b
c
k

var [a, b, k] = [a,b,...c]
// map one to one irrespective of name but order
a
b
c
k

var [a, b, k, l] = [a,b,...c]
// map one to one irrespective of name but order
a
b
c
k
l

var [a, b, k, ...l] = [a,b,...c]
// map one to one irrespective of name but order
a
b
c
k
l


// swap two numbers
var [a,b] = [1,2]
a
b
c

// skip values in array
var [a, , , , c] = [1,2,3,4,5]
a
b
c


var initObj = {
    a:'a',
    b:'b',
    c: {
        d:'d'
    },
    e:'e',
    f:'f'
}

var {a, b, c} = {...initObj}
a
b
c

// store c in other variable
var {c: k} = {...initObj};
k

var {d:k} = c
k

var obj = {
    name:'harpreet',
    address: {
        permanent: {
            value: "Delhi"
        },
        temporary: {
            value:"Noida"
        }
    }
}
// unnecessary ...
var {address} = {...obj}
address
var {permanent} = {...address}
permanent
var {value:k} = {...permanent}
k

// short ...
var {address} = obj
address
var {permanent} = address
permanent
var {value:k} = {...permanent}
k


// shorter
var {address: {permanent: {value:permanentAddress}}} = obj;
address
permanent
// value
permanentAddress

let key = 'z';
let {[key]: foo} = {z: 'bar'};

console.log(foo); // "bar"
key = 'address';
// let key2 = 'permsnent'
var {[key]: {permanent: {value:permanentAddress}}} = obj;
permanentAddress

// reset a, b
a = 0;
b = 0;
var {a, b, c} = {...initObj, a, b}
a
b
c

// assign default values
var {a=1, b=2, k=6} = {...initObj}
a
b
k

// unnecessary use of a, b at right
// reset a, b
a = 0;
b = 0;
var {a, b, c} = {a, b, ...initObj}
a
b
c

// important use of a, b at right
// reset a, b
a = 0;
b = 0;
// override value of a, b provided by initObject
// but this is unncessary you can skip a, b
//  in ar {a, b, c} and use var c
var {a, b, c} = {...initObj, a, b}
a
b
c
// check here
var {c} = {...initObj}
a
b
c

// skip certain fields from an object
var {a, b, ...restObj} = {...initObj}
initObj
restObj

var {a, b, ...restObj} = initObj
initObj
restObj

// override value of certain fields in object
// method 1: (long way and overused)
    // Step 1:
    var {a, b, c} = {...initObj}
    a
    b
    c

    // Step 2
    var k = {
        ...{a:'X'}, //over used
        b,
        c
    }
    k

// method 2: (long way)
    // Step 1:
    var {a, b, c} = {...initObj, a:'X'}
    a
    b
    c

    // Step 2
    var k = {
        a,
        b,
        c
    }
    k

// or
// method 3: (short)
    var k = {a,b,c} = {...initObj, a:'X'}
    k

// pass rest to f
var {a, b, c, ...f} = {...initObj}
a
b
f

// just pass f to f
var {a, b, c, e, ...f} = {...initObj}
a
b
c
e
f

// merge arrays
init = [1,2,3,4,5]
k = [0, ...init, 6]
k

// merge objects
k = {x:'x', ...initObj, y:'y'}
k

// merge objects and override fields
k = {x:'x', ...initObj, y:'y', a:1, b:2}
k

// merge objects and override fields
k = {x:'x', y:'y', ...initObj, a:1, b:2}
k

// merge two different objects 
var obj1 = {a, b}
var obj2 = {c}
var obj3 = {a, b:'X'}
obj1
obj2
obj3

// last object's field value will override previously created field
k = {...obj1, ...obj2, ...obj3}
// obj1.b replaced by obj3.b
k

k = {...obj2, ...obj3, ...obj1}
// obj3.b replaced by obj1.b
k

k = {...obj3, ...obj1, ...obj2}
// obj3.b replaced by obj1.b
k

k = {...obj1, ...obj3, ...obj2}
// obj1.b replaced by obj3.b
k

k = {...obj3, ...obj2, ...obj1}
// obj3.b replaced by obj1.b
k

k = {obj3, obj2, obj1}
k

k = {...[obj3], obj2, obj1}
k

k = [obj3, obj2, obj1]
k

var sumAll = (...args) => args.reduce((prev, curr) => (prev + curr), 0)

k = sumAll(1,2,3,4,5)
k

var sumAllV2 = (args) => args.reduce((prev, curr) => (prev + curr), 0)

k = sumAllV2([1,2,3,4,5])
k

var sumAllV2 = args => args.reduce((prev, curr) => (prev + curr), 0)

k = sumAllV2([1,2,3,4,5,6])
k


var factorial = (...args) => args.reduce((prev, curr) => (prev * curr), 1)
k = factorial(1,2,3,4,5)
k

var sumAllGreaterThan5 = (...args) => args
                                        .filter(val => val > 5)
                                        .reduce((prev, curr) => (prev + curr), 0)
k = sumAllGreaterThan5(1,2,3,4,5,6,7,8)
k

var sumAllGreaterThan5AndLessThan10 = (...args) => args
                                        .filter(val => val > 5 && val < 10)
                                        .reduce((prev, curr) => (prev + curr), 0)
k = sumAllGreaterThan5AndLessThan10(1,2,3,4,5,6,7,8,9,10)
k

var sqr = x => x*x
k = sqr(3)
k



init = [1,2,3,4,5]
k
init
var [a, , k, , , , l] = [...init, , ,]
a
k
l

// var [a, ...b, c]  = [1, 2, 3];
// a
// b
// c

// {a, b} = {a: 1, b: 2}
// a
// b

var {a, b} = {a: 1, b: 2}
a
b

var people = [
    {
      name: 'Mike Smith',
      family: {
        mother: 'Jane Smith',
        father: 'Harry Smith',
        sister: 'Samantha Smith'
      },
      age: 35
    },
    {
      name: 'Tom Jones',
      family: {
        mother: 'Norah Jones',
        father: 'Richard Jones',
        brother: 'Howard Jones'
      },
      age: 25
    }
  ];
  
  for (var {name: n, family: {father: f}} of people) {
    console.log('Name: ' + n + ', Father: ' + f);
  }

let f1 = (param) => {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            console.log('fun1')
            resolve(param);
        }, 2000)
    });
}

let f2 = (param) => {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            console.log('fun2')
            resolve(param);
        }, 2000)
    });
}

let f3 = (param) => {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            console.log('fun3')
            resolve(param);
        }, 2000)
    });
}

let f4 = (param) => {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            console.log('fun4')
            resolve(param);
        }, 2000)
    });
}

/* f1(1).then((value1) => {
    console.log('here', value1)
    f2(value1 + 2).then((value2) => {
        console.log("here 2", value2);
    })
})

f1(10).then((value1) => {
    console.log('here')
    return f2(value1 + 20)
}).then((res) => {
    console.log("here 2", res);
})


f1(10).then((value1) => {
    console.log('here')
    return f2(value1 + 10)
}).then((value2) => {
    console.log("here 2", value2);
    return f3(value2 + 10)
}).then((value3) => {
    console.log("here 3", value3);
})


f1(10).then((value1) => {
    return f2(value1 + 10)
}).then((value2) => {
    return f3(value2 + 10)
}).then((value3) => {
    return f4(value3 + 10)
}).then((value4) => {
    console.log("here 4", value4);
    return value4
})
 */
// var arr = [f1, f2, f3, f4, f4]
// let store = '';
// for(let i=0;i<arr.length;i++) {
//     store = arr[i](i);
//     if(i+1<arr.length) {
//         store.then(arr[i+1][i+1])
//     } else {
//         store.then((value) => {
//             value
//             return value
//         })
//     }
// }

let promiseSeries = (arr) => {
    return new Promise((resolve, reject) => {
        let store = '';
        for(let i=0;i<arr.length;i++) {
            store = arr[i](i);
            if(i+1<arr.length) {
                store.then(arr[i+1][i+1])
            } else {
                store.then((value) => {
                    resolve(value)
                })
            }
        }                
    })
}

var arr = [f1, f2, f3, f4, f4]
// promiseSeries(arr).then((res) => {
//     console.log(res)
// })

// var a = [1,2,3,4,5]
// let acc = 0;
// acc =a.reduce((res, item, index) => {
//     res
//     item
//     return res += item
// }, acc)
// acc

let ret = Promise.resolve(null);
let res = [];
arr.reduce((result, item, index) => {
    return result.then((value) => {
        return item(index).then((val) => {
            res.push(val)
            return val;
        })
    })
}, ret).then((val) => {
    console.log(val, 'val')
    res
})