JS変数ストレージのディープコピーとシャローコピーの詳しい説明

let a1 = 0; // スタックメモリ let a2 = "this is string" // スタックメモリ let a3 = null; // スタックメモリ let b = { x: 10 }; // 変数 b はスタックに存在し、{ x: 10 } はヒープ内のオブジェクトとして存在します let c = [1, 2, 3]; // 変数 c はスタックに存在し、[1, 2, 3] はヒープ内のオブジェクトとして存在します

a = {x: 10, y: 20}とします。
b = a とします。
5 倍
コンソールログ(ax); // 5 

var obj = { a: {a: "kobe", b: 39},b:1 };
        var initalObj = Object.assign({}, obj);
        initalObj.aa = "ウェイド";
        初期オブジェクトb = 2;
        console.log(obj.aa); //ウェイド
        コンソールログ(obj.b); //1

obj = {a:1,b:{c:1}}とします。
obj2 = {...obj} とします。
2 番目の引数は 0 です。
console.log(obj); //{a:2,b:{c:1}}
コンソールログ(obj2); //{a:1,b:{c:1}}

obj.bc = 2;
console.log(obj); //{a:2,b:{c:2}}
コンソールログ(obj2); //{a:1,b:{c:2}}

arr = [1, 3, {
    ユーザー名: 'kobe'
    }];
arr3 = arr.slice() とします。
0 は 0 です。
arr3[2].ユーザー名 = 'ウェイド'
コンソールにログ出力します。

arr = [1, 3, {
    ユーザー名: 'kobe'
    }];
arr2=arr.concat() とします。   
0 は 0 です。
arr2[2].ユーザー名 = 'ウェイド';
コンソールにログ出力します。

関数 shallowCopy(src) {
    var dst = {};
    (var prop in src) の場合 {
        src.hasOwnProperty(prop) の場合 {
            dst[prop] = src[prop];
        }
    }
    dst を返します。
}

arr = [1, 3, {
    ユーザー名: 'kobe'
}];
arr4 = JSON.parse(JSON.stringify(arr)) とします。
arr4[2].ユーザー名 = 'ダンカン'; 
コンソールログ(arr, arr4)

関数クローン(ターゲット) {
    if (typeof target === 'object') {
        cloneTarget を Array.isArray(target) とします。[] : {};
        for (const キー in ターゲット) {
            cloneTarget[キー] = clone(target[キー]);
        }
        cloneTarget を返します。
    } それ以外 {
        ターゲットを返します。
    }
};

