前端点滴（Node.js）（五）---- 构建 Web 应用（三）路由

最新推荐文章于 2024-03-26 20:34:47 发布
置顶 最新推荐文章于 2024-03-26 20:34:47 发布
阅读量245 收藏 1
点赞数
分类专栏： Node.js 文章标签： node.js javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/errrl/article/details/104314117
版权

3. 路由解析

前文提及了很多Web请求的预处理过程，对于不同的业务，我们还是期望有不同的处理方式，这带来了路由的选择问题。

（1）文件路径型

1. 静态文件

这种方式的路由在路径解析的部分有过简单的描述，其让人舒服的地方在于URL的路径与网站目录的路径一致，无需转换，非常直观。这种路由的处理方式也十分简单，将请求对应的文件发送给客户端即可。这在前文路劲解析部分有过介绍，不再重复。

2. 动态文件

在MVC模式流行起来之前，根据文件的路径执行动态脚本也是基本的路由方式，它的处理原则是Web服务器根据URL路径找到对应的文件， 比如/index.php或者/index.asp。Web服务器根据文件名后缀去寻找脚本的解析器，并传入HTTP请求的上下文。

解析器执行脚本，并输出响应报文，达到完成服务的目的。现在大多数的服务器都能很明智地根据后缀同时服务动态或静态文件，这种方式不太适用于node，主要原因就是文件的后缀名都是js ，分不清是后端脚本还是前端脚本，这可不是什么 好的设计，而且node中的Web服务器与对应业务脚本是一体的，无需按照这种方式实现。

（2）MVC（重点）

在MVC流行之前，主流的处理方式就是通过文件的路径进行处理，甚至以为是常态。直到有一天开发者发现用户请求的URL路径原来可以跟具体脚本所在的路径没有任何的关系。

MVC模型的主要思想是将业务逻辑按照职责分离，主要分为以下几种：

  • 控制器（Controller）（C层），一组行为的集合。
  • 模型（Model）（M层），数据相关的操作和封装。
  • 试图（View）（V层），视图的渲染。

这是目前最为经典的分层模式，大致而言，它的工作模式就是：

  • 路由的解析，根据URL寻找对应的控制器和行为。
  • 行为调用相关的模型，进行数据操作。
  • 数据操作结束后，调用试图与相关数据进行页面渲染，输出到客户端。

如何根据URL做路由映射，这里有两个分支实现。一、手工关联映射；二、自然关联映射。前者会有一个对应的路由文件将URL映射到对应的控制器，后者没有这样的文件。

路由的映射（接口的实现）

先来解释一下什么是路由映射：

1. 首先我们要理解MVC中路由的作用：url Routing的作用是将浏览器的URL请求映射到特定的MVC控制器动作。

2. 当我们访问http://localhost:8080/Home/Index 这个地址的时候，请求首先被UrlRoutingModule截获，截获请求后，从Routes中得到与当前请求URL相符合的RouteData对象，将RouteData对象和当前URL封装成一个RequestContext对象，然后从RequestContext封装的RouteData中得到 Controller名字，根据Controller的名字，通过反射创建控制器对象，这个时候控制器才真正被激活，最后去执行控制器里面对应的 Action。

路由处理流程：

（1）手动映射

  • 手动映射的实现

具体代码：

var routes = [];  // 生成的router 所保存的位置
/*****路由配置文件,(可以用单独的模块配置然后require),这就是所谓的接口配置*****/
var http = require('http');
var url = require('url');
var server = http.createServer();
/* 模拟路径,将url路径映射到对应的action中 */
var routes_config = [
    {
        path: "/user/get",
        ctrl: (req, res) => res.end("path=user/get")
    },
    {
        path: "/user/post",
        ctrl: (req, res) => res.end("path=user/post")
    }
];

// 设置路由方法
function setRoutes(path, action) {
    routes.push([path, action])
}

routes_config.forEach((item, index) => {
    setRoutes(item.path, item.ctrl);
})
server.on('request', function (req, res) {
    var pathname = url.parse(req.url).pathname;
    for (var i = 0; i < routes.length; i++) {
        var route = routes[i];
        if (route[0] == pathname) {
            var action = route[1];
            action(req, res);
            return;
        }
    }
    function res404(req, res) {
        res.end("404");
    }
    // 错误路由处理
    res404(req, res);
}).listen(8000,()=>{
    console.log('server is create')
})

