增加井号重复判断

‘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
'use strict';
 
var GetIntrinsic = require('get-intrinsic');
var hasSymbols = require('has-symbols')();
 
var $TypeError = GetIntrinsic('%TypeError%');
var IteratorPrototype = GetIntrinsic('%IteratorPrototype%', true);
 
var AdvanceStringIndex = require('./AdvanceStringIndex');
var CreateIterResultObject = require('./CreateIterResultObject');
var CreateMethodProperty = require('./CreateMethodProperty');
var Get = require('./Get');
var OrdinaryObjectCreate = require('./OrdinaryObjectCreate');
var RegExpExec = require('./RegExpExec');
var Set = require('./Set');
var ToLength = require('./ToLength');
var ToString = require('./ToString');
var Type = require('./Type');
 
var SLOT = require('internal-slot');
var setToStringTag = require('es-set-tostringtag');
 
var RegExpStringIterator = function RegExpStringIterator(R, S, global, fullUnicode) {
    if (Type(S) !== 'String') {
        throw new $TypeError('`S` must be a string');
    }
    if (Type(global) !== 'Boolean') {
        throw new $TypeError('`global` must be a boolean');
    }
    if (Type(fullUnicode) !== 'Boolean') {
        throw new $TypeError('`fullUnicode` must be a boolean');
    }
    SLOT.set(this, '[[IteratingRegExp]]', R);
    SLOT.set(this, '[[IteratedString]]', S);
    SLOT.set(this, '[[Global]]', global);
    SLOT.set(this, '[[Unicode]]', fullUnicode);
    SLOT.set(this, '[[Done]]', false);
};
 
if (IteratorPrototype) {
    RegExpStringIterator.prototype = OrdinaryObjectCreate(IteratorPrototype);
}
 
var RegExpStringIteratorNext = function next() {
    var O = this; // eslint-disable-line no-invalid-this
    if (Type(O) !== 'Object') {
        throw new $TypeError('receiver must be an object');
    }
    if (
        !(O instanceof RegExpStringIterator)
        || !SLOT.has(O, '[[IteratingRegExp]]')
        || !SLOT.has(O, '[[IteratedString]]')
        || !SLOT.has(O, '[[Global]]')
        || !SLOT.has(O, '[[Unicode]]')
        || !SLOT.has(O, '[[Done]]')
    ) {
        throw new $TypeError('"this" value must be a RegExpStringIterator instance');
    }
    if (SLOT.get(O, '[[Done]]')) {
        return CreateIterResultObject(undefined, true);
    }
    var R = SLOT.get(O, '[[IteratingRegExp]]');
    var S = SLOT.get(O, '[[IteratedString]]');
    var global = SLOT.get(O, '[[Global]]');
    var fullUnicode = SLOT.get(O, '[[Unicode]]');
    var match = RegExpExec(R, S);
    if (match === null) {
        SLOT.set(O, '[[Done]]', true);
        return CreateIterResultObject(undefined, true);
    }
    if (global) {
        var matchStr = ToString(Get(match, '0'));
        if (matchStr === '') {
            var thisIndex = ToLength(Get(R, 'lastIndex'));
            var nextIndex = AdvanceStringIndex(S, thisIndex, fullUnicode);
            Set(R, 'lastIndex', nextIndex, true);
        }
        return CreateIterResultObject(match, false);
    }
    SLOT.set(O, '[[Done]]', true);
    return CreateIterResultObject(match, false);
};
CreateMethodProperty(RegExpStringIterator.prototype, 'next', RegExpStringIteratorNext);
 
if (hasSymbols) {
    setToStringTag(RegExpStringIterator.prototype, 'RegExp String Iterator');
 
    if (Symbol.iterator && typeof RegExpStringIterator.prototype[Symbol.iterator] !== 'function') {
        var iteratorFn = function SymbolIterator() {
            return this;
        };
        CreateMethodProperty(RegExpStringIterator.prototype, Symbol.iterator, iteratorFn);
    }
}
 
// https://262.ecma-international.org/11.0/#sec-createregexpstringiterator
module.exports = function CreateRegExpStringIterator(R, S, global, fullUnicode) {
    // assert R.global === global && R.unicode === fullUnicode?
    return new RegExpStringIterator(R, S, global, fullUnicode);
};