octoparse-cli 0.1.14

package/node_modules/@octopus/engine/dist/actions/LoopAction.js

@@ -0,0 +1,526 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const LoopConfig_1 = __importDefault(require("../configs/LoopConfig"));
+const enums_1 = require("../enums");
+const Operations_1 = require("../utils/Operations");
+const BaseAction_1 = __importDefault(require("./BaseAction"));
+const actionItem_1 = require("../models/actionItem");
+class LoopAction extends BaseAction_1.default {
+    constructor() {
+        super(...arguments);
+        this.isDoneFirst = false;
+        this.targets = [];
+        this.onTargetCreated = (target) => {
+            if (target.type() == 'page') {
+                this.targets = [...(this.targets || []), target];
+            }
+        };
+        this.onTargetChanged = (target) => {
+            if (target.type() == 'page') {
+            }
+        };
+    }
+    parseConfig(config) {
+        return new LoopConfig_1.default(config);
+    }
+    resetTarget() {
+        this.actionTarget && this.browserProxy.switchTarget(this.actionTarget);
+        this.browserProxy.removeTargetCreated(this.onTargetCreated);
+        this.browserProxy.removeTargetChanged(this.onTargetChanged);
+    }
+    async loopElementExists(actionItem, timeout = 0) {
+        if (this.useExtensionBridge) {
+            const bridgeExists = await this.bridgeElementExists(this.page, actionItem, timeout || 1500);
+            if (bridgeExists !== undefined) {
+                return bridgeExists;
+            }
+        }
+        return Boolean(await (0, Operations_1.queryElement)(actionItem, this.page, timeout));
+    }
+    async wait() {
+        var _a;
+        if (this.isDoneFirst || this.getIsSkipCurrentLoop()) {
+            const page = await ((_a = this.actionTarget) === null || _a === void 0 ? void 0 : _a.page());
+            if (page) {
+                if (!this.useExtensionBridge) {
+                    await page.bringToFront();
+                }
+                this.browserProxy.switchTarget(this.actionTarget);
+                for (const target of this.targets) {
+                    const page = await target.page();
+                    if (!page.isClosed()) {
+                        await page.close();
+                    }
+                }
+                this.targets = [];
+            }
+            this.finish();
+            return;
+        }
+        this.isDoneFirst = true;
+        this.page = await this.getCurrentPage();
+        this.actionTarget = this.browserProxy.currentTarget;
+        this.browserProxy.onTargetCreated(this.onTargetCreated);
+        // JSON 任务跳过页面等待逻辑
+        if (this.browserProxy.navigateType !== "OpenJson" /* NavigateType.OpenJson */) {
+            await super.wait();
+        }
+        // 设置本次循环的次数_设置数量
+        this.initLoopCount(this.id);
+        const list = [];
+        switch (this.config.loopType) {
+            case "FixedItem" /* LoopType.FixedItem */:
+                {
+                    this.log(enums_1.LogKey.Loop.Begin.FixedItem, this.name);
+                    if (this.config.fixedItem) {
+                        list.unshift(this.config.fixedItem);
+                    }
+                    // 设置无效点击为 0 次
+                    this.initContinuousInvalidPageCount(this.id);
+                }
+                break;
+            case "FixedItemList" /* LoopType.FixedItemList */:
+                {
+                    this.log(enums_1.LogKey.Loop.Begin.FixedList, this.name);
+                    // JSON 模式不支持 FixedItemList（固定元素列表需要 DOM 查询）
+                    if (this.browserProxy.navigateType === "OpenJson" /* NavigateType.OpenJson */) {
+                        break;
+                    }
+                    try {
+                        const extensionElementsValues = this.activity.activity.extensionElements.values;
+                        for (const key in extensionElementsValues) {
+                            const fixedList = extensionElementsValues[key];
+                            if (fixedList.$type == "xml:LoopAction.FixedList" /* ActionTags.FixedList */ &&
+                                fixedList.$children) {
+                                for (const c of fixedList.$children) {
+                                    const actionItem = this.config.getElementXPath(c.value);
+                                    const exists = await this.loopElementExists(actionItem, this.shouldWait ? 1500 : 0);
+                                    if (exists)
+                                        list.unshift(actionItem);
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        await this.checkPause();
+                    }
+                }
+                break;
+            case "TextList" /* LoopType.TextList */:
+                {
+                    this.log(enums_1.LogKey.Loop.Begin.TextList, this.name);
+                    const extensionElementsValues = this.activity.activity.extensionElements.values;
+                    for (const key in extensionElementsValues) {
+                        const textList = extensionElementsValues[key];
+                        if (textList.$type == "xml:LoopAction.TextList" /* ActionTags.TextList */ && textList.$children) {
+                            for (const c of textList.$children) {
+                                list.unshift(c.value);
+                            }
+                        }
+                    }
+                }
+                break;
+            case "URLList" /* LoopType.URLList */:
+                {
+                    this.log(enums_1.LogKey.Loop.Begin.URLList, this.name);
+                    const extensionElementsValues = this.activity.activity.extensionElements.values;
+                    for (const key in extensionElementsValues) {
+                        const textList = extensionElementsValues[key];
+                        if (textList.$type == "xml:LoopAction.URLList" /* ActionTags.URLList */ && textList.$children) {
+                            for (const c of textList.$children) {
+                                list.unshift(c.value);
+                            }
+                        }
+                    }
+                }
+                break;
+            case "VarilableItemList" /* LoopType.VarilableItemList */:
+                {
+                    this.log(enums_1.LogKey.Loop.Begin.VarilableList, this.name);
+                    if (this.config.variableList) {
+                        // JSON 模式和网页模式分别处理
+                        if (this.browserProxy.navigateType === "OpenJson" /* NavigateType.OpenJson */) {
+                            try {
+                                const originalPath = this.config.variableList.AbsXpath;
+                                // 检查 jsonParser 是否有数据
+                                const root = this.browserProxy.jsonParser.getRoot();
+                                if (!root || Object.keys(root).length === 0) {
+                                    console.log('❌ jsonParser 没有数据！');
+                                }
+                                else {
+                                    const startIndex = originalPath.lastIndexOf('[*]');
+                                    //当前循环项的xpath
+                                    const thisXpath = originalPath.substring(0, startIndex) + '[0]';
+                                    const thisnode = this.browserProxy.jsonParser.getNode(thisXpath);
+                                    if (thisnode) {
+                                        list.unshift(this.config.variableList);
+                                    }
+                                    else {
+                                        // 尝试直接用原始路径查询看看
+                                        const testNode = this.browserProxy.jsonParser.getNode(originalPath.replace('[*]', '[0]'));
+                                        console.log('🔍 尝试替换 [*] 为 [0]:', testNode);
+                                    }
+                                }
+                            }
+                            catch (error) {
+                                console.log('🔴 LoopAction JSON 模式错误:', error);
+                            }
+                        }
+                        else {
+                            try {
+                                const { AbsXpath } = this.config.variableList;
+                                // 这里必须等待 Promise 结果；否则 Promise 对象本身恒为 truthy，
+                                // 会把“不存在的列表”也当成存在，导致循环队列永远压回去。
+                                const isExist = await this.loopElementExists(this.config.variableList, this.shouldWait ? 1500 : 0);
+                                if (isExist) {
+                                    list.unshift(this.config.variableList);
+                                }
+                                let diff = false;
+                                if (this.getCurrentLoopUrl(this.id)) {
+                                    const url = this.page.url();
+                                    if (this.getCurrentLoopUrl(this.id) != url) {
+                                        diff = true;
+                                    }
+                                }
+                                else {
+                                    diff = true;
+                                }
+                                const sample = this.getSamplingElementsMap(this.id);
+                                if (sample.size > 0) {
+                                    for (const [key, value] of sample) {
+                                        const thisElement = {
+                                            ...this.config.variableList,
+                                            AbsXpath: '(' + AbsXpath + ')[' + key + ']'
+                                        };
+                                        const isExist = await this.loopElementExists(thisElement, this.shouldWait ? 1500 : 0);
+                                        if (!isExist) {
+                                            continue;
+                                        }
+                                        // const text = await this.page.$eval(`::-p-xpath(${thisXpath})`, (ele: HTMLElement) => ele?.innerText || ele.textContent)
+                                        const text = await (0, Operations_1.processElement)(thisElement, this.page, '$eval', (ele) => (ele === null || ele === void 0 ? void 0 : ele.innerText) || ele.textContent);
+                                        if (this.similar(value.replace(/[\r\n\s]/g, ''), text.replace(/[\r\n\s]/g, ''), 2) < 0.95) {
+                                            diff = true; //说明前面的列表数据有变化
+                                            break;
+                                        }
+                                    }
+                                }
+                                const parentLoopAction = this.recursionGetParentLoopAction(this);
+                                const parentLoopCount = this.getLoopCount(parentLoopAction === null || parentLoopAction === void 0 ? void 0 : parentLoopAction.id);
+                                let isScrollWeb = false;
+                                // 滚动时循环列表不自动去重,重置index
+                                let notDirectSkip = true;
+                                if (parentLoopAction) {
+                                    const parentConfig = this.parent.config;
+                                    // 必须是在其父类的时候是FixedItem，单击的时候才做次判断
+                                    if (parentConfig.loopType == "ScrollWeb" /* LoopType.ScrollWeb */) {
+                                        isScrollWeb = true;
+                                        notDirectSkip =
+                                            parentConfig.disabledScrollAutoRemoveDuplication;
+                                    }
+                                    else if (parentConfig.loopType == "FixedItem" /* LoopType.FixedItem */ &&
+                                        parentConfig.checkedJumpLoopClick) {
+                                        // // 需要在任务配置勾选了【自动跳过无效的循环点击】选项才启用后面的【采样判断】
+                                        notDirectSkip = false;
+                                    }
+                                }
+                                if (parentLoopCount === 1 ||
+                                    notDirectSkip ||
+                                    (diff && !isScrollWeb)) {
+                                    this.initSomeLoopExtractDataCount(this.id);
+                                    this.initIdentifiedEachLoopExtractDataCount(this.id);
+                                    // 当列表基准发生变化时，同时清空上次为瞬时失败留下的 offset，
+                                    // 保证下一轮重新从自然索引开始。
+                                    this.resetNextLoopOffset(this.id);
+                                    this.initSamplingElementsMap(this.id);
+                                    this.initSampedLoopRecord();
+                                    this.initContinuousClickLoadNoNewDataCount(parentLoopAction === null || parentLoopAction === void 0 ? void 0 : parentLoopAction.id);
+                                }
+                                else {
+                                    this.setIdentifiedEachLoopExtractDataCount(this.id);
+                                    // 停止无效点击
+                                    if (parentLoopAction && this.browserProxy.workflowSetting) {
+                                        const parentLoopActionConfig = parentLoopAction.config;
+                                        // 只有循环采集的父级循环循环类型是循环单个元素时，才进行停止无效点击加载更多判断
+                                        if (parentLoopActionConfig &&
+                                            parentLoopActionConfig.loopType === "FixedItem" /* LoopType.FixedItem */ &&
+                                            parentLoopActionConfig.checkedJumpLoopClick &&
+                                            parentLoopCount >
+                                                this.browserProxy.workflowSetting.repeatPageLoopCount) {
+                                            const configOptions = {
+                                                AbsXpath: this.config.variableList.AbsXpath,
+                                                IsIFrame: this.config.variableList.IsIFrame,
+                                                IFrameAbsXPath: this.config.variableList.IFrameAbsXPath,
+                                                newXpathStartIndex: this.getSomeLoopExtractDataCount(this.id)
+                                            };
+                                            // 判断是否有新数据
+                                            if (await this.ifNextElement(configOptions, this.page)) {
+                                                this.initContinuousClickLoadNoNewDataCount(parentLoopAction.id);
+                                            }
+                                            else {
+                                                this.addContinuousClickLoadNoNewDataCount(parentLoopAction.id);
+                                            }
+                                            const noNewDataCount = this.getContinuousClickLoadNoNewDataCount(parentLoopAction.id);
+                                            if (noNewDataCount >=
+                                                this.browserProxy.workflowSetting.continuousJudgeCount) {
+                                                // 跳过本轮采集
+                                                this.setIsSkipCurrentLoop(parentLoopAction.id, true);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            catch (error) {
+                                await this.checkPause();
+                                /* empty */
+                            }
+                            // if (this.workflow.navigateType == NavigateType.OpenJson) {
+                            //   const startIndex = this.config.variableList.AbsXpath.lastIndexOf('[*]')
+                            //   //当前循环项的xpath
+                            //   const thisXpath = this.config.variableList.AbsXpath.substring(0, startIndex) + '[0]'
+                            //   const thisnode = this.workflow.jsonParser.getNode(thisXpath)
+                            //   if (thisnode) {
+                            //     list.unshift(this.config.variableList)
+                            //   }
+                            // } else {
+                            //   //当前循环项的xpath
+                            //   this.popIsLoadedState()
+                            //   let checkRes = false
+                            //   const actionItem = new ActionItem(this.config.variableList.AbsXpath, this.config.variableList.IsIFrame, this.config.variableList.IFrameAbsXPath)
+                            //   // 检测是否加载，如果加载后，那么会执行一次时长120的检测页面加载(成功后提前退出)
+                            //   // if ([FuncRetryType.IsLoaded, FuncRetryType.IsClick].indexOf(nowType) > -1) {
+                            //   //     checkRes = await this.retryCheckActionItem(this.id + '_IsLoaded_IsClick', actionItem, 120 * 1000)
+                            //   // } else {
+                            //   // 健壮性
+                            //   checkRes = await this.workflow.browser.existElement(actionItem)
+                            //   //如果存在
+                            //   if (!checkRes) {
+                            //                     checkRes = await this.awaitElement(actionItem)
+                            //   }
+                            //                 // 记录结果
+                            //                 var msg = '页面找不到循环的'
+                            //                 if (checkRes) {
+                            //                     list.unshift(this.config.variableList)
+                            //                     msg = '准备循环的'
+                            //   }
+                            //                 await this.varilableItemListCount()
+                        }
+                    }
+                }
+                break;
+            case "ScrollWeb" /* LoopType.ScrollWeb */:
+                {
+                    this.log(enums_1.LogKey.Loop.Begin.Scroll, this.name);
+                    list.unshift(['ScrollWeb']);
+                }
+                break;
+        }
+        this.setLoopValues(this.id, list);
+        this.finish();
+    }
+    leave() {
+        super.leave();
+        // 删除除去跳过本次循环
+        this.deleteIsSkipCurrentLoop(this.id);
+        this.isDoneFirst = false;
+        // this.workflow.emit('loop-completed')
+    }
+    /** 不固定元素循环列表的采集偏移量计算 */
+    async varilableItemListCount() {
+        this.setIdentifiedEachLoopExtractDataCount(this.id);
+        // let parentLoopCount = 0
+        // // (父级/爷爷级)循环是第几次循环
+        // const parentLoopAction = this.recursionGetParentLoopAction(this)
+        // let notDirectSkip = true
+        // let isScrollWeb = false
+        // if (parentLoopAction) {
+        //   parentLoopCount = this.getLoopCount(parentLoopAction.id)
+        //   const parentConfig = this.parent.config as LoopConfig
+        //   // 必须是在其父类的时候是FixedItem，单击的时候才做次判断
+        //   if (parentConfig.loopType == LoopType.ScrollWeb) {
+        //     isScrollWeb = true
+        //     notDirectSkip = parentConfig.disabledScrollAutoRemoveDuplication
+        //   } else if (parentConfig.loopType == LoopType.FixedItem && parentConfig.checkedJumpLoopClick) {
+        //     // 需要在任务配置勾选了【自动跳过无效的循环点击】选项才启用后面的【采样判断】
+        //     notDirectSkip = false
+        //   }
+        // }
+        // const configOptions = {
+        //   AbsXpath: this.config.variableList.AbsXpath,
+        //   IsIFrame: this.config.variableList.IsIFrame,
+        //   IFrameAbsXPath: this.config.variableList.IFrameAbsXPath,
+        //   newXpathStartIndex: this.getSomeLoopExtractDataCount(this.id),
+        // }
+        // // parentLoopCount 不固定元素循环列表，父循环的循环次数为1时，置零
+        // if (parentLoopCount === 1 || notDirectSkip || (!isScrollWeb && (await this.diffSamplingElements(this.id, configOptions)))) {
+        //   this.initSomeLoopExtractDataCount(this.id)
+        //   this.initIdentifiedEachLoopExtractDataCount(this.id)
+        //   this.initSamplingElementsMap(this.id)
+        //   this.initSampedLoopRecord()
+        //   this.initContinuousClickLoadNoNewDataCount(parentLoopAction?.id)
+        // } else {
+        //   // 根据上一次
+        //   this.setIdentifiedEachLoopExtractDataCount(this.id)
+        //   // 停止无效点击
+        //   // if (parentLoopAction && this.workflow.task.workflowSetting) {
+        //   //   const parentLoopActionConfig = parentLoopAction.config as LoopConfig
+        //   //   // 只有循环采集的父级循环循环类型是循环单个元素时，才进行停止无效点击加载更多判断
+        //   //   if (
+        //   //     parentLoopActionConfig &&
+        //   //     parentLoopActionConfig.loopType === LoopType.FixedItem &&
+        //   //     parentLoopActionConfig.checkedJumpLoopClick &&
+        //   //     parentLoopCount > this.workflow.task.workflowSetting.repeatPageLoopCount
+        //   //   ) {
+        //   //     // 判断是否有新数据
+        //   //     if (await this.ifNextElement(configOptions)) {
+        //   // this.initContinuousClickLoadNoNewDataCount(parentLoopAction.id)
+        //   //     } else {
+        //   // this.addContinuousClickLoadNoNewDataCount(parentLoopAction.id)
+        //   //     }
+        //   //     const noNewDataCount = this.getContinuousClickLoadNoNewDataCount(parentLoopAction.id)
+        //   //     if (noNewDataCount >= this.workflow.task.workflowSetting.continuousJudgeCount) {
+        //   //       // 跳过本轮采集
+        //   //       this.setIsSkipCurrentLoop(parentLoopAction.id, true)
+        //   //     }
+        //   //   }
+        //   // }
+        // }
+    }
+    /**
+     * 递归获取第一个(父级/爷爷级)循环节点
+     * @param action 当前节点
+     */
+    recursionGetParentLoopAction(action) {
+        if (action && action.parent && action.parent.type === 'LoopAction') {
+            return action.parent;
+        }
+        if (!action) {
+            return undefined;
+        }
+        return this.recursionGetParentLoopAction(action.parent);
+    }
+    /**
+     * 对比指定的不固定循环列表元素是否变化
+     * @param nodeId
+     * @param loopConfig
+     */
+    async diffSamplingElements(nodeId, loopConfig) {
+        if (this.getCurrentLoopUrl(nodeId)) {
+            // const url = this.workflow.browser.getURL()
+            // if (this.getCurrentLoopUrl(nodeId) != url) {
+            //   return true
+            // }
+        }
+        else {
+            return true;
+        }
+        const AbsXpath = loopConfig.AbsXpath;
+        const IsIFrame = loopConfig.IsIFrame;
+        const IFrameAbsXPath = loopConfig.IFrameAbsXPath;
+        const flag = false;
+        const samplingElementsMap = this.getSamplingElementsMap(nodeId);
+        // 这个时候可能请求没有结束
+        // if (this.workflow.browser.isWaitRequest()) {
+        //   //4秒等待
+        //   for (let i = 0; i < 20; i++) {
+        //     if (this.workflow.browser.isWaitRequest()) {
+        //       await this.sleep(200)
+        //       await this.checkPause()
+        //     } else {
+        //       break
+        //     }
+        //   }
+        // }
+        // if (samplingElementsMap.size > 0) {
+        //   for (const [key, value] of samplingElementsMap) {
+        //     const thisXpath = '(' + AbsXpath + ')[' + key + ']'
+        //     let curVal = await this.workflow.browser.getInnerText(new ActionItem(thisXpath, IsIFrame, IFrameAbsXPath))
+        //     /** 相似度比对  */
+        //     if (this.similar(value.replace(/[\r\n\s]/g, ''), curVal.replace(/[\r\n\s]/g, ''), 2) < 0.95) {
+        //       // 说明前面遍历过的元素有变动，将该轮循环的偏移量置零
+        //       // console.log(value.replace(/[\r\n]/g,'') +'--------不相同-------'+ curVal.replace(/[\r\n]/g,''))
+        //       flag = true //说明前面的列表数据有变化
+        //       break
+        //     }
+        //     /** 全比对  */
+        //     // if(value.replace(/[\r\n]/g,'') != curVal.replace(/[\r\n]/g,'')){
+        //     //     // 说明前面遍历过的元素有变动，将该轮循环的偏移量置零
+        //     //     console.log(value.replace(/[\r\n]/g,'') +'--------不相同-------'+ curVal.replace(/[\r\n]/g,''))
+        //     //     falg = true //说明前面的列表数据有变化
+        //     //     break;
+        //     // }
+        //   }
+        // }
+        return flag;
+    }
+    /**
+     * 辅助判断当前循环列表所依赖的列表元素是否有增加
+     * @param loopConfig
+     */
+    async ifNextElement(loopConfig, page) {
+        const { AbsXpath, IsIFrame, IFrameAbsXPath } = loopConfig;
+        const newXpathStartIndex = loopConfig.newXpathStartIndex;
+        //判断下一个循环的xpath对应元素是否存在，存在则把line重新压入队列中以使循环能够继续执行
+        const nextXpath = '(' + AbsXpath + ')[' + (newXpathStartIndex + 1) + ']';
+        const nextActionItem = new actionItem_1.ActionItem(nextXpath, IsIFrame, IFrameAbsXPath);
+        if (this.useExtensionBridge && page === this.page) {
+            const bridgeExists = await this.bridgeElementExists(page, nextActionItem, 500);
+            if (bridgeExists !== undefined) {
+                return bridgeExists;
+            }
+        }
+        return Boolean(await (0, Operations_1.queryElement)(nextActionItem, page));
+    }
+    /**
+     * 辅助判断字符串相似度
+     * @param s 字符串1
+     * @param t 字符串1
+     * @param f 精确度：保留几位小数
+     */
+    similar(s, t, f) {
+        if (s == '' && t == '') {
+            return 1;
+        }
+        if (!s || !t) {
+            return 0;
+        }
+        const l = s.length > t.length ? s.length : t.length;
+        const n = s.length;
+        const m = t.length;
+        const d = [];
+        f = f || 3;
+        const min = function (a, b, c) {
+            return a < b ? (a < c ? a : c) : b < c ? b : c;
+        };
+        let i, j, si, tj, cost;
+        if (n === 0)
+            return m;
+        if (m === 0)
+            return n;
+        for (i = 0; i <= n; i++) {
+            d[i] = [];
+            d[i][0] = i;
+        }
+        for (j = 0; j <= m; j++) {
+            d[0][j] = j;
+        }
+        for (i = 1; i <= n; i++) {
+            si = s.charAt(i - 1);
+            for (j = 1; j <= m; j++) {
+                tj = t.charAt(j - 1);
+                if (si === tj) {
+                    cost = 0;
+                }
+                else {
+                    cost = 1;
+                }
+                d[i][j] = min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+            }
+        }
+        const res = 1 - d[n][m] / l;
+        return res.toFixed(f);
+    }
+}
+exports.default = LoopAction;

package/node_modules/@octopus/engine/dist/actions/LoopStartAction.d.ts

@@ -0,0 +1,47 @@
+import LoopStartConfig from '../configs/LoopStartConfig';
+import BaseAction from './BaseAction';
+export default class LoopStartAction extends BaseAction {
+    config: LoopStartConfig;
+    private page;
+    private readLoopItemText;
+    private loopElementExists;
+    protected parseConfig(): LoopStartConfig;
+    wait(): Promise<void>;
+    loopXpathNextWait: Map<string, number>;
+    isWaitPathByMaxIndex(key: string, currentIndex: number): boolean;
+    /**
+     * 停止无效点击翻页判断
+     * @param parentid
+     * @param loopConfig
+     */
+    private stopInvalidClickPage;
+    /**
+     * 生成随机采样数据需要的数据坐标
+     * @param currentIndex  抽样前多少条数据条目（数据模板）
+     * @param m  抽样的数据条目
+     */
+    private getRandomArrayElements;
+    /**
+     * 指定循环采集数据步骤完成后进行数据采样并存储
+     * @param params
+     */
+    private cacheCurLoopSampleElenemts;
+    /**
+     * 对比指定的不固定循环列表元素是否变化
+     * @param nodeId
+     * @param loopConfig
+     */
+    private diffSamplingElements;
+    /**
+     * 辅助判断当前循环列表所依赖的列表元素是否有增加
+     * @param loopConfig
+     */
+    private ifNextElement;
+    /**
+     * 辅助判断字符串相似度
+     * @param s 字符串1
+     * @param t 字符串1
+     * @param f 精确度：保留几位小数
+     */
+    private similar;
+}