增加井号重复判断

‘liusuyi’

2023-07-03 29d8ea701df5bba27bda837a550853b299207040

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
'use strict';
 
const Types = require('./types');
const Utils = require('./utils');
 
 
const internals = {
    needsProtoHack: new Set([Types.set, Types.map, Types.weakSet, Types.weakMap])
};
 
 
module.exports = internals.clone = function (obj, options = {}, _seen = null) {
 
    if (typeof obj !== 'object' ||
        obj === null) {
 
        return obj;
    }
 
    let clone = internals.clone;
    let seen = _seen;
 
    if (options.shallow) {
        if (options.shallow !== true) {
            return internals.cloneWithShallow(obj, options);
        }
 
        clone = (value) => value;
    }
    else {
        seen = seen || new Map();
 
        const lookup = seen.get(obj);
        if (lookup) {
            return lookup;
        }
    }
 
    // Built-in object types
 
    const baseProto = Types.getInternalProto(obj);
    if (baseProto === Types.buffer) {
        return Buffer && Buffer.from(obj);              // $lab:coverage:ignore$
    }
 
    if (baseProto === Types.date) {
        return new Date(obj.getTime());
    }
 
    if (baseProto === Types.regex) {
        return new RegExp(obj);
    }
 
    // Generic objects
 
    const newObj = internals.base(obj, baseProto, options);
    if (newObj === obj) {
        return obj;
    }
 
    if (seen) {
        seen.set(obj, newObj);                              // Set seen, since obj could recurse
    }
 
    if (baseProto === Types.set) {
        for (const value of obj) {
            newObj.add(clone(value, options, seen));
        }
    }
    else if (baseProto === Types.map) {
        for (const [key, value] of obj) {
            newObj.set(key, clone(value, options, seen));
        }
    }
 
    const keys = Utils.keys(obj, options);
    for (const key of keys) {
        if (key === '__proto__') {
            continue;
        }
 
        if (baseProto === Types.array &&
            key === 'length') {
 
            newObj.length = obj.length;
            continue;
        }
 
        const descriptor = Object.getOwnPropertyDescriptor(obj, key);
        if (descriptor) {
            if (descriptor.get ||
                descriptor.set) {
 
                Object.defineProperty(newObj, key, descriptor);
            }
            else if (descriptor.enumerable) {
                newObj[key] = clone(obj[key], options, seen);
            }
            else {
                Object.defineProperty(newObj, key, { enumerable: false, writable: true, configurable: true, value: clone(obj[key], options, seen) });
            }
        }
        else {
            Object.defineProperty(newObj, key, {
                enumerable: true,
                writable: true,
                configurable: true,
                value: clone(obj[key], options, seen)
            });
        }
    }
 
    return newObj;
};
 
 
internals.cloneWithShallow = function (source, options) {
 
    const keys = options.shallow;
    options = Object.assign({}, options);
    options.shallow = false;
 
    const storage = Utils.store(source, keys);    // Move shallow copy items to storage
    const copy = internals.clone(source, options);      // Deep copy the rest
    Utils.restore(copy, source, storage);         // Shallow copy the stored items and restore
    return copy;
};
 
 
internals.base = function (obj, baseProto, options) {
 
    if (baseProto === Types.array) {
        return [];
    }
 
    if (options.prototype === false) {                  // Defaults to true
        if (internals.needsProtoHack.has(baseProto)) {
            return new baseProto.constructor();
        }
 
        return {};
    }
 
    const proto = Object.getPrototypeOf(obj);
    if (proto &&
        proto.isImmutable) {
 
        return obj;
    }
 
    if (internals.needsProtoHack.has(baseProto)) {
        const newObj = new proto.constructor();
        if (proto !== baseProto) {
            Object.setPrototypeOf(newObj, proto);
        }
 
        return newObj;
    }
 
    return Object.create(proto);
};