const mapTag = "[オブジェクト Map]";
    const setTag = "[オブジェクト Set]";
    const arrayTag = "[オブジェクト配列]";
    const objectTag = "[オブジェクト オブジェクト]";
    const argsTag = "[オブジェクト引数]";

    const boolTag = "[オブジェクト ブール値]";
    const dateTag = "[オブジェクト Date]";
    const numberTag = "[オブジェクト番号]";
    const stringTag = "[オブジェクト文字列]";
    const symbolTag = "[オブジェクト シンボル]";
    const errorTag = "[オブジェクト Error]";
    const regexpTag = "[オブジェクト RegExp]";
    const funcTag = "[オブジェクト関数]";

    const deepTag = [mapTag、setTag、arrayTag、objectTag、argsTag];

    関数 forEach(配列, iteratee) {
      インデックスを -1 とします。
      定数長さ = 配列.長さ;
      (++インデックス < 長さ) の間 {
        iteratee(配列[インデックス], インデックス);
      }
      配列を返します。
    }

    関数isObject(ターゲット) {
      const type = typeof ターゲット;
      戻りターゲット !== null && (type === "オブジェクト" || type === "関数");
    }

    関数 getType(ターゲット) {
      Object.prototype.toString.call(target) を返します。
    }

    関数 getInit(ターゲット) {
      const Ctor = target.constructor;
      新しい Ctor() を返します。
    }

    関数 cloneSymbol(ターゲット) {
      Object(Symbol.prototype.valueOf.call(target)) を返します。
    }

    関数 cloneReg(ターゲット) {
      const reFlags = /\w*$/;
      const 結果 = 新しい targe.constructor(targe.source、reFlags.exec(targe));
      結果.lastIndex = ターゲット.lastIndex;
      結果を返します。
    }

    関数 cloneFunction(func) {
      定数 bodyReg = /(?<={)(.|\n)+(?=})/m;
      定数paramReg = /(?<=\().+(?=\)\s+{)/;
      定数 funcString = func.toString();
      if (関数プロトタイプ) {
        定数パラメータ = paramReg.exec(funcString);
        bodyReg は、次のコードで定義されます。
        if (本文) {
          if (パラメータ) {
            param[0]を分割します。
            新しい関数(...paramArr、body[0])を返します。
          } それ以外 {
            新しい関数(body[0])を返します。
          }
        } それ以外 {
          null を返します。
        }
      } それ以外 {
        eval(funcString) を返します。
      }
    }

    関数 cloneOtherType(ターゲット, タイプ) {
      const Ctor = target.constructor;
      スイッチ（タイプ）{
        ケース boolタグ:
        ケース番号タグ:
        ケース文字列タグ:
        ケースエラータグ:
        ケース日付タグ:
          新しい Ctor(target) を返します。
        case regexpタグ:
          cloneReg(ターゲット)を返します。
        ケースシンボルタグ:
          cloneSymbol(target) を返します。
        ケース関数タグ:
          cloneFunction(ターゲット) を返します。
        デフォルト：
          null を返します。
      }
    }

    関数クローン(ターゲット、マップ = 新しいWeakMap()) {
      // 元の型を複製する if (!isObject(target)) {
        ターゲットを返します。
      }

      // 初期化 const type = getType(target);
      cloneTarget を作成します。
      deepTag.includes(type) の場合
        cloneTarget = getInit(ターゲット、タイプ);
      } それ以外 {
        cloneOtherType(ターゲット、タイプ) を返します。
      }

      // 循環参照を防ぐ if (map.get(target)) {
        map.get(target) を返します。
      }
      マップを設定します(ターゲット、クローンターゲット);

      // セットを複製する
      if (type === setTag) {
        ターゲット.forEach(値 => {
          cloneTarget.add(clone(値、マップ));
        });
        cloneTarget を返します。
      }

      // マップを複製する
      if (type === mapTag) {
        target.forEach((値, キー) => {
          cloneTarget.set(キー、clone(値、マップ));
        });
        cloneTarget を返します。
      }

      // オブジェクトと配列を複製します。const keys = type === arrayTag ? undefined : Object.keys(target);
      forEach(キー || ターゲット、(値、キー) => {
        if (キー) {
          キー = 値;
        }
        cloneTarget[key] = clone(target[key], map);
      });

      cloneTarget を返します。
    }

    定数マップ = 新しい Map();
    map.set("キー", "値");
    map.set("ConardLi", "code Secret Garden");

    set は新しい Set() です。
    set.add("ConardLi");
    set.add("コード秘密の庭");

    定数ターゲット = {
      フィールド1: 1,
      フィールド2: 未定義、
      フィールド3: {
        子供: 「子供」
      },
      フィールド4: [2, 4, 8],
      空: null、
      地図、
      セット、
      bool: 新しいブール値(true)、
      num: 新しい数値(2)、
      str: 新しい文字列(2)、
      シンボル: オブジェクト(シンボル(1))、
      日付: 新しい Date(),
      reg: /\d+/,
      エラー: 新しい Error()、
      関数1: () => {
        console.log("コード秘密の庭");
      },
      関数2: 関数(a, b) {
        a + b を返します。
      }
    };

    const 結果 = clone(ターゲット);

    console.log(ターゲット);
    console.log(結果);