node-red 通过递归的方式遍历 OPC UA 服务器一个目录下的所有标签组中的标签

于 2024-07-06 10:18:58 发布
阅读量282 收藏 8
点赞数 5
分类专栏： Node-red 文章标签： 服务器 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunly_8081/article/details/140223906
版权

在这里插入图片描述
这个方法的思路和主要代码由GPT生成。
需要安装 “node-red-contrib-opcua” 包来使用 OPC UA Browser。
在这个示例流程中，我们使用了以下节点：

  1. Inject 节点（用来触发流程开始）：设置为每个流程启动时触发。
  2. OPC UA Browser 节点（用于获取目录信息）：配置 OPC UA 服务器连接和目录路径。
  3. Function 节点（用于处理目录信息）：用来解析 OPC UA Browser 返回的目录信息，并将标签名存储到一个数组中。
  4. Delay 节点（用于延迟发送标签组名）：将标签组名发送到 OPC UA Browser 之前添加一些延迟。
  5. Debug 节点（用于调试输出）：将标签名和标签组名输出到调试面板。

根据上边的流程截图创建流程，
Set browse address 按照图片样式设置一个需要办理访问的目录。
在这里插入图片描述

以下是 Function 节点 Decode & filter 的代码（用于解析目录信息并存储标签名）：
在这里插入图片描述

//这段代码根据GPT生成的代码修改得到的。
// 定义两个空数组，用于存储不同类型的nodeId
var X_nodeIds = flow.get('X_nodeIds1') || [];
var nodeIds = flow.get('nodeIds1') || [];

// 获取消息中的节点数组
var items = msg.payload;

// 遍历节点数组中的每一个节点
for (var i = 0; i < items.length; i++) {
    var item = items[i];
    var ref = item.item;
    var nodeClass = ref.nodeClass;
    var typeDef = ref.typeDefinition;
    var bname = ref.browseName;
    var ns = bname.namespaceIndex;
    var name = bname.name;
    var nodeId = ref.nodeId;
    var NodeId_str = nodeId.toString();

    // 检查并跳过不满足条件的nodeId
    if (NodeId_str.includes('._') || NodeId_str.match(/^.*=_/) || NodeId_str.match('.V4') || NodeId_str.match('.@')) {
        continue;
    }

    // 根据不同的条件创建并发送消息
    if (ns === 2) {
        if (nodeClass === 1) { // 条件一：命名空间索引为2且nodeClass为1的节点
            var newmsgX = { topic: nodeId, payload: "", actiontype: 'browse' };
            // 发送第一个类型的消息
            node.send([null, newmsgX]);
            X_nodeIds.push(nodeId);
        } else if (nodeClass === 2) { // 条件二：命名空间索引为2且nodeClass为2的节点
            var newmsgY = { topic: nodeId, payload: "", actiontype: 'browse' };
            // 发送第二个类型的消息
            node.send([newmsgY, null]);
            nodeIds.push(nodeId);
        }
    }
}

// 将更新后的数组存储回flow上下文
flow.set('X_nodeIds1', X_nodeIds);
flow.set('nodeIds1', nodeIds);

// 不返回任何消息，直接通过send方法发送
return null;

请根据实际情况修改 OPC UA Browser 节点和 Delay 节点的配置，部署这个流程后。每次运行流程时，它都会遍历整个目录，将标签名保存在数组中，并将标签组名发送回 OPC UA Browser 节点进行下一次遍历。

以下是 Function 节点 （清除所有 flow 范围内的变量） 的代码（用于清除所有 flow 范围内的变量），这段代码由GPT生成：

// 清除所有 flow 范围内的变量
var keys = flow.keys(); // 获取所有存储的 keys
for (var i = 0; i < keys.length; i++) { // 遍历所有 keys
    flow.set(keys[i], undefined); // 将每个 key 对应的值设置为 undefined
}

// 验证是否清除成功
var clearedKeys = flow.keys(); // 再次获取所有存储的 keys
if (clearedKeys.length === 0) {
    node.warn("Flow context successfully cleared."); // 输出成功信息
    msg.payload = "Flow context successfully cleared."; // 设置 msg.payload 为成功信息
} else {
    node.warn("Failed to clear flow context. Remaining keys: " + clearedKeys); // 输出失败信息和剩余的 keys
    msg.payload = "Failed to clear flow context. Remaining keys: " + clearedKeys; // 设置 msg.payload 为失败信息和剩余的 keys
}