手工映射十分方便，由于它对URL十分灵活，按照业务需求可以在routes_config配置更多的路由，以更好地实现任务。

不过通常我们会将文件分开成两部分以便于操作：

router.js：

var routes = [];  // 生成的router 所保存的位置
/*****路由配置文件,(可以用单独的模块配置然后require),这就是所谓的接口配置*****/

var routes_config = [
    {
        path: "/user/get",
        ctrl: (req, res) => res.end("path=user/get")
    },
    {
        path: "/user/post",
        ctrl: (req, res) => res.end("path=user/post")
    }
];

// 设置路由方法
function setRoutes(path, action) {
    routes.push([path, action])
}

routes_config.forEach((item, index) => {
    setRoutes(item.path, item.ctrl);
})

module.exports.routes = routes;

luyou.js：

var r = require('./router');

var http = require('http');
var url = require('url');
var server = http.createServer();

server.on('request', function (req, res) {
    var pathname = url.parse(req.url).pathname;
    for (var i = 0; i < r.routes.length; i++) {
        var route = r.routes[i];
        if (route[0] == pathname) {
            var action = route[1];
            action(req, res);
            return;
        }
    }
    function res404(req, res) {
        res.end("404");
    }
    // 错误路由处理
    res404(req, res);
}).listen(8000,()=>{
    console.log('server is create')
})

对于简单的路径采用上面的方法是可以解决问题的，但是路径一旦复杂上述配置映射就显得和吃力。

所以采用正则来进行匹配

zzrouter.js：

var routes = [];  // 生成的router 所保存的位置
/*****路由配置文件,(可以用单独的模块配置然后require),这就是所谓的接口配置*****/

var routes_config = [
    {
        path: "/user/:username/id/:id",
        ctrl: (req, res) => {
            console.log(req.url)
            res.end()
            // ...... ToDo
        }
    },
    {
        path: "/user.:ext",
        ctrl: (req, res) => {
            console.log(req.url)
            res.end()
            // ...... ToDo
        }
    }
];


var pathRegexp = function (path) {
    let strict = path
    path = path
        .concat(strict ? '' : '/?')
        .replace(/\/\(/g, '(?:/')
        .replace(/(\/)?(\.)?:(\w+)(?:(\(.*?\)))?(\?)?(\*)?/g, function (_, slash, format, key, capture,
            optional, star) {
            slash = slash || '';
            return ''
                + (optional ? '' : slash)
                + '(?:'
                + (optional ? slash : '')
                + (format || '') + (capture || (format && '([^/.]+?)' || '([^/]+?)')) + ')'
                + (optional || '')
                + (star ? '(/*)?' : '');
        })
        .replace(/([\/.])/g, '\\$1')
        .replace(/\*/g, '(.*)');
    return new RegExp('^' + path + '$');
}

// 设置路由方法
function setRoutes(path, action) {
    routes.push([path, action])
}

routes_config.forEach((item, index) => {
    setRoutes(pathRegexp(item.path), item.ctrl);
})

module.exports.routes = routes;

zzluyou.js：

var r = require('./zzrouter');

var http = require('http');
var url = require('url');
var server = http.createServer();

server.on('request', function (req, res) {
    var pathname = url.parse(req.url).pathname;
    for (var i = 0; i < r.routes.length; i++) {
        var route = r.routes[i];
        if (route[0].exec(pathname)) {
            var action = route[1];
            action(req, res);
            return;
        }
    }
    function res404(req, res) {
        res.end("404");
    }
    // 错误路由处理
    res404(req, res);
}).listen(8000, () => {
    console.log('server is create')
})

结果：

 

  • 参数解析

尽管完成了正则匹配，可以实现相似URL的匹配，但是:username到底匹配了啥，还没有解决。为此我们还需要进一步将匹配到的内容抽取出来，希望在业务中能如下这样调用：

{
    path: "/user/:username",
    ctrl: (req, res) => {
        var username = req.params.username;   
        console.log(username)
        res.end()
        // ...... ToDo
    }
},

这里的目标是将抽取的内容设置到req.params处。那么第一步就是将键值抽取出来，如下所示：

修改 zzrouter.js：

module.exports.routes = routes;

var routes = [];  // 生成的router 所保存的位置
/*****路由配置文件,(可以用单独的模块配置然后require),这就是所谓的接口配置*****/

var routes_config = [
    {
        path: "/user/:username/id/:id",
        ctrl: (req, res) => {
            var pa = req.params;
            console.log(pa)  //=>  { username: 'username', id: '1' }
            res.end()
            // ...... ToDo
        }
    },
    {
        path: "/user.:ext",
        ctrl: (req, res) => {
            var username = req.params.username;
            console.log(username)
            res.end()
            // ...... ToDo
        }
    }
];


var pathRegexp = function (path) {
    let strict = path
    const keys = [];
    path = path
        .concat(strict ? '' : '/?')
        .replace(/\/\(/g, '(?:/')
        .replace(/(\/)?(\.)?:(\w+)(?:(\(.*?\)))?(\?)?(\*)?/g, function (_, slash, format, key, capture, optional, star) {
            // 将匹配到的键值保存起来
            keys.push(key);
            slash = slash || '';
            return ''
                + (optional ? '' : slash)
                + '(?:'
                + (optional ? slash : '')
                + (format || '') + (capture || (format && '([^/.]+?)' || '([^/]+?)')) + ')'
                + (optional || '')
                + (star ? '(/*)?' : '');
        })
        .replace(/([\/.])/g, '\\$1')
        .replace(/\*/g, '(.*)');
    return {
        keys: keys,
        regexp: new RegExp('^' + path + '$')
    };
}

// 设置路由方法
function setRoutes(path, action) {
    routes.push([path, action])
}

routes_config.forEach((item, index) => {
    setRoutes(pathRegexp(item.path), item.ctrl);
})

module.exports.routes = routes;

修改 zzluyou.js：

var r = require('./zzrouter');

var http = require('http');
var url = require('url');
var server = http.createServer();

server.on('request', function (req, res) {
    var pathname = url.parse(req.url).pathname;
    for (var i = 0; i < r.routes.length; i++) {
        var route = r.routes[i];
        // 正则匹配
        var reg = route[0].regexp;
        var keys = route[0].keys;
        var matched = reg.exec(pathname);
        if (matched) {
            // 抽取具体值
            var params = {};
            for (var i = 0, l = keys.length; i < l; i++) {
                var value = matched[i + 1];
                if (value) {
                    params[keys[i]] = value;
                }
            }
            req.params = params;
            var action = route[1];
            action(req, res);
            return;
        }
    }
    // 处理404请求
    function res404(req, res) {
        res.end("404");
    }
    // 错误路由处理
    res404(req, res);
}).listen(8000, () => {
    console.log('server is create')
})

结果：

至此，我们除了从查询字符串（req.query）或提交数据（req.body）中取到值外，还能从路径的映射里取到值。

（2）自然映射

略...

（3）RESTful

MVC模式大行其道了很多年，直到RESTful的流行，大家才意识到URL也可以设计得很规范，请求方法也能作为逻辑分发的单元。

REST的全称是Representational State Transfer，中文含义为表现层状态转化。符合REST规范的设计，我们称为RESTful设计。它的设计哲学主要将服务器端提供的内容实体看作一个资源， 并表现在URL上。

比如一个用户的地址如下所示：

/users/Errrl

这个地址代表了一个资源，对这个资源的操作，主要体现在HTTP请求方法上，不是体现在URL上。过去我们对用户的增删改查或许是如下这样设计URL的：

POST /user/add?username=Errrl
GET /user/remove?username=Errrl
POST /user/update?username=Errrl
GET /user/get?username=Errrl

操作行为主要体现在行为上，主要使用的请求方法是POST和GET。在RESTful设计中，它是如下这样的：

POST /users/Errrl
DELETE /users/Errrl
PUT /users/Errrl
GET /users/Errrl

它将DELETE和PUT请求方法引入设计中，参与资源的操作和更改资源的状态。

对于这个资源的具体表现形态，也不再如过去一样表现在URL的文件后缀上。过去设计资源的格式与后缀有很大的关联，例如：

GET /users/test.json
GET /users/test.xml

在RESTful设计中，资源的具体格式由请求报头中的Accept字段和服务器端的支持情况来决定。如果客户端同时接受JSON和XML格式的响应，那么它的Accept字段值是如下这样的：

Accept: application/json,application/xml

靠谱的服务器端应该要顾及这个字段，然后根据自己能响应的格式做出响应。在响应报文中，通过Content-Type字段告知客户端是什么格式，如下所示：

Content-Type: application/json

具体格式，我们称之为具体的表现。所以REST的设计就是，通过URL设计资源、请求方法定义资源的操作，通过Accept决定资源的表现形式。

RESTful与MVC设计并不冲突，而且是更好的改进。相比MVC，RESTful只是将HTTP请求方法也加入了路由的过程，以及在URL路径上体现得更资源化。

请求方法的实现

为了让Node能够支持RESTful需求，我们改进了我们的设计。如果use是对所有请求方法的处理，那么在RESTful的场景下，我们需要区分请求方法设计。示例如下所示：

http.js：

var http = require('http');
// 获取请求
var restful = require('./RESTful');
var server = http.createServer();
server.listen(8000,function(err){
    console.log('请在浏览器中打开127.0.0.1:8000');
});

restful.server(server);

RESTful.js （路由分发js）：

var r = require('./rest')
var url = require('url');

module.exports.server = function (server) {
    server.on('request', (req, res) => {
        const match = (pathname, routes) => {
            for (let i = 0; i < routes.length; i++) {
                let route = routes[i];
                // 正则匹配
                let reg = route[0].regexp;
                let keys = route[0].keys;
                let matched = reg.exec(pathname);
                if (matched) {
                    // 抽取具体值
                    const params = {};
                    for (let i = 0, l = keys.length; i < l; i++) {
                        let value = matched[i + 1];
                        if (value) {
                            params[keys[i]] = value;
                        }
                    }
                    req.params = params;
                    let action = route[1];
                    action(req, res);
                    return true;
                }
            }
            return false;
        };
        let pathname = url.parse(req.url).pathname;
        // 将请求方法变为小写
        let method = req.method.toLowerCase();
        if (r.routes.hasOwnProperty(method)) {
            // 根据请求方法分发
            if (match(pathname, r.routes[method])) {
                return;
            } else {
                // 如果路径没有匹配成功，尝试让all()来处理
                if (match(pathname, r.routes.all)) {
                    return;
                }
            }
        } else {
            // 直接让all()来处理
            if (match(pathname, r.routes.all)) {
                return;
            }
        }
        // 处理404请求
        function res404(req, res) {
            res.end("404");
        }
        res404(req, res);
    })
}

rest.js （路由js）：

var yewu = require('./yewu')
var pathRegexp = function (path) {
    let strict = path
    const keys = [];
    path = path
        .concat(strict ? '' : '/?')
        .replace(/\/\(/g, '(?:/')
        .replace(/(\/)?(\.)?:(\w+)(?:(\(.*?\)))?(\?)?(\*)?/g, function (_, slash, format, key, capture, optional, star) {
            // 将匹配到的键值保存起来
            keys.push(key);
            slash = slash || '';
            return ''
                + (optional ? '' : slash)
                + '(?:'
                + (optional ? slash : '')
                + (format || '') + (capture || (format && '([^/.]+?)' || '([^/]+?)')) + ')'
                + (optional || '')
                + (star ? '(/*)?' : '');
        })
        .replace(/([\/.])/g, '\\$1')
        .replace(/\*/g, '(.*)');
    return {
        keys: keys,
        regexp: new RegExp('^' + path + '$')
    };
}


const routes = { 'all': [] };
const app = {};
app.use = function (path, action) {
    routes.all.push([pathRegexp(path), action]);
};
['get', 'put', 'delete', 'post'].forEach(function (method) {
    routes[method] = [];
    app[method] = function (path, action) {
        routes[method].push([pathRegexp(path), action]);
    };
});


// 增加用户
app.post('/user/:username/id/:id', yewu.addUser);
// 删除用户
app.delete('/user/:username/id/:id', yewu.removeUser);
// 修改用户
app.put('/user/:username/id/:id', yewu.updateUser);
// 查询用户
app.get('/user/:username/id/:id', yewu.getUser);

module.exports.routes = routes;

yewu.js （action控制器js文件）：

module.exports = {
    getUser:(req,res)=>{
        // ..... ToDo ..... //
        res.end('1');
    },
    removeUser:(req,res)=>{
        // ..... ToDo ..... //
        res.end('2');
    },
    updateUser:(req,res)=>{
        // ..... ToDo ..... //
        res.end('3');
    },
    addUser:(req,res)=>{
        // ..... ToDo ..... //
        res.end('4');
    }
}

结果：

       

              

  • 参数解析同上，此处不再论述。

如此，我们完成了实现RESTful支持的必要条件。这里的实现过程采用了手工映射的方法完成，事实上通过自然映射也能完成RESTful的支持，但是根据Controller/Action的约定必须要转化为Resource/Method的约定，此处已经引出实现思路，不再详述。

目前RESTful应用已经开始广泛起来，随着业务逻辑前端化、客户端的多样化，RESTful模式以其轻量的设计，得到广大开发者的青睐。对于多数的应用而言，只需要构建一套RESTful服务接口，就能适应移动端、PC端的各种客户端应用。

 

 

 

 

 

 

 

 

全干丶
关注
专栏目录
Vue项目路由使用
qq_23979127的博客
12-08 371
路由传参示例
vue3之动态路由
weixin_42255789的博客
09-22 1021
vue3动态路由
前端开发之vue动态路由实现方案
m0_50207524的博客
04-25 1032
本篇讲解的路由实现方案：默认存在的路由json->登录获取路由的json数据和权限->index.vue页面通过watch监听router为路由附加默认值->通过router.push跳转->触发beforeEach实现页面权限的判断和addrouter合并路由列表。
2023.5.13前端设计
a_student_2020的博客
05-14 891
Springboot+Vue架构设计（一）
动态添加路由addRoutes
weixin_30876945的博客
01-11 603
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <meta http-equ...
【附源码】Node.js毕业设计个人博客网页设计（Express）
奔跑程序
03-26 704
在后端，通过Express设置路由和中间件，与MySQL 5.7数据库进行交互，确保数据的存储和检索。在这个背景下，本毕业设计题目旨在通过使用前端技术（HTML、CSS、JavaScript和Vue）和后端技术（Node.js和Express）以及MySQL数据库，为用户提供一个简洁、易用、功能丰富的个人博客网页。其次，个人博客网页可以为用户提供一个在线交流和互动的平台，促进知识的传播和分享。此外，通过学习和实践个人博客网页设计，学生可以提高自己的编程能力和项目实践经验，为未来的职业生涯打下坚实的基础。
【附源码】Node.js毕业设计个人博客（Express）
奔跑程序
03-26 1002
在众多个人博客系统的开发技术中，前端技术采用HTML+CSS+JavaScript+Vue的组合，后端技术采用Node.js+Express的组合，数据库采用MySQL5.7，这些技术都是目前互联网行业中应用广泛、成熟的技术。此外，个人博客系统的开发过程中，学生还需要运用到版本控制工具Git、开发工具Visual Studio Code和数据库管理工具Navicat等辅助工具，这些工具在实际工作中也具有很高的应用价值。因此，开发一款功能完善、界面美观、操作简便的个人博客系统，具有很高的实用价值。
【附源码】Node.js毕业设计个人博客网站（Express）
奔跑程序
03-26 588
在技术层面，采用HTML、CSS、JavaScript、Vue等前端技术，结合Node.js、Express后端技术和MySQL数据库进行开发，可以让用户更好地掌握网站开发的相关知识，提高自己的技能水平。本毕业设计将采用HTML、CSS、JavaScript、Vue等前端技术，结合Node.js、Express后端技术和MySQL数据库，使用VSCode和Navicat作为开发工具，打造一个功能完善、界面美观的个人博客网站。完成开发后，将项目打包，配置好生产环境，并通过npm脚本启动应用。
Sitoi-blog:Sitoi博客
03-23
同时，后端可能采用了Node.js、Python的Django或Flask、Java的Spring Boot等服务器端技术，用于处理数据请求、用户认证、路由等功能。 数据库方面，Sitoi博客可能采用了MySQL、PostgreSQL或者MongoDB等关系型或非...
【附源码】Node.js毕业设计个人微博网站（Express）
最新发布
vcd603的博客
03-26 588
通过本项目的开发，我们可以深入了解和掌握前端技术（如HTML、CSS、JavaScript、Vue）和后端技术（如Node.js、Express）的应用，为今后的学习和工作打下坚实的基础。总之，个人微博网站的开发不仅可以满足用户的个性化需求，还可以为我们提供一个学习和实践新技术的机会，具有较高的实用价值和社会意义。本项目将采用HTML、CSS、JavaScript、Vue等前端技术，以及Node.js、Express后端技术和MySQL数据库进行开发，旨在为用户提供一个简洁、易用的个人微博网站。
vue的自动化路由+分模块管理+路由懒加载
shi_Avicii的博客
12-10 1000
近期单独做了一个系统项目，项目不大但是页面太多了，为了后期维护管理容易，做了个自动化加载路由以及模块化的管理。在此记录一下。 直接撸代码 1.首先看目录 router下的index.js是路由配置文件。 views下每个目录为一个模块，目录下每个pages文件夹存放页面。每个模块有一个单独的.router.js去管理。 2.先以asupmatset.router.js为例子 //...
Vue-router嵌套路由的使用
a641832648的博客
03-21 7177
路由使用的时候需要设置路由的路径： ew Router({ // mode: 'abstract', routes: [ { path: '/top', component: Top }, { path: '/new', component: New }, { path: '/', redirect: '/top' } ] }) 然后设置路由要渲染的标签：
request模块发送restful请求
蛐蛐的博客
12-30 1139
const request = require('request') request.get({ url:'http://localhost:8080' },(err,response,body)=>{ if(err){ console.log(err) } if(body){ console.log(body) }
vue+vue-router+vuex，利用vue-router2.2.0新增特性addRoutes实现路由动态加载，菜单动态加载，运用于后台管理系统，路由数据取自数据库
热门推荐
satisfy
03-13 8万+
vue,vuex,vue-router新特性addRoutes，动态加载路由,服务端渲染路由
vue-router之addRoutes（动态路由/权限路由）使用分析
it_lin_web的博客
03-04 1万+
// 1 设置默认路由 // 2 由登录获取权限路由（动态路由） // 要存储routes数据 -- 防止刷新时数据丢失--刷新时要重新动态渲染路由 var routes sessionStorage.setItem('routes', JSON.stringify(routes)) // 3 调用方法router.addRoutes（routes）routes要符合路由规则 routes....
express for node 路由route几种实现方式的思考
JINKAI
09-05 3万+
1、路由实现方式和顺序 express框架创建的模板app,js中默认代码 var express = require('express'); var routes = require('./routes'); var user = require('./routes/user'); var http = require('http'); var path = require('path');
VUE中权限+动态路由加载+配置，理论与实践！
AC916305619的博客
08-26 2101
哈喽大家好，今天我们来探讨vue开发过程中，最不可避免的过程。尤其是开发后台管理系统，其中有很多的角色需要用来做判断。不同的角色有着不同的权限。作为管理员还必须拥有修改这些权限的能力。 这样的操作无疑会使得前端做路由的加载时显得更为复杂。我司的角色有包括管理员在内总共6种。所以我将自己在开发过程中遇到的问题整理起来。仅做参考，希望对大家有帮助！ 思路 1.先从最高权限下手，把项目所有需要做...
搭建一套简单的web服务器，记录实验过程
abel97135的博客
07-10 1012
搭建web服务器 一、实验内容： 　　实验要求： 　　1、完成一个简单的web服务器，web服务器从mysql里读取数据进行返回　　2、Mysql需要有一个单独的数据盘，每个mysql虚拟机的磁盘挂载方式需要都不一样　　3、公网ip配置在虚拟机上，三个web服务器用snat访问公网　　4、使用dnat把8080端口映射到公网去，访问控制台的8080端口需要能够访问web serve...
Vue动态配置路由权限
天生欧皇张狗蛋
07-07 1292
import Vue from 'vue' import Vuex from 'vuex' import permission from './modules/permission' Vue.use(Vuex) const store = new Vuex.Store({ modules: { permission, }, }) export default store 动态获取后台参数并渲染 import { constantRoutes } from '@/router' i
S7-200 PLC编程技巧与故障排查
“S7-200点滴：分享S7-200 PLC的编程经验和实践知识，适合新手学习。” S7-200系列是西门子推出的一款小型可编程逻辑控制器（PLC），广泛应用于工业自动化领域。这篇资料主要涵盖了S7-200在实际应用中的一些关键...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值