first commit javascript coding

Author: Mahdidzt

array-prototype.js

@@ -0,0 +1,124 @@
+function filter(arr, callback) {
+    const newArray = [];
+    for (let i = 0; i < arr.length; i++) {
+        if (callback(arr[i], i, arr)) {
+            newArray.push(arr[i])
+        }
+    }
+    return newArray;
+}
+
+function filterObject(object, callback) {
+    let newOject = {};
+    for (const key in object) {
+        if (callback(object[key], key, object)) {
+            newOject = { ...newOject, ...{ [key]: object[key] } };
+        }
+
+    }
+    return newOject;
+}
+
+// const objFilter = { a: 2, b: 3, c: 4, f: 10 }
+// console.log(filterObject(objFilter, (value => value > 3)));
+// const arr = [1, 2, 2, 3, 4, 5, 6]
+// console.log(filter(arr, (x => x > 3)))
+// filter(arr, ((x, i, a) => {
+//     console.log(i);
+// }))
+
+
+function map(array, callback) {
+    const newArray = [];
+    for (let i = 0; i < array.length; i++) {
+        newArray.push(callback(array[i], i, array))
+    }
+    return newArray;
+}
+
+function objectMap(object, callback) {
+    let newOject = {}
+    for (const key in object) {
+        newOject = { ...newOject, ...{ [key]: callback(object[key], key) } }
+    }
+    return newOject;
+}
+// const array = [1, 2, 3, 4]
+// const array = [{ x: 2, y: 3 }, { x: 2, y: 3 }]
+// console.log(map(array, (x => x.x)));
+
+// const obj = { a: 2, b: 3, x: 4 }
+// console.log(Object.keys(obj));
+// console.log(
+//     objectMap(obj, ((val, key) => {
+//         return val * 2;
+//     }
+//     ))
+// );
+
+
+function reduce(array, callback, initialValue) {
+    let accumulator = initialValue ?? 0;
+    for (let i = 0; i < array.length; i++) {
+        accumulator = callback(accumulator, array[i], i, array)
+    }
+    return accumulator;
+}
+
+function objectReduce(object, callback, initialValue) {
+    let accumulator = initialValue ?? 0;
+    for (const key in object) {
+        accumulator = callback(accumulator, object[key], key, object);
+    }
+    return accumulator;
+}
+
+// const array = [1, 2, 3, 4]
+const object = { a: 2, b: 3, x: 4 }
+// console.log(reduce(array, ((acc, item) => {
+//      acc.push()
+// }), [] ));
+
+// console.log(
+//     objectReduce(object, ((acc, value, key) => {
+//         acc += value;
+
+//         return acc;
+//     }), 0)
+// );
+
+// function flat(array, depth = 1) {
+//     return array.reduce((acc, item) => {
+//         if (Array.isArray(item)) {
+//             if (depth >= 1) {
+//                 acc.push(...flat(item, depth - 1))
+//                 return acc;
+//             }
+//         }
+//         acc.push(item)
+//         return acc;
+//     }, [])
+// }
+
+function flat(array, depth = 1) {
+    return array.reduce((acc, item) => {
+        if (Array.isArray(item) && depth >= 1) {
+            acc.push(...flat(item, depth - 1))
+            return acc;
+        }
+        acc.push(item);
+        return acc;
+    }, [])
+}
+
+const arr = [[1, 2], 3, [8, 4, [5, 6]]];
+console.log(flat(arr));
+
+
+
+
+
+
+
+
+

chunk.mjs

@@ -0,0 +1,10 @@
+function chunk(array, size) {
+    if (!array.length) {
+        return [];
+    }
+
+    return [array.slice(0, size), ...chunk(array.slice(size), size)];
+}
+
+let arr = [1, 2, 3, 4, 5, 6];
+console.log(chunk(arr, 0));

clone-deep.mjs

@@ -0,0 +1,30 @@
+const target = {
+    field1: 1,
+    field2: undefined,
+    field3: {
+        child: 'child'
+    },
+    field4: [2, 4, 8]
+};
+
+target.target2 = target;
+function cloneDeep(target, map = new WeakMap()) {
+    if (typeof target === 'object') {
+        const cloneTarget = Array.isArray(target) ? [] : {}
+        const currentTarget = map.get(target);
+        if (currentTarget) {
+            return currentTarget;
+        }
+        map.set(target, cloneTarget)
+        for (const key in target) {
+            cloneTarget[key] = cloneDeep(target[key], map);
+        }
+        return cloneTarget;
+    }
+    return target;
+}
+
+
+const newTarget = cloneDeep(target);
+// const newTarget = target;
+console.log(target.field4 === newTarget.field4);

convert-object-keys.mjs

@@ -0,0 +1,39 @@
+function snake_case(obj) {
+    return Object.fromEntries
+        (
+            Object.entries(obj).map(([key, value]) => {
+                const newKey = key.replace(/[A-Z]/g, (letter) => '_' + letter.toLowerCase());
+                return [newKey, value]
+            })
+        )
+}
+
+function camelCase(obj) {
+    return Object.fromEntries
+        (
+            Object.entries(obj).map(([key, value]) => {
+                const newKey = key.replace(/[-_][a-z]/g, (letter) => letter.toUpperCase().replace(/-|_/g, ''))
+                return [newKey, value]
+            })
+        )
+}
+const obj = {
+    fullName: 'Mahdi Rezazadeh',
+    birthDate: '1996/12/28'
+
+}
+// const snake_case_obj = snake_case(obj);
+// console.log('snake_case_obj: ', snake_case_obj);
+// const newSample = {
+//     'full-name': 'Mahdi Rez',
+//     'birth-date': '12313 123123'
+// }
+// const camelCaseObj = camelCase(newSample);
+// console.log('camelCaseObj: ', camelCaseObj);
+
+console.log(mahdi);
+
+
+var mahdi = function ali() {
+    return 'mahdi function'
+}

debounce.mjs

@@ -0,0 +1,22 @@
+
+function debounce(fn, delay) {
+    let timer;
+    return (...args) => {
+        clearTimeout(timer);
+        timer = setTimeout(() => {
+            fn.apply(this, args);
+        }, delay);
+    }
+}
+
+
+function save(params) {
+    console.log('item saved in ' + params);
+}
+
+const timer = 1500;
+const process = debounce(save, timer);
+setInterval(() => {
+
+    process(timer)
+}, 200);

deep-equal.mjs

@@ -0,0 +1,39 @@
+const person1 = {
+    "firstName": "John",
+    "lastName": "Doe",
+    "age": 35
+};
+
+const person2 = {
+    "firstName": "John",
+    "lastName": "Doe",
+    "age": 35,
+};
+
+const isDeepEqual = (object1, object2) => {
+
+    const objKeys1 = Object.keys(object1);
+    const objKeys2 = Object.keys(object2);
+
+    if (objKeys1.length !== objKeys2.length) return false;
+
+    for (var key of objKeys1) {
+        const value1 = object1[key];
+        const value2 = object2[key];
+
+        const isObjects = isObject(value1) && isObject(value2);
+
+        if ((isObjects && !isDeepEqual(value1, value2)) ||
+            (!isObjects && value1 !== value2)
+        ) {
+            return false;
+        }
+    }
+    return true;
+};
+
+const isObject = (object) => {
+    return object != null && typeof object === "object";
+};
+
+console.log(isDeepEqual(person1, person2)); //true

factorial.js

@@ -0,0 +1,17 @@
+
+var factorial = (function hideCache() {
+    var cache = [];
+    return function factorial(num) {
+        if (num < 2) {
+            return 1;
+        }
+        if (!(num in cache)) {
+            cache[num] = num * factorial(num - 1);
+            return cache[num];
+        }
+        return cache[num];
+    }
+})()
+
+
+console.log(factorial(6));

groupBy.mjs

@@ -0,0 +1,26 @@
+function groupBy(array, callBack) {
+    const newArray = [];
+    const obj = {};
+    for (let i = 0; i < array.length; i++) {
+        const key = callBack(array[i], i);
+        if (!obj[key]) {
+            obj[key] = [array[i]];
+
+        } else {
+            obj[key].push(array[i])
+        }
+
+    }
+    newArray.push(obj);
+    return newArray;
+}
+
+const products = [
+    { name: 'apples', category: 'fruits' },
+    { name: 'oranges', category: 'fruits' },
+    { name: 'potatoes', category: 'vegetables' }
+];
+
+
+const groupByCategory = groupBy(products, (res) => res.category)
+console.log('groupByCategory: ', groupByCategory);