return msg; // 返回 msg

以下是 Function 节点 （Show Final Node IDs） 的代码（使用Debug输出显示所有标签名），这段代码由GPT生成：

// 获取 flow 上下文中的 nodeIds 数组
var finalNodeIds = flow.get('nodeIds1') || [];
// 将最终的 nodeIds 数组赋值给 msg.payload
msg.payload = finalNodeIds;
// 返回 msg 以显示最终的 nodeIds 数组
// return msg;

//这段代码本来到 return msg; 就结束了，但是当 数组长度超过1000时，Debug显示不出超过 1000 的元素，又增加了下边的代码改为一次最多输出1000个元素，临时解决了问题。

//   // 获取要发送的数组
//   const finalNodeIds = msg.payload;

  // 设置每次发送的元素数量
  const chunkSize = 1000;

  // 初始化起始索引和结束索引
  let startIndex = 0;
  let endIndex = chunkSize;

  // 循环发送所有元素
  while (startIndex < finalNodeIds.length) {
    // 获取当前批次的元素
    const chunk = finalNodeIds.slice(startIndex, endIndex);

    // 创建新的消息，并将当前批次的元素作为有效载荷发送
    node.send({
      payload: chunk
    });

    // 更新起始索引和结束索引，指向下一个批次
    startIndex += chunkSize;
    endIndex += chunkSize;
  }

最后，这是这个流程导出的JSON，可以直接在Node-red中尝试导入。

[
    {
        "id": "28c02a8fd3c52bbf",
        "type": "OpcUa-Browser",
        "z": "bc19e3cc51a9a215",
        "endpoint": "bfd4fb1d3827c759",
        "item": "",
        "datatype": "",
        "topic": "",
        "items": [],
        "name": "",
        "x": 530,
        "y": 60,
        "wires": [
            [
                "02fb5a0d042755b9",
                "33625a091b088e5a"
            ]
        ]
    },
    {
        "id": "e2cf37bc11c2ee19",
        "type": "inject",
        "z": "bc19e3cc51a9a215",
        "name": "Browse",
        "props": [
            {
                "p": "payload"
            },
            {
                "p": "topic",
                "vt": "str"
            }
        ],
        "repeat": "",
        "crontab": "",
        "once": true,
        "onceDelay": "",
        "topic": "",
        "payload": "",
        "payloadType": "str",
        "x": 100,
        "y": 60,
        "wires": [
            [
                "c209a0a4da4b3a2e",
                "f736f71918e2182c"
            ]
        ]
    },
    {
        "id": "c209a0a4da4b3a2e",
        "type": "function",
        "z": "bc19e3cc51a9a215",
        "name": "Set browse address",
        "func": "// msg.topic='ns=2;s=DL_S1.D1';\nmsg.topic='ns=0;i=85';\nmsg.actiontype='browse';\nreturn msg;",
        "outputs": 1,
        "timeout": "",
        "noerr": 0,
        "initialize": "",
        "finalize": "",
        "libs": [],
        "x": 280,
        "y": 60,
        "wires": [
            [
                "28c02a8fd3c52bbf"
            ]
        ]
    },
    {
        "id": "b9012b8c7084df40",
        "type": "debug",
        "z": "bc19e3cc51a9a215",
        "name": "目录debug 54",
        "active": true,
        "tosidebar": true,
        "console": false,
        "tostatus": false,
        "complete": "payload",
        "targetType": "msg",
        "statusVal": "",
        "statusType": "auto",
        "x": 820,
        "y": 260,
        "wires": []
    },
    {
        "id": "1bbfe2859a040f28",
        "type": "delay",
        "z": "bc19e3cc51a9a215",
        "name": "",
        "pauseType": "rate",
        "timeout": "10",
        "timeoutUnits": "seconds",
        "rate": "1",
        "nbRateUnits": "5",
        "rateUnits": "second",
        "randomFirst": "1",
        "randomLast": "5",
        "randomUnits": "seconds",
        "drop": false,
        "allowrate": false,
        "outputs": 1,
        "x": 680,
        "y": 180,
        "wires": [
            [
                "28c02a8fd3c52bbf",
                "b9012b8c7084df40"
            ]
        ]
    },
    {
        "id": "02fb5a0d042755b9",
        "type": "debug",
        "z": "bc19e3cc51a9a215",
        "name": "debug 55",
        "active": false,
        "tosidebar": true,
        "console": false,
        "tostatus": false,
        "complete": "false",
        "statusVal": "",
        "statusType": "auto",
        "x": 820,
        "y": 60,
        "wires": []
    },
    {
        "id": "724b8fae9ad64826",
        "type": "debug",
        "z": "bc19e3cc51a9a215",
        "name": "变量debug 56",
        "active": true,
        "tosidebar": true,
        "console": false,
        "tostatus": false,
        "complete": "payload",
        "targetType": "msg",
        "statusVal": "",
        "statusType": "auto",
        "x": 840,
        "y": 100,
        "wires": []
    },
    {
        "id": "33625a091b088e5a",
        "type": "delay",
        "z": "bc19e3cc51a9a215",
        "name": "",
        "pauseType": "rate",
        "timeout": "10",
        "timeoutUnits": "seconds",
        "rate": "1",
        "nbRateUnits": "1",
        "rateUnits": "second",
        "randomFirst": "1",
        "randomLast": "5",
        "randomUnits": "seconds",
        "drop": false,
        "allowrate": false,
        "outputs": 1,
        "x": 310,
        "y": 180,
        "wires": [
            [
                "e204381af2d34de2"
            ]
        ]
    },
    {
        "id": "e204381af2d34de2",
        "type": "function",
        "z": "bc19e3cc51a9a215",
        "name": "Decode & filter",
        "func": "// 定义两个空数组，用于存储不同类型的nodeId\nvar X_nodeIds = flow.get('X_nodeIds1') || [];\nvar nodeIds = flow.get('nodeIds1') || [];\n\n// 获取消息中的节点数组\nvar items = msg.payload;\n\n// 遍历节点数组中的每一个节点\nfor (var i = 0; i < items.length; i++) {\n    var item = items[i];\n    var ref = item.item;\n    var nodeClass = ref.nodeClass;\n    var typeDef = ref.typeDefinition;\n    var bname = ref.browseName;\n    var ns = bname.namespaceIndex;\n    var name = bname.name;\n    var nodeId = ref.nodeId;\n    var NodeId_str = nodeId.toString();\n\n    // 检查并跳过不满足条件的nodeId\n    if (NodeId_str.includes('._') || NodeId_str.match(/^.*=_/) || NodeId_str.match('.V4') || NodeId_str.match('.@')) {\n        continue;\n    }\n\n    // 根据不同的条件创建并发送消息\n    if (ns === 2) {\n        if (nodeClass === 1) { // 条件一：命名空间索引为2且nodeClass为1的节点\n            var newmsgX = { topic: nodeId, payload: \"\", actiontype: 'browse' };\n            // 发送第一个类型的消息\n            node.send([null, newmsgX]);\n            X_nodeIds.push(nodeId);\n        } else if (nodeClass === 2) { // 条件二：命名空间索引为2且nodeClass为2的节点\n            var newmsgY = { topic: nodeId, payload: \"\", actiontype: 'browse' };\n            // 发送第二个类型的消息\n            node.send([newmsgY, null]);\n            nodeIds.push(nodeId);\n        }\n    }\n}\n\n// 将更新后的数组存储回flow上下文\nflow.set('X_nodeIds1', X_nodeIds);\nflow.set('nodeIds1', nodeIds);\n\n// 不返回任何消息，直接通过send方法发送\nreturn null;",
        "outputs": 2,
        "timeout": 0,
        "noerr": 0,
        "initialize": "",
        "finalize": "",
        "libs": [],
        "x": 480,
        "y": 180,
        "wires": [
            [
                "724b8fae9ad64826"
            ],
            [
                "1bbfe2859a040f28"
            ]
        ]
    },
    {
        "id": "a14762e716eb88fd",
        "type": "inject",
        "z": "bc19e3cc51a9a215",
        "name": "Show Final IDs",
        "props": [
            {
                "p": "payload"
            }
        ],
        "repeat": "",
        "crontab": "",
        "once": false,
        "onceDelay": 0.1,
        "topic": "",
        "payload": "",
        "payloadType": "date",
        "x": 120,
        "y": 320,
        "wires": [
            [
                "e656c50f0dcef8aa"
            ]
        ]
    },
    {
        "id": "e656c50f0dcef8aa",
        "type": "function",
        "z": "bc19e3cc51a9a215",
        "name": "Show Final Node IDs",
        "func": "// 获取 flow 上下文中的 nodeIds 数组\nvar finalNodeIds = flow.get('nodeIds1') || [];\n// 将最终的 nodeIds 数组赋值给 msg.payload\nmsg.payload = finalNodeIds;\n// 返回 msg 以显示最终的 nodeIds 数组\n// return msg;\n\n\n//   // 获取要发送的数组\n//   const finalNodeIds = msg.payload;\n\n  // 设置每次发送的元素数量\n  const chunkSize = 1000;\n\n  // 初始化起始索引和结束索引\n  let startIndex = 0;\n  let endIndex = chunkSize;\n\n  // 循环发送所有元素\n  while (startIndex < finalNodeIds.length) {\n    // 获取当前批次的元素\n    const chunk = finalNodeIds.slice(startIndex, endIndex);\n\n    // 创建新的消息，并将当前批次的元素作为有效载荷发送\n    node.send({\n      payload: chunk\n    });\n\n    // 更新起始索引和结束索引，指向下一个批次\n    startIndex += chunkSize;\n    endIndex += chunkSize;\n  }\n\n",
        "outputs": 1,
        "timeout": "",
        "noerr": 0,
        "initialize": "",
        "finalize": "",
        "libs": [],
        "x": 420,
        "y": 320,
        "wires": [
            [
                "3fbf36f8f6fdfc80"
            ]
        ]
    },
    {
        "id": "3fbf36f8f6fdfc80",
        "type": "debug",
        "z": "bc19e3cc51a9a215",
        "name": "变量地址",
        "active": true,
        "tosidebar": true,
        "console": false,
        "tostatus": false,
        "complete": "payload",
        "targetType": "msg",
        "statusVal": "",
        "statusType": "auto",
        "x": 700,
        "y": 320,
        "wires": []
    },
    {
        "id": "f736f71918e2182c",
        "type": "function",
        "z": "bc19e3cc51a9a215",
        "name": "清除所有 flow 范围内的变量",
        "func": "// 清除所有 flow 范围内的变量\nvar keys = flow.keys(); // 获取所有存储的 keys\nfor (var i = 0; i < keys.length; i++) { // 遍历所有 keys\n    flow.set(keys[i], undefined); // 将每个 key 对应的值设置为 undefined\n}\n\n// 验证是否清除成功\nvar clearedKeys = flow.keys(); // 再次获取所有存储的 keys\nif (clearedKeys.length === 0) {\n    node.warn(\"Flow context successfully cleared.\"); // 输出成功信息\n    msg.payload = \"Flow context successfully cleared.\"; // 设置 msg.payload 为成功信息\n} else {\n    node.warn(\"Failed to clear flow context. Remaining keys: \" + clearedKeys); // 输出失败信息和剩余的 keys\n    msg.payload = \"Failed to clear flow context. Remaining keys: \" + clearedKeys; // 设置 msg.payload 为失败信息和剩余的 keys\n}\n\nreturn msg; // 返回 msg",
        "outputs": 1,
        "timeout": "",
        "noerr": 0,
        "initialize": "",
        "finalize": "",
        "libs": [],
        "x": 360,
        "y": 280,
        "wires": [
            []
        ]
    },
    {
        "id": "b7e1628c12f76bda",
        "type": "inject",
        "z": "bc19e3cc51a9a215",
        "name": "清理",
        "props": [
            {
                "p": "payload"
            },
            {
                "p": "topic",
                "vt": "str"
            }
        ],
        "repeat": "",
        "crontab": "",
        "once": false,
        "onceDelay": 0.1,
        "topic": "",
        "payload": "",
        "payloadType": "date",
        "x": 90,
        "y": 280,
        "wires": [
            [
                "f736f71918e2182c"
            ]
        ]
    },
    {
        "id": "bfd4fb1d3827c759",
        "type": "OpcUa-Endpoint",
        "endpoint": "opc.tcp://SJ-KEPSer-01:49320",
        "secpol": "None",
        "secmode": "None",
        "none": true,
        "login": false,
        "usercert": false,
        "usercertificate": "",
        "userprivatekey": ""
    }
]

有一个问题没有解决，就是第一次点击部署，程序就开始运行，但是会出想非常多的重复标签，等程序运行完成后再次点击inject节点Browse，这次运行的结果是根预期的一样。
不知道是哪里的问题

sunly_8081
关注
  • 5
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Node-RED系列（二八）：基于OPC UA节点与西门子PLC进行通讯
知无涯
06-28 3850
西门子PLC是一个很常用的协议，在Node-RED中也有类似的节点支持该协议，与硬件进行通信。下面就来介绍一下基于OPC UA节点与西门子PLC进行通讯。安装节点：node-red-contrib-opcua包含的节点如下： 模块官方文档介绍：用法：使用 OpcUa-Item 定义变量。 使用 OpcUa-Client 读取/写入/订阅/浏览 OPC UA 服务器。编写node-red OPC UA 读写变量的程序：由于手头没有硬件：因此采用软件模拟的方式来实现：Kepware KepServer模拟出一个
数据结构（十三） -- C语言版 -- 树 - 二叉树的遍历（递归、非递归）
青椒*^_^*凤爪爪的博客
05-23 7856
二叉树是一种非线性的数据结构，在怼他进行操作时，总是需要注意对每个元素进行操作，这样就存在一个操作的顺序的问题，由此提出二叉树的遍历的操作。 所谓二叉树的遍历就是按照一定的顺序访问二叉树的每一个节点一次且仅一次的过程，这里的访问可以是输出、比较、更新、查看元素内容等等操作。
Node-Red系列教程——NodeRed订阅opcua数据，并通过mqtt发布
鲸鱼姐的专栏
10-03 5248
1.nodered订阅opcua数据 2. nodered发布为mqtt 3. 部署运行结果，通过emqx接收数据 4. nodered的json代码
node-red 读取OPCUA数据存储到SQLServer中
最新发布
sunly_8081的博客
07-05 653
首先，您需要安装node-red-contrib-opcua和node-red-contrib-mssql-plus节点，以便使用OPC UA Client获取OPC变量值，连接SQLServer。把获得的OPC UA 的值传送到 function（数据处理flow）中，把变量和值，成对的存放到flow中的数组变量中。这是就能在数据库中看到已经创建了新的表，表名是变量地址，每个变量一个表，表中已经有了插入的数据。然后，您可以使用Inject节点（OPC采集）作为触发器，用于定期采集OPC变量值。
node-red-contrib-opcua:一个用于通信OPC UA的Node-RED节点。 使用节点操作库
05-13
节点红色贡献 节点通过进行通信或服务。 基于 安装 在Node-RED安装目录上运行命令。 npm install node-red-contrib-opcua 或运行命令进行全局安装。 npm install -g node-red-contrib-opcua 用法 使用OpcUa-Item定义变量。 使用OpcUa-Client读取/写入/订阅/浏览OPC UA服务器。 请参阅“下的一些流程。 更新的服务器子流示例OPCUA-TEST-NODES.json查找命令：addFolder，AddVariable，setFolder。 在这里，您已经准备好使用示例。 您可以使用右上角菜单中的“在Node-RED中导入”。 可将Schneider IGSS和Prosys Simulation Server作为Node-RED流的示例。 在以下搜索OPC UA： http ： /
node-red opc-ua节点操作
weixin_44462773的博客
10-08 813
node-red的opc-ua节点操作说明
Node-red 基于IIoT模块（node-red-contrib-iiot-opcua）的节拍采集应用
Juuzumaru的博客
03-06 562
node-red通过opc协议实时采集设备数据
NodeRED学习（三）OPC UA
qq_32812063的博客
04-09 2365
1、在任务栏Kepware应用右键找到OPC UA 配置：opc.tcp://192.168.10.12:493202、在kepServerEx单击项目，在属性编辑器里的OPCUA选项里，允许匿名登录选择“是”3、点击任务栏的Kepware，选择重新初始化（不初始化好像也可以，客户端会报错）
Node.js 使用递归实现遍历文件夹中所有文件
01-02
遍历完目录中的所有文件为止 代码中用到的几个方法 path.resolve(path) 一个路径或路径片段解析成一个绝对路径，返回解析后的路径字符串 fs.readdir(path[,option],callback) 读取目录下面的文件，返回目录下的文件...
Node.js：实现遍历文件夹下所有文件
彭世瑜的博客
08-08 2236
Node.js：实现遍历文件夹。
前端开源库-node-opcua-pki
08-30
前端开源库-node-opcua-pki节点opcua pki，节点opcua的pki管理
前端开源库-node-opcua-crypto
08-30
前端开源库-node-opcua-crypto节点opcua加密，用于节点opcua的加密工具
node-opcua-sample:一个简单的OPCUA示例客户端，以演示如何使用节点opcua SDK
05-15
结点样本 一个简单的OPCUA示例客户端，以演示如何使用 SDK。 该样品带有3种口味 带有异步/等待支持的打字稿 $ npm install ts-node -g $ ts-node simple_client_ts.ts 支持async / await的最新nodejs版本（es2017） $ node simple_client_es18.js 旧的nodejs（8.0版） this version uses the old callback back mechanism which is not recommended anymore $ git clone https://github.com/node-opcua/node-opcua-sample $ cd node-opcua-sample $ npm install $ node simple_client.js
node-opcua：完全用javascript和nodejs编写的OPC UA堆栈的实现-http：node-opcua.github.io
02-04
结点 node-opcua是完全用Typescript为NodeJS编写的OPC UA堆栈的实现。 是在上运行的OPC-UA堆栈。 为什么选择NodeJS？ 因为nodeJs是设计异步应用程序的绝佳框架。 入门 将node-opcua安装为节点软件包 $ mkdir mytest $ cd mytest $ npm init $ npm install node-opcua --unsafe-perms $ # create your first app.js file ! 将node-opcua示例安装为节点软件包 $ mkdir myserver $ cd myserver $ n
java递归和非递归方式遍历所有文件和目录
第七宇林的博客
06-25 2688
java递归和非递归方式遍历所有文件和目录
C++-二叉树递归遍历与非递归遍历实现
席木木的博客
10-24 3598
-二叉树递归遍历与非递归遍历实现引言0 有关线性表结点定义-LinkNode1 栈的链式存储结构实现-LinkedStack2 队列的链式存储结构实现-LinkedQueue3 二叉树的链式存储结构实现3.1 树的结点定义-TreeNode3.2 二叉树定义3.3 前中后序遍历-递归算法实现3.4 前中后序遍历-非递归算法实现3.5 层序遍历算法实现4 代码测试5 测试结果 引言     二叉树的遍历方法有：前序遍历、中序遍历、后序遍历、层序遍历，其中前中后序遍历又有
第二章 NODE-RED opc-ua 节点使用
顾西昂的博客
04-26 857
物联网平台中经常会遇到集成Node-RED开源项目，Node-RED是基于Node.js构建的轻量级开源工具，可以低成本的连接设备获取设备数据。
基于Node Red的OPC UA节点与NX MCD的数据交互实现远程控制和实时监控
CiQkThJTG的博客
04-23 558
在Node-RED中，通过将各种功能节点进行连接和配置，可以灵活地创建物联网应用。通过使用OPC UA节点，我们可以方便地建立与OPC UA服务器的连接，实现数据的读取和写入。总之，通过利用Node-RED的OPC UA节点和NX MCD，我们可以实现便捷的数据交互和控制。通过拖拽和配置各种可视化节点，我们可以自定义界面布局，并与OPC UA节点和NX MCD节点进行数据交互。通过node Red的OPC UA节点，使用OPC UA server节点建立服务，量NX MCD作为客户端实现数据的交互。
在node.js中如何递归遍历指定目录？
06-06
在node.js中递归遍历指定目录可以使用`fs`模块中的`readdirSync`和`statSync`方法实现，具体步骤如下： 1. 使用`readdirSync`方法获取指定目录下所有文件和子目录的名称数组。 2. 遍历名称数组，使用`statSync`方法获取每个文件和目录的详细信息，判断是否是目录。 3. 如果是目录，则递归调用当前方法，传入子目录路径进行遍历。 4. 如果是文件，则可以进行其他操作，比如读取文件内容等。 下面是一个示例代码： ```javascript const fs = require('fs'); const path = require('path'); function traverseDir(dirPath) { const files = fs.readdirSync(dirPath); for (let i = 0; i < files.length; i++) { const filePath = path.join(dirPath, files[i]); const stat = fs.statSync(filePath); if (stat.isDirectory()) { // 递归遍历子目录 traverseDir(filePath); } else { // 处理文件 console.log(filePath); } } } // 示例：遍历当前目录下的所有文件和子目录 traverseDir('.'); ``` 需要注意的是，以上代码仅用于演示递归遍历目录的基本思路，实际应用中还需要考虑一些细节问题，比如异常处理、异步遍历等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值