[SEO优化中HTML分页标签的使用技巧]的搜索结果

...fka在高并发场景下优化策略的关注。 针对此类问题，专家建议企业应更加注重Kafka的调优与监控。一方面，可以通过调整batch.size和linger.ms参数，优化批量发送效率，从而降低网络开销；另一方面，借助Prometheus和Grafana等工具实时监控集群状态，及时发现潜在风险。此外，随着云原生技术的普及，越来越多的企业开始将Kafka部署在容器化环境中。这种趋势不仅提升了资源利用率，还简化了运维流程。例如，阿里云推出的Kafka on ACK服务，就为企业提供了一站式解决方案，帮助企业快速构建稳定可靠的流处理系统。 与此同时，Kafka社区也在不断迭代更新，最新版本引入了多项新特性，如异步压缩算法和动态分区扩展等，进一步增强了系统的灵活性和扩展性。这些改进为企业应对复杂业务场景提供了更多可能性。不过，技术的进步也带来了新的学习曲线，开发者需要持续关注官方文档和最佳实践，以确保自身技能跟上行业发展的步伐。 总而言之，Kafka的广泛应用离不开对其特性的深刻理解以及合理配置。未来，随着5G、物联网等新兴技术的兴起，Kafka将在实时数据处理领域发挥更大的作用。企业和开发者唯有不断提升技术水平，才能在激烈的市场竞争中占据有利位置。

...的一种职位，主要负责使用Java编程语言进行软件系统的设计、编码、测试和维护工作。在文中，JAVA开发工程师是一个高频出现的技术岗位，众多公司在金九银十求职季招聘的重点对象，因其跨平台、面向对象特性以及广泛应用于互联网后台服务端开发而受到业界青睐。 六险一金 , 六险一金是中国大陆地区较为全面的社会保险和住房公积金福利制度的简称。它包括养老保险、医疗保险、失业保险、工伤保险、生育保险、补充医疗保险（部分公司提供）以及住房公积金。在本文中，各家公司为吸引优秀人才，均提供了包含六险一金在内的综合福利待遇。 年终奖 , 年终奖是指企业在每年度末向员工发放的一种奖金形式，用于表彰员工一年来的工作业绩和贡献。文中提到的多家公司都提到了年终奖作为其福利待遇的一部分，这不仅是对员工工作成果的认可，也是激励员工积极工作的有效手段。 股票期权 , 股票期权是一种长期激励机制，允许员工在未来特定时间内以预先约定的价格购买公司股票的权利。在本文所述的互联网公司中，很多公司向员工提供股票期权作为福利之一，旨在让员工分享公司的成长收益，增强归属感，并鼓励员工与公司共同长期发展。

...，越来越多的企业选择使用像Nacos这样的开源工具作为配置中心，以提升系统的灵活性和可维护性。然而，除了Nacos之外，还有其他一些优秀的配置管理工具值得关注。例如，Spring Cloud Config，它同样支持动态刷新配置，能够与Spring生态系统无缝集成。对于那些已经采用Spring生态的企业来说，Spring Cloud Config无疑是一个不错的选择。此外，Consul Config也是值得考虑的选项之一，它不仅具备配置管理功能，还提供了服务发现和服务网格的能力，特别适合分布式系统环境下的应用。 同时，随着技术的发展，安全问题日益受到重视。在使用Nacos或其他配置管理工具时，数据传输的安全性至关重要。建议开发者们在部署过程中启用SSL/TLS加密，确保敏感信息在网络中传输时不会被窃取或篡改。另外，定期更新工具版本，修复已知漏洞，也是保障系统安全的重要措施。 在全球范围内，开源社区对这些技术的支持力度也在不断加大。比如GitHub上的Nacos项目，其活跃度非常高，每周都有大量的贡献者提交代码改进和修复问题。这种持续的技术迭代为企业提供了强大的技术支持，使得企业在面对复杂多变的技术挑战时能够更加从容应对。 总之，在选择合适的配置管理工具时，企业需要综合考量自身的业务需求和技术栈特点，同时也要密切关注最新的技术趋势和安全动态，以确保系统的稳定性和安全性。

...现在我们需要在程序中使用这个服务。按照传统的做法，可能会直接在类内部实例化： csharp public class Worker { private readonly IService _service = new Service(); public void Execute() { _service.DoWork(); } } 这种方式看起来没什么问题，但实际上隐藏着巨大的隐患。比如，如果你需要替换Service为其他实现（比如MockService），你就得修改Worker类的代码。这违背了开闭原则。 于是，我们引入了依赖注入框架，比如Microsoft的Microsoft.Extensions.DependencyInjection。让我们看看如何正确配置。 --- 3. 正确配置 DI容器的正确姿势 首先，你需要注册服务。比如，在Program.cs文件中： csharp using Microsoft.Extensions.DependencyInjection; var services = new ServiceCollection(); services.AddTransient(); var serviceProvider = services.BuildServiceProvider(); 这里的关键点在于Transient这个词。它表示每次请求时都会生成一个新的实例。对了，还有别的选择呢，比如说 Scoped——在一个作用域里大家用同一个实例，挺节省资源的；再比如 Singleton——在整个应用跑着的时候大家都用一个“独苗”实例，从头到尾都不换。选择合适的生命周期很重要，否则可能会导致意想不到的行为。 接下来，我们可以通过依赖注入获取实例： csharp public class Worker { private readonly IService _service; public Worker(IService service) { _service = service; } public void Execute() { _service.DoWork(); } } 在这个例子中，Worker类不再负责创建IService的实例，而是由DI容器提供。这种解耦的方式让代码更加灵活。 --- 4. 配置错误 常见的坑 然而，现实总是比理想复杂得多。以下是一些常见的DI配置错误，以及它们可能带来的后果。 4.1 注册类型时搞错了 有时候我们会不小心把类型注册错了。比如： csharp services.AddTransient(); // 想注册MockService，却写成了Service 结果就是，无论你在代码中怎么尝试，拿到的永远是Service而不是MockService。其实这个坑挺容易被忽略的，毕竟编译器又不报错，一切都看起来风平浪静，直到程序跑起来的时候，问题才突然冒出来，啪叽一下给你整一个大 surprise！ 我的建议是，尽量使用常量或者枚举来定义服务名称，这样可以减少拼写错误的风险： csharp public static class ServiceNames { public const string MockService = "MockService"; public const string RealService = "RealService"; } services.AddTransient(ServiceNames.MockService, typeof(MockService)); 4.2 生命周期设置不当 另一个常见的问题是生命周期设置错误。比如说，你要是想弄个单例服务，结果不小心把它设成了 Transient，那每次调用的时候都会新生成一个实例。这就好比你本来想让一个人负责一件事，结果每次都换个人来干，不仅效率低得让人崩溃，搞不好还会出大乱子呢！ csharp // 错误示范 services.AddTransient(); // 正确示范 services.AddSingleton(); 记住，单例模式适用于那些无状态或者状态不重要的场景。嘿，想象一下，你正在用一个数据库连接池这种“有状态”的服务，要是把它搞成单例模式，那可就热闹了——多个线程或者任务同时去抢着用它，结果就是互相踩脚、搞砸事情，什么竞争条件啦、数据混乱啦，各种麻烦接踵而至。就好比大家伙儿都盯着同一个饼干罐子，都想伸手拿饼干，但谁也没个规矩，结果不是抢得太猛把罐子摔了，就是谁都拿不痛快。所以啊，这种情况下，还是别让单例当这个“独裁者”了，分清楚责任才靠谱！ 4.3 忘记注册依赖 有时候，我们可能会忘记注册某些依赖项。比如： csharp public class SomeClass { private readonly IAnotherService _anotherService; public SomeClass(IAnotherService anotherService) { _anotherService = anotherService; } } 如果IAnotherService没有被注册到DI容器中，那么在运行时就会抛出异常。为了避免这种情况，你可以使用AddScoped或AddTransient来确保所有依赖都被正确注册。 --- 5. 探讨与总结 通过今天的讨论，我们可以看到，虽然依赖注入能够极大地提高代码的质量和可维护性，但它并不是万能的。设置搞错了，那可就麻烦大了，小到一个单词拼错了，大到程序跑偏、东西乱套，什么幺蛾子都可能出现。 我的建议是，在使用DI框架时要多花时间去理解和实践。不要害怕犯错，因为正是这些错误教会了我们如何更好地编写代码。同时，也要学会利用工具和日志来帮助自己排查问题。 最后，我想说的是，编程不仅仅是解决问题的过程，更是一个不断学习和成长的过程。希望大家能够在实践中找到乐趣，享受每一次成功的喜悦！ 好了，今天的分享就到这里啦，如果你有任何疑问或者想法，欢迎随时留言交流哦！😄

...ock 所有命令需要使用root 权限 nvidia@nvidia-desktop:~$ hwclockhwclock: Cannot access the Hardware Clock via any known method.hwclock: Use the --debug option to see the details of our search for an access method.nvidia@nvidia-desktop:~$nvidia@nvidia-desktop:~$nvidia@nvidia-desktop:~$ sudo hwclock2023-03-21 11:18:49.607690+0800nvidia@nvidia-desktop:~$ 将系统时间同步到硬件时间 hwclock -w 将硬件时间同步到系统时间 hwclock -s 二、不同机器间时间同步 为了避免主机时间因为长期运作下所导致的时间偏差，进行时间同步(synchronize)的工作是非常必要的。Linux系统下，一般使用ntp服务器来同步不同机器的时间。一台机器，可以同时是ntp服务器和ntp客户机。 2.1 ntpdate命令实现 ntpdate 安装： yum install ntpdate -y Centos系统======================================sudo apt install ntpdate Ubuntu系统 时间同步 sudo ntpdate -u cn.pool.ntp.org18 Mar 18:25:22 ntpdate[18673]: adjust time server 84.16.73.33 offset 0.015941 sec 使用ntpdate 只是强制将系统时间设置为ntp服务器时间，如果cpu tick有问题，时间还是会不准。所以，一般配合cron命令，来进行定期同步设置。比如，在crontab中添加： sudo crontab -e0 12 /usr/sbin/ntpdate 192.168.10.110 上述命令的意思是：每天的12点整，从192.168.10.110 ntp服务器同步一次时间（前提是 192.168.10.110有ntp服务）。 2.2 Ntp客户端代码实现 本质上还是创建socket连接去获取ntp服务的时间与本地时间比较，不一致修改本机时间即可。 NtpClient.h //// Created by lwang on 2023-03-18.//ifndef NTP_CLIENT_Hdefine NTP_CLIENT_Hinclude <stdio.h>include <stdlib.h>include <string.h>include <time.h>include <iostream>include <unistd.h>include <sys/select.h>include <sys/time.h>include <sys/socket.h>include <arpa/inet.h>include <netdb.h>include <errno.h>include <endian.h>include <map>include <string>include <mutex>using namespace std;define NTP_LI 0define NTP_VERSION_NUM 3define NTP_MODE_CLIENT 3define NTP_MODE_SERVER 4define NTP_STRATUM 0define NTP_POLL 4define NTP_PRECISION -6define NTP_MIN_LEN 48define NTP_SERVER_PORT 123define NTP_SERVER_ADDR "119.28.183.184"define TIMEOUT 2define BUFSIZE 1500define JAN_1970 0x83aa7e80define NTP_CONV_FRAC32(x) (uint64_t)((x) ((uint64_t)1 << 32))define NTP_REVE_FRAC32(x) ((double)((double)(x) / ((uint64_t)1 << 32)))define NTP_CONV_FRAC16(x) (uint32_t)((x) ((uint32_t)1 << 16))define NTP_REVE_FRAC16(x) ((double)((double)(x) / ((uint32_t)1 << 16)))define USEC2FRAC(x) ((uint32_t)NTP_CONV_FRAC32((x) / 1000000.0))define FRAC2USEC(x) ((uint32_t)NTP_REVE_FRAC32((x)1000000.0))define NTP_LFIXED2DOUBLE(x) ((double)(ntohl(((struct l_fixedpt )(x))->intpart) - JAN_1970 + FRAC2USEC(ntohl(((struct l_fixedpt )(x))->fracpart)) / 1000000.0))struct s_fixedpt{uint16_t intpart;uint16_t fracpart;};struct l_fixedpt{uint32_t intpart;uint32_t fracpart;};struct ntphdr{if __BYTE_ORDER == __BID_ENDIANunsigned int ntp_li : 2;unsigned int ntp_vn : 3;unsigned int ntp_mode : 3;endifif __BYTE_ORDER == __LITTLE_ENDIANunsigned int ntp_mode : 3;unsigned int ntp_vn : 3;unsigned int ntp_li : 2;endifuint8_t ntp_stratum;uint8_t ntp_poll;int8_t ntp_precision;struct s_fixedpt ntp_rtdelay;struct s_fixedpt ntp_rtdispersion;uint32_t ntp_refid;struct l_fixedpt ntp_refts;struct l_fixedpt ntp_orits;struct l_fixedpt ntp_recvts;struct l_fixedpt ntp_transts;};class NtpClient {public:NtpClient();virtual ~NtpClient();void GetNtpTime(std::string &ntpTime);in_addr_t HostTransfer(const char host);int PaddingNtpPackage(void buf, size_t size);double GetOffset(const struct ntphdr ntp, const struct timeval recvtv);private:int m_sockfd;};endif / NTP_CLIENT_H / NtpClient.cpp //// Created by lwang on 2023-03-18.//include "NtpClient.h"NtpClient::NtpClient() { }NtpClient::~NtpClient() {}in_addr_t NtpClient::HostTransfer(const char host){in_addr_t saddr;struct hostent hostent;if ((saddr = inet_addr(host)) == INADDR_NONE){if ((hostent = gethostbyname(host)) == NULL){return INADDR_NONE;}memmove(&saddr, hostent->h_addr, hostent->h_length);}return saddr;}int NtpClient::PaddingNtpPackage(void buf, size_t size) // 构建并发送NTP请求报文{if (!size)return -1;struct ntphdr ntp;struct timeval tv;memset(buf, 0, BUFSIZE);ntp = (struct ntphdr )buf;ntp->ntp_li = NTP_LI;ntp->ntp_vn = NTP_VERSION_NUM;ntp->ntp_mode = NTP_MODE_CLIENT;ntp->ntp_stratum = NTP_STRATUM;ntp->ntp_poll = NTP_POLL;ntp->ntp_precision = NTP_PRECISION;gettimeofday(&tv, NULL); // 把目前的时间用tv 结构体返回ntp->ntp_transts.intpart = htonl(tv.tv_sec + JAN_1970);ntp->ntp_transts.fracpart = htonl(USEC2FRAC(tv.tv_usec));size = NTP_MIN_LEN;return 0;}double NtpClient::GetOffset(const struct ntphdr ntp, const struct timeval recvtv) // 偏移量{double t1, t2, t3, t4;t1 = NTP_LFIXED2DOUBLE(&ntp->ntp_orits);t2 = NTP_LFIXED2DOUBLE(&ntp->ntp_recvts);t3 = NTP_LFIXED2DOUBLE(&ntp->ntp_transts);t4 = recvtv->tv_sec + recvtv->tv_usec / 1000000.0;return ((t2 - t1) + (t3 - t4)) / 2;}void NtpClient::GetNtpTime(std::string &ntpTime){char buffer[64] = {0};char cmd[128] = {0};tm local;char buf[BUFSIZE];size_t nbytes;int maxfd1;struct sockaddr_in servaddr;fd_set readfds;struct timeval timeout, recvtv, tv;double offset;servaddr.sin_family = AF_INET;servaddr.sin_port = htons(NTP_SERVER_PORT);servaddr.sin_addr.s_addr = HostTransfer(NTP_SERVER_ADDR);if ((m_sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0){perror("socket error");return ;}if (connect(m_sockfd, (struct sockaddr )&servaddr, sizeof(struct sockaddr)) != 0){perror("connect error");return ;}nbytes = BUFSIZE;if (PaddingNtpPackage(buf, &nbytes) != 0){fprintf(stderr, "construct ntp request error \n");exit(-1);}send(m_sockfd, buf, nbytes, 0);FD_ZERO(&readfds);FD_SET(m_sockfd, &readfds);maxfd1 = m_sockfd + 1;timeout.tv_sec = TIMEOUT;timeout.tv_usec = 0;if (select(maxfd1, &readfds, NULL, NULL, &timeout) > 0){if (FD_ISSET(m_sockfd, &readfds)){if ((nbytes = recv(m_sockfd, buf, BUFSIZE, 0)) < 0){perror("recv error");exit(-1);}// 计算C/S时间偏移量gettimeofday(&recvtv, NULL);offset = GetOffset((struct ntphdr )buf, &recvtv);gettimeofday(&tv, NULL);tv.tv_sec += (int)offset;tv.tv_usec += offset - (int)offset;local = localtime((time_t )&tv.tv_sec);strftime(buffer, 64, "%Y-%m-%d %H:%M:%S", local);ntpTime = std::string(buffer);} }return ;} main.cpp include "NtpClient.h"int main(){std::string ntpTime = "";char curBuf[64] = {0};struct timeval cur;tm local;NtpClient client;client.GetNtpTime(ntpTime);cout << "ntpTime: " << ntpTime << endl;gettimeofday(&cur, NULL);local = localtime((time_t )&cur.tv_sec);strftime(curBuf, 64, "%Y-%m-%d %H:%M:%S", local);std::string curTime = std::string(curBuf);cout << "curTime: " << curTime << endl;if (curTime != ntpTime){cout << "start time calibrate!" << endl;std::string cmd = "sudo date -s \"" + ntpTime + "\"";system(cmd.c_str());cout << "cmd: " << cmd << endl;}else{cout << "time seem" << endl;}return 0;} 推荐一个零声学院免费教程，个人觉得老师讲得不错， 分享给大家：[Linux，Nginx，ZeroMQ，MySQL，Redis， fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker， TCP/IP，协程，DPDK等技术内容，点击立即学习: 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_46935110/article/details/129683157。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...2. Proxy基本使用 2.1 Proxy 的 set 和 get 捕获器 2.2 Proxy 所有捕获器 (13个) 2.3 Proxy 的 construct 和 apply 3. Reflect 3.1 Reflect 的作用 3.2 Reflect 的常见方法 3.3 Reflect 的使用 3.4 Receiver的作用 3.5 Reflect 的 construct 4. 响应式 4.1 什么是响应式？ 4.2 响应式函数设计 4.3 响应式依赖的收集 4.4 监听对象的变化 4.5 对象的依赖管理 4.6 对 Depend 重构 4.7 创建响应式对象 4.8 Vue2 响应式原理 Proxy 、Relect、响应式 1. 监听对象的操作 需求：有一个对象，我们希望监听这个对象中的属性被设置或获取的过程 可以通过属性描述符中的存储属性描述符来做到 这段代码就利用了 Object.defineProperty 的存储属性描述符来对属性的操作进行监听 const obj = {name: 'why',age: 18}Object.keys(obj).forEach((key) => {let value = obj[key]Object.defineProperty(obj, key, {get: function () {console.log(监听到obj对象的${key}属性被访问了)return value},set: function (newValue) {console.log(监听到obj对象的${key}属性被设置值)value = newValue} })})obj.name = 'kobe'obj.age = 30console.log(obj.name)console.log(obj.age)/ 监听到obj对象的name属性被设置值监听到obj对象的age属性被设置值监听到obj对象的name属性被访问了kobe监听到obj对象的age属性被访问了30/ 属性描述符监听对象的缺点： 首先，Object.defineProperty 设计的初衷，不是为了去监听截止一个对象中所有的属性的 我们在定义某些属性的时候，初衷其实是定义普通的属性，但是后面我们强行将它变成了数据属性描述符 其次，如果我们想监听更加丰富的操作，比如新增属性、删除属性，那么 Object.defineProperty 是无能为力的 所以我们要知道，存储数据描述符设计的初衷并不是为了去监听一个完整的对象 Ps: 原来的对象是 数据属性描述符，通过 Object.defineProperty 变成了 访问属性描述符 2. Proxy基本使用 在ES6中，新增了一个Proxy类，这个类从名字就可以看出来，是用于帮助我们创建一个代理的： 也就是说，如果我们希望监听一个对象的相关操作，那么我们可以先创建一个代理对象（Proxy对象） 之后对该对象的所有操作，都通过代理对象来完成，代理对象可以监听我们想要对原对象进行哪些操作 将上面的案例用 Proxy 来实现一次： 首先，我们需要 new Proxy 对象，并且传入需要侦听的对象以及一个处理对象，可以称之为 handler； const p = new Proxy(target, handler) 其次，我们之后的操作都是直接对 Proxy 的操作，而不是原有的对象，因为我们需要在 handler 里面进行侦听 const obj = {name: 'why',age: 18}const objProxy = new Proxy(obj, {// 获取值时的捕获器get: function (target, key) {console.log(监听到obj对象的${key}属性被访问了)return target[key]},// 设置值时的捕获器set: function (target, key, newValue) {console.log(监听到obj对象的${key}属性被设置值)target[key] = newValue} })console.log(objProxy.name)console.log(objProxy.age)objProxy.name = 'kobe'objProxy.age = 30console.log(obj.name)console.log(obj.age)/ 监听到obj对象的name属性被访问了why监听到obj对象的age属性被访问了18监听到obj对象的name属性被设置值监听到obj对象的age属性被设置值kobe30/ 2.1 Proxy 的 set 和 get 捕获器 如果我们想要侦听某些具体的操作，那么就可以在 handler 中添加对应的捕捉器（Trap） set 和 get 分别对应的是函数类型 set 函数有四个参数： target：目标对象（侦听的对象） property：将被设置的属性 key value：新属性值 receiver：调用的代理对象 get 函数有三个参数 target：目标对象（侦听的对象） property：被获取的属性 key receiver：调用的代理对象 2.2 Proxy 所有捕获器 (13个) handler.getPrototypeOf() Object.getPrototypeOf 方法的捕捉器 handler.setPrototypeOf() Object.setPrototypeOf 方法的捕捉器 handler.isExtensible() Object.isExtensible 方法的捕捉器 handler.preventExtensions() Object.preventExtensions 方法的捕捉器 handler.getOwnPropertyDescriptor() Object.getOwnPropertyDescriptor 方法的捕捉器 handler.defineProperty() Object.defineProperty 方法的捕捉器 handler.ownKeys() Object.getOwnPropertyNames 方法和 Object.getOwnPropertySymbols 方法的捕捉器 handler.has() in 操作符的捕捉器 handler.get() 属性读取操作的捕捉器 handler.set() 属性设置操作的捕捉器 handler.deleteProperty() delete 操作符的捕捉器 handler.apply() 函数调用操作的捕捉器 handler.construct() new 操作符的捕捉器 const obj = {name: 'why',age: 18}const objProxy = new Proxy(obj, {// 获取值时的捕获器get: function (target, key) {console.log(监听到obj对象的${key}属性被访问了)return target[key]},// 设置值时的捕获器set: function (target, key, newValue) {console.log(监听到obj对象的${key}属性被设置值)target[key] = newValue},// 监听 in 的捕获器has: function (target, key) {console.log(监听到obj对象的${key}属性的in操作)return key in target},// 监听 delete 的捕获器deleteProperty: function (target, key) {console.log(监听到obj对象的${key}属性的delete操作)delete target[key]} })// in 操作符console.log('name' in objProxy)// delete 操作delete objProxy.name/ 监听到obj对象的name属性的in操作true监听到obj对象的name属性的delete操作/ 2.3 Proxy 的 construct 和 apply 到捕捉器中还有 construct 和 apply，它们是应用于函数对象的 function foo() {console.log('调用了 foo')}const fooProxy = new Proxy(foo, {apply: function (target, thisArg, argArray) {console.log(对 foo 函数进行了 apply 调用)target.apply(thisArg, argArray)},construct: function (target, argArray, newTarget) {console.log(对 foo 函数进行了 new 调用)return new target(...argArray)} })fooProxy.apply({}, ['abc', 'cba'])new fooProxy('abc', 'cba')/ 对 foo 函数进行了 apply 调用调用了 foo对 foo 函数进行了 new 调用调用了 foo/ 3. Reflect 3.1 Reflect 的作用 Reflect 也是 ES6 新增的一个 API，它是一个对象，字面的意思是反射 Reflect 的作用： 它主要提供了很多操作 JavaScript 对象的方法，有点像 Object 中操作对象的方法 比如 Reflect.getPrototypeOf(target) 类似于 Object.getPrototypeOf() 比如 Reflect.defineProperty(target, propertyKey, attributes) 类似于 Object.defineProperty() 如果我们有 Object 可以做这些操作，那么为什么还需要有Reflect这样的新增对象呢？ 这是因为在早期的 ECMA 规范中没有考虑到这种对 对象本身 的操作如何设计会更加规范，所以将这些 API 放到了 Object上面 但是 Object 作为一个构造函数，这些操作实际上放到它身上并不合适 另外还包含一些类似于 in、delete 操作符，让 JS 看起来是会有一些奇怪的 所以在 ES6 中新增了 Reflect，让我们这些操作都集中到了 Reflect 对象上 那么 Object 和 Reflect 对象之间的 API 关系，可以参考 MDN 文档： 比较 Reflect 和 Object 方法 3.2 Reflect 的常见方法 Reflect中有哪些常见的方法呢？它和Proxy是一一对应的，也是13个 Reflect.getPrototypeOf(target) 类似于 Object.getPrototypeOf() Reflect.setPrototypeOf(target, prototype) 设置对象原型的函数. 返回一个 Boolean， 如果更新成功，则返回 true Reflect.isExtensible(target) 类似于 Object.isExtensible() Reflect.preventExtensions(target) 类似于 Object.preventExtensions() , 返回一个 Boolean Reflect.getOwnPropertyDescriptor(target, propertyKey) 类似于 Object.getOwnPropertyDescriptor() , 如果对象中存在该属性，则返回对应的属性描述符, 否则返回 undefined Reflect.defineProperty(target, propertyKey, attributes) 和 Object.defineProperty() 类似, 如果设置成功就会返回 true Reflect.ownKeys(target) 返回一个包含所有自身属性（不包含继承属性）的数组 （类似于 Object.keys(), 但不会受 enumerable 影响） Reflect.has(target, propertyKey) 判断一个对象是否存在某个属性，和 in 运算符 的功能完全相同 Reflect.get(target, propertyKey[, receiver]) 获取对象身上某个属性的值，类似于 target[name] Reflect.set(target, propertyKey, value[, receiver]) 将值分配给属性的函数，返回一个 Boolean，如果更新成功，则返回 true Reflect.deleteProperty(target, propertyKey) 作为函数的 delete 操作符，相当于执行 delete target[name] Reflect.apply(target, thisArgument, argumentsList) 对一个函数进行调用操作，同时可以传入一个数组作为调用参数。和 Function.prototype.apply() 功能类似 Reflect.construct(target, argumentsList[, newTarget]) 对构造函数进行 new 操作，相当于执行 new target(...args) 3.3 Reflect 的使用 那么我们可以将之前Proxy案例中对原对象的操作，都修改为Reflect来操作 const obj = {name: 'why',age: 18}const objProxy = new Proxy(obj, {get: function (target, key) {console.log(监听到obj对象的${key}属性被访问了)return Reflect.get(target, key)// return target[key] // 对原来对象进行了直接操作},set: function (target, key, newValue) {console.log(监听到obj对象的${key}属性被设置值)Reflect.set(target, key, newValue)// target[key] = newValue // 对原来对象进行了直接操作} })objProxy.name = 'kobe'console.log(objProxy.name)/ 监听到obj对象的name属性被设置值监听到obj对象的name属性被访问了kobe/ 3.4 Receiver的作用 我们发现在使用getter、setter的时候有一个receiver的参数，它的作用是什么呢？ 如果我们的源对象（obj）有 setter 、getter 的访问器属性，那么可以通过 receiver 来改变里面的 this const obj = {_name: 'why',get name() {return this._name // 不使用receiver, _name属性的操作不会被objProxy代理，因为this指向obj},set name(newValue) {this._name = newValue} }const objProxy = new Proxy(obj, {get: function (target, key, receiver) {// receiver 是创建出来的代理对象console.log('get 方法被访问-------', key, receiver)console.log(objProxy === receiver) // truereturn Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)} })objProxy.name = 'kobe'console.log(objProxy.name) // kobe/ get 方法被访问------- name { _name: 'kobe', name: [Getter/Setter] }trueget 方法被访问------- _name { _name: 'kobe', name: [Getter/Setter] }truekobe/ 3.5 Reflect 的 construct function Student(name, age) {this.name = namethis.age = age}function Teacher() {}const stu = new Student('why', 18)console.log(stu)console.log(stu.__proto__ === Student.prototype)/ Student { name: 'why', age: 18 }true/// 执行 Student 函数中的内容，但是创建出来的对象是 Teacher 对象const teacher = Reflect.construct(Student, ['why', 18], Teacher)console.log(teacher)console.log(teacher.__proto__ === Teacher.prototype)/ Teacher { name: 'why', age: 18 }true/ 4. 响应式 4.1 什么是响应式？ 先来看一下响应式意味着什么？我们来看一段代码： m 有一个初始化的值，有一段代码使用了这个值； 那么在 m 有一个新的值时，这段代码可以自动重新执行 let m = 0// 一段代码console.log(m)console.log(m 2)console.log(m 2)m = 200 上面的这样一种可以自动响应数据变量的代码机制，我们就称之为是响应式的 对象的响应式 4.2 响应式函数设计 首先，执行的代码中可能不止一行代码，所以我们可以将这些代码放到一个函数中： 那么问题就变成了，当数据发生变化时，自动去执行某一个函数； 但是有一个问题：在开发中是有很多的函数的，如何区分一个函数需要响应式，还是不需要响应式呢？ 很明显，下面的函数中 foo 需要在 obj 的 name 发生变化时，重新执行，做出相应； bar 函数是一个完全独立于 obj 的函数，它不需要执行任何响应式的操作； // 对象的响应式const obj = {name: 'why',age: 18}function foo() {const newName = obj.nameconsole.log('你好啊，李银河')console.log('Hello World')console.log(obj.name)}function bar() {console.log('普通的其他函数')console.log('这个函数不需要有任何的响应式')}obj.name = 'kobe' // name 发生改变时候 foo 函数执行 响应式函数的实现 watchFn 如何区分响应式函数？ 这个时候我们封装一个新的函数 watchFn 凡是传入到 watchFn 的函数，就是需要响应式的 其他默认定义的函数都是不需要响应式的 / 封装一个响应式的函数 /let reactiveFns = []function watchFn(fn) {reactiveFns.push(fn)}// 对象的响应式const obj = {name: 'why',age: 18}watchFn(function foo() {const newName = obj.nameconsole.log('你好啊，李银河')console.log('Hello World')console.log(obj.name)})watchFn(function demo() {console.log(obj.name, 'demo function ---------')})function bar() {console.log('普通的其他函数')console.log('这个函数不需要有任何的响应式')}obj.name = 'kobe' // name 发生改变时候 foo 函数执行reactiveFns.forEach((fn) => {fn()}) 4.3 响应式依赖的收集 目前收集的依赖是放到一个数组中来保存的，但是这里会存在数据管理的问题： 在实际开发中需要监听很多对象的响应式 这些对象需要监听的不只是一个属性，它们很多属性的变化，都会有对应的响应式函数 不可能在全局维护一大堆的数组来保存这些响应函数 所以要设计一个类，这个类用于管理某一个对象的某一个属性的所有响应式函数： 相当于替代了原来的简单 reactiveFns 的数组； class Depend {constructor() {this.reactiveFns = []}addDepend(reactiveFn) {this.reactiveFns.push(reactiveFn)}notify() {this.reactiveFns.forEach((fn) => {fn()})} }const depend = new Depend()function watchFn(fn) {depend.addDepend(fn)}// 对象的响应式const obj = {name: 'why', // depend 对象age: 18 // depend 对象}watchFn(function foo() {const newName = obj.nameconsole.log('你好啊，李银河')console.log('Hello World')console.log(obj.name)})watchFn(function demo() {console.log(obj.name, 'demo function ---------')})function bar() {console.log('普通的其他函数')console.log('这个函数不需要有任何的响应式')}obj.name = 'kobe'depend.notify() 4.4 监听对象的变化 那么接下来就可以通过之前的方式来监听对象的变化： 方式一：通过 Object.defineProperty 的方式（vue2采用的方式）； 方式二：通过 new Proxy 的方式（vue3采用的方式）； 我们这里先以Proxy的方式来监听 class Depend {constructor() {this.reactiveFns = []}addDepend(reactiveFn) {this.reactiveFns.push(reactiveFn)}notify() {this.reactiveFns.forEach((fn) => {fn()})} }const depend = new Depend()function watchFn(fn) {depend.addDepend(fn)}// 对象的响应式const obj = {name: 'why', // depend 对象age: 18 // depend 对象}// 监听对象的属性变化：Proxy(vue3)/Object.defineProperty(vue2)const objProxy = new Proxy(obj, {get: function (target, key, receiver) {return Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)depend.notify()} })watchFn(function foo() {const newName = objProxy.nameconsole.log('你好啊，李银河')console.log('Hello World')console.log(objProxy.name)})watchFn(function demo() {console.log(objProxy.name, 'demo function ---------')})objProxy.name = 'kobe'objProxy.name = 'james'/ 你好啊，李银河Hello Worldkobekobe demo function ---------你好啊，李银河Hello Worldjamesjames demo function ---------/ 4.5 对象的依赖管理 目前是创建了一个 Depend 对象，用来管理对于 name 变化需要监听的响应函数： 但是实际开发中我们会有不同的对象，另外会有不同的属性需要管理； 如何可以使用一种数据结构来管理不同对象的不同依赖关系呢？ 在前面我们刚刚学习过 WeakMap，并且在学习 WeakMap 的时候我讲到了后面通过 WeakMap 如何管理这种响应式的数据依赖： 实现 可以写一个 getDepend 函数专门来管理这种依赖关系 / 封装一个获取depend的函数 /const taregtMap = new WeakMap()function getDepend(target, key) {// 根据target对象获取mapconst map = taregtMap.get(target)if (!map) {map = new Map()taregtMap.set(target, map)}// 根据key获取depend对象const depend = map.get(key)if (!depend) {depend = new Depend()map.set(key, depend)}return depend}// 监听对象的属性变化：Proxy(vue3)/Object.defineProperty(vue2)const objProxy = new Proxy(obj, {get: function (target, key, receiver) {return Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)const depend = getDepend(target, key)depend.notify()} }) 正确的依赖收集 我们之前收集依赖的地方是在 watchFn 中： 但是这种收集依赖的方式我们根本不知道是哪一个 key 的哪一个 depend 需要收集依赖； 只能针对一个单独的 depend 对象来添加你的依赖对象； 那么正确的应该是在哪里收集呢？应该在我们调用了 Proxy 的 get 捕获器时 因为如果一个函数中使用了某个对象的 key，那么它应该被收集依赖 / 封装一个响应式函数 /let activeReactviceFn = nullfunction watchFn(fn) {activeReactviceFn = fnfn()activeReactviceFn = null}/ 封装一个获取depend的函数 /const taregtMap = new WeakMap()function getDepend(target, key) {// 根据target对象获取maplet map = taregtMap.get(target)if (!map) {map = new Map()taregtMap.set(target, map)}// 根据key获取depend对象let depend = map.get(key)if (!depend) {depend = new Depend()map.set(key, depend)}return depend}// 监听对象的属性变化：Proxy(vue3)/Object.defineProperty(vue2)const objProxy = new Proxy(obj, {get: function (target, key, receiver) {// 根据 target key 获取对应的 depnedconst depend = getDepend(target, key)// 给 depend 对象中添加响应式函数activeReactviceFn && depend.addDepend(activeReactviceFn)return Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)const depend = getDepend(target, key)depend.notify()} }) 4.6 对 Depend 重构 两个问题： 问题一：如果函数中有用到两次 key，比如 name，那么这个函数会被收集两次 问题二：我们并不希望将添加 reactiveFn 放到 get 中，因为它是属于 Depend 的行为 所以我们需要对 Depend 类进行重构： 解决问题一的方法：不使用数组，而是使用 Set 解决问题二的方法：添加一个新的方法，用于收集依赖 // 保存当前需要收集的响应式函数let activeReactviceFn = nullclass Depend {constructor() {this.reactiveFns = new Set()}depend() {if (activeReactviceFn) {this.reactiveFns.add(activeReactviceFn)} }addDepend(reactiveFn) {this.reactiveFns.add(reactiveFn)}notify() {this.reactiveFns.forEach((fn) => {fn()})} }// 对象的响应式const obj = {name: 'why', // depend 对象age: 18 // depend 对象}/ 封装一个响应式函数 /function watchFn(fn) {activeReactviceFn = fnfn()activeReactviceFn = null}/ 封装一个获取depend的函数 /const taregtMap = new WeakMap()function getDepend(target, key) {// 根据target对象获取maplet map = taregtMap.get(target)if (!map) {map = new Map()taregtMap.set(target, map)}// 根据key获取depend对象let depend = map.get(key)if (!depend) {depend = new Depend()map.set(key, depend)}return depend}// 监听对象的属性变化：Proxy(vue3)/Object.defineProperty(vue2)const objProxy = new Proxy(obj, {get: function (target, key, receiver) {// 根据 target key 获取对应的 depnedconst depend = getDepend(target, key)// 给 depend 对象中添加响应式函数depend.depend()return Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)const depend = getDepend(target, key)depend.notify()} })watchFn(function () {console.log(objProxy.name, '--------------')console.log(objProxy.name, '++++++++++++++')})objProxy.name = 'kobe'/ why --------------why ++++++++++++++kobe --------------kobe ++++++++++++++/ 4.7 创建响应式对象 目前的响应式是针对于obj一个对象的，我们可以创建出来一个函数，针对所有的对象都可以变成响应式对象 / 保存当前需要收集的响应式函数 /let activeReactviceFn = null/ 依赖收集类 /class Depend {constructor() {this.reactiveFns = new Set()}depend() {if (activeReactviceFn) {this.reactiveFns.add(activeReactviceFn)} }addDepend(reactiveFn) {this.reactiveFns.add(reactiveFn)}notify() {this.reactiveFns.forEach((fn) => {fn()})} }/ 封装一个响应式函数 /function watchFn(fn) {activeReactviceFn = fnfn()activeReactviceFn = null}/ 封装一个获取depend的函数 /const taregtMap = new WeakMap()function getDepend(target, key) {// 根据target对象获取maplet map = taregtMap.get(target)if (!map) {map = new Map()taregtMap.set(target, map)}// 根据key获取depend对象let depend = map.get(key)if (!depend) {depend = new Depend()map.set(key, depend)}return depend}/ 创建响应式对象函数 /function reactive(obj) {// 监听对象的属性变化：Proxy(vue3)/Object.defineProperty(vue2)return new Proxy(obj, {get: function (target, key, receiver) {// 根据 target key 获取对应的 depnedconst depend = getDepend(target, key)// 给 depend 对象中添加响应式函数depend.depend()return Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)const depend = getDepend(target, key)depend.notify()} })}const info = reactive({address: '广州市',height: 1.88})watchFn(() => {console.log(info.address, '---')})info.address = '北京市' 4.8 Vue2 响应式原理 前面所实现的响应式的代码，其实就是 Vue3 中的响应式原理： Vue3 主要是通过 Proxy 来监听数据的变化以及收集相关的依赖的 Vue2 中通过 Object.defineProerty的方式来实现对象属性的监听 可以将 reactive 函数进行如下的重构： 在传入对象时，我们可以遍历所有的 key，并且通过属性存储描述符来监听属性的获取和修改 在 setter 和 getter 方法中的逻辑和前面的 Proxy 是一致的 / 保存当前需要收集的响应式函数 /let activeReactviceFn = null/ 依赖收集类 /class Depend {constructor() {this.reactiveFns = new Set()}depend() {if (activeReactviceFn) {this.reactiveFns.add(activeReactviceFn)} }addDepend(reactiveFn) {this.reactiveFns.add(reactiveFn)}notify() {this.reactiveFns.forEach((fn) => {fn()})} }/ 封装一个响应式函数 /function watchFn(fn) {activeReactviceFn = fnfn()activeReactviceFn = null}/ 封装一个获取depend的函数 /const taregtMap = new WeakMap()function getDepend(target, key) {// 根据target对象获取maplet map = taregtMap.get(target)if (!map) {map = new Map()taregtMap.set(target, map)}// 根据key获取depend对象let depend = map.get(key)if (!depend) {depend = new Depend()map.set(key, depend)}return depend}/ 创建响应式对象函数 /function reactive(obj) {Object.keys(obj).forEach((key) => {let value = obj[key]Object.defineProperty(obj, key, {get: function () {const dep = getDepend(obj, key)dep.depend()return value},set: function (newValue) {value = newValueconst dep = getDepend(obj, key)dep.notify()} })})return obj}const info = reactive({address: '广州市',height: 1.88})watchFn(() => {console.log(info.address, '---')})info.address = '北京市' 本篇文章为转载内容。原文链接：https://blog.csdn.net/wanghuan1020/article/details/126774033。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...但是因为同一种能量包使用太多会带来副作用，因此同样的能量包不能同时使用超过两个，也就是说最多同时可以使用两个相同的能量包。 每种能量包都有一个重量值和能量值。由于这些能量包的特殊性，必须要完整地使用一个能量包才能够发挥功效，否则将失去对应的能量值。 考虑到竞赛的公平性，竞赛组委会规定每个人赛前补充的能量包的总重量不能超过W。 现在需要你编写一个程序计算出X星人能够拥有的最大能量值是多少？ 输入 单组输入。 第1行包含两个正整数N和W，其中N<=10^ 3，W<=10^ 3。 第2行到第N+1行，每一行包含两个正整数，分别表示每一种能量包的重量和能量值，两个正整数之间用空格隔开。每一种能量包的重量和能量值都是小于等于100的正整数。 输出 输出X星人能够拥有的最大能量值。 背包 可以看成每个物品个数为2的多重背包，用多重背包的方法做；也可以看成总共有2n个物品，用一般背包的方法做 //方法1include <bits/stdc++.h>using namespace std;int c[1005],w[1005];//重量 能量int f[10005];int main(){int n,m;cin>>n>>m;for(int i=1;i<=n;i++)cin>>c[i]>>w[i];for(int i=1;i<=n;i++)for(int j=m;j>=c[i];--j){for(int k=1;k<=2&&kc[i]<=j;k++){f[j]=max(f[j],f[j-c[i]k]+w[i]k);} }cout<<f[m]<<endl;return 0;}//方法2include<bits/stdc++.h>using namespace std;const int N=1e3+5;int a[2N],b[2N],dp[N],n,m;int main(){cin>>n>>m;for(int i=1;i<=n;i++){cin>>a[i]>>b[i];a[i+n]=a[i],b[i+n]=b[i];}for(int i=1;i<=2n;i++){for(int j=m;j>=a[i];j--){dp[j]=max(dp[j],dp[j-a[i]]+b[i]);} }cout<<dp[m]<<'\n';return 0;} E: 最大素数 题目描述 输入一个数字字符串，从中删除若干个（包含0个）数字后可以得到一个素数，请编写一个程序求解删除部分数字之后能够得到的最大素数。 例如，输入“1234”，删除1和4，可以得到的最大素数为23。 输入 输入一个数字字符串，从中删除若干个（包含0个）数字后可以得到一个素数，请编写一个程序求解删除部分数字之后能够得到的最大素数。 例如，输入“1234”，删除1和4，可以得到的最大素数为23。 输出 输入一个数字字符串，从中删除若干个（包含0个）数字后可以得到一个素数，请编写一个程序求解删除部分数字之后能够得到的最大素数。 例如，输入“1234”，删除1和4，可以得到的最大素数为23。 搜索 这里用的bfs，优先搜索当前最大的数，如果这个数已经是素数那么就是答案 我说不清楚，参考代码吧 include <bits/stdc++.h>using namespace std;bool isprime(int n){//素数判断if(n<2)return 0;for(int i=2;i<=(int)sqrt(n);++i)if(n%i==0)return 0;return 1;}struct node {string s;int len;bool operator<(const node &q)const{if(len!=q.len)return len<q.len;return s<q.s;} };bool check(string str){int m=0;for(int i=0;i<str.size();i++){m=m10+str[i]-'0';}return isprime(m);}bool flag;map<string,bool>vis;string s;void bfs(){priority_queue<node>q;q.push({s,s.size()});while(!q.empty()){node k=q.top();q.pop();if(vis[k.s])continue;vis[k.s]=1;if(check(k.s)){cout<<k.s<<endl;flag=1;return ;}for(int i=0;i<k.s.size();i++){//去掉第i个字符string s1=k.s.substr(0,i)+k.s.substr(i+1);q.push({s1,s1.size()});} }}int main(){cin>>s;bfs();if(!flag)puts("No result.");return 0;} F: 最大计分 题目描述 小米和小花在玩一个删除数字的游戏。 游戏规则如下： 首先随机写下N个正整数，然后任选一个数字作为起始点，从起始点开始从左往右每次可以删除一个数字，但是必须满足下一个删除的数字要小于上一个删除的数字。每成功删除一个数字计1分。 请问对于给定的N个正整数，一局游戏过后可以得到的最大计分是多少？ 输入 单组输入。 第1行输入一个正整数N表示数字的个数（N<=10^3）。 第2行输入N个正整数，两两之间用空格隔开。 输出 对于给定的N个正整数，一局游戏过后可以得到的最大计分值。 最长下降子序列 将数组逆转就等价于求最长上升子序列长度 include <bits/stdc++.h>using namespace std;int arr[1005];int main(){int n;cin>>n;for(int i=0;i<n;i++)cin>>arr[i];reverse(arr,arr+n);vector<int>stk;stk.push_back(arr[0]);for (int i = 1; i < n; ++i) {if (arr[i] > stk.back())stk.push_back(arr[i]);elselower_bound(stk.begin(), stk.end(), arr[i]) = arr[i];}cout << stk.size() << endl;return 0;} G: 密钥 题目描述 X星人又截获了Y星人的一段密文。 破解这段密文需要使用一个密钥，而这个密钥存在于一个正整数N中。 聪明的X星人终于找到了获取密钥的方法：这个正整数的最后一位是一个非零数K（K>=2），需要将正整数N切分成K个小的整数，并且要使得这K个较小整数的乘积达到最大。而所得到的最大乘积就是破解密文所需的密钥。 你能否帮X星人编写一段程序来得到密钥呢？ 输入 X星人又截获了Y星人的一段密文。 破解这段密文需要使用一个密钥，而这个密钥存在于一个正整数N中。 聪明的X星人终于找到了获取密钥的方法：这个正整数的最后一位是一个非零数K（K>=2），需要将正整数N切分成K个小的整数，并且要使得这K个较小整数的乘积达到最大。而所得到的最大乘积就是破解密文所需的密钥。 你能否帮X星人编写一段程序来得到密钥呢？ 输出 将N划分为K个整数后的最大乘积。 搜索 include <bits/stdc++.h>using namespace std;define ll long longll n;ll ans;void dfs(ll sum,ll m,int res){if(res==1){ans=max(ans,summ);return ;}int num=(int)log10(m)+1;//m的位数int k=10;for(int i=1;i<=num-res+1;i++){//保证剩余的数至少还有res-1位dfs(sum(m%k),m/k,res-1);k=10;}return ;}int main(){cin>>n;dfs(1ll,n,n%10);cout<<ans<<endl;return 0;} H: X星大学 题目描述 X星大学新校区终于建成啦！ 新校区一共有N栋教学楼和办公楼。现在需要用光纤把这N栋连接起来，保证任意两栋楼之间都有一条有线网络通讯链路。 已知任意两栋楼之间的直线距离（单位：千米）。为了降低成本，要求两栋楼之间都用直线光纤连接。 光纤的单位成本C已知（单位：X星币/千米），请问最少需要多少X星币才能保证任意两栋楼之间都有光纤直接或者间接相连？ 注意：如果1号楼和2号楼相连，2号楼和3号楼相连，则1号楼和3号楼间接相连。 输入 单组输入。 第1行输入两个正整数N和C，分别表示楼栋的数量和光纤的单位成本（单位：X星币/千米），N<=100，C<=100。两者之间用英文空格隔开。 接下来N(N-1)/2行，每行包含三个正整数，第1个正整数和第2个正整数表示楼栋的编号（从1开始一直到N），编号小的在前，编号大的在后，第3个正整数为两栋楼之间的直线距离（单位：千米）。 输出 输出最少需要多少X星币才能保证任意两栋楼之间都有光纤直接或者间接相连。 最小生成树模板题 //prim（）最小生成树include <bits/stdc++.h>using namespace std;define ll long longdefine INF 0x3f3f3f3fint n,c;int dist[105];bool vis[105];int a[105][105];ll prim(int pos){memset(dist,INF,sizeof(dist));dist[pos]=0;ll sum=0;for(int i=1;i<=n;i++){int cur=-1;for(int j=1;j<=n;j++){if(!vis[j]&&(cur==-1||dist[j]<dist[cur]))cur=j;}if(dist[cur]>=INF)return INF;sum+=dist[cur];vis[cur]=1;for(int l=1;l<=n;l++)if(!vis[l])dist[l]=min(dist[l],a[cur][l]);}return sum;}int main() {scanf("%d%d",&n,&c);int x,y,z;memset(a,INF,sizeof(a));for(int i=1;i<=n;i++)a[i][i]=0;for(int i=1;i<=n(n-1)/2;i++){scanf("%d%d%d",&x,&y,&z);a[x][y]=min(a[x][y],z);a[y][x]=a[x][y];}printf("%lld\n",prim(1)c);return 0;}//Kruskal（）最小生成树include<bits/stdc++.h>using namespace std;struct node {int x,y,z;}edge[10005];bool cmp(node a,node b) {return a.z < b.z;}int fa[105];int n,m,c;long long sum;int get(int x) {return x == fa[x] ? x : fa[x] = get(fa[x]);}int main() {scanf("%d%d",&n,&c);m=n(n-1)/2;for(int i = 1; i <= m; i ++) {scanf("%d%d%d",&edge[i].x,&edge[i].y,&edge[i].z);}for(int i = 0; i <= n; i ++) {fa[i] = i;}sort(edge + 1,edge + 1 + m,cmp);// 每次加入一条最短的边for(int i = 1; i <= m; i ++) {int x = get(edge[i].x);int y = get(edge[i].y);if(x == y) continue;fa[y] = x;sum += edge[i].z;}printf("%lld\n",sumc);return 0;} 本篇文章为转载内容。原文链接：https://blog.csdn.net/qq_52139055/article/details/123284091。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...数的代码实现中，我们使用showString函数把被加载执行的用户进程数据段所对应的全局描述符号给显示到桌面上，上面代码执行后情况如下： 我们看到，在控制台中执行hlt命令后，内核加载了用户进程，同时在控制台下方输出了一个字符串，也就是0x1E,这个数值对应的就是当前运行用户进程其数据段对应的全局描述符号。一旦有这个信息之后，另一个进程就可以有机可乘了。 接着我们在本地目录创建一个新文件叫crack.c,其内容如下： void main() {char p = (char)0x123;p[0] = 'c';p[1] = 'r';p[2] = 'a';p[3] = 'c';p[4] = 'k';p[5] = 0;} 它的目的简单，就是针对内存地址0x123处写入字符串”crack”.接着我们修改一下makefile，使得内核编译时，能把crack.c编译成二进制文件： CFLAGS=-fno-stack-protectorckernel : ckernel_u.asm app_u.asm crack_u.asm cp ckernel_u.asm win_sheet.h win_sheet.c mem_util.h mem_util.c write_vga_desktop.c timer.c timer.h global_define.h global_define.c multi_task.c multi_task.h app_u.asm app.c crack_u.asm crack.c makefile '/media/psf/Home/Documents/操作系统/文档/19/OS-kernel-win-sheet/'ckernel_u.asm : ckernel.o....crack_u.asm : crack.o./objconv -fnasm crack.o crack_u.asmcrack.o : crack.cgcc -m32 -fno-stack-protector -fno-asynchronous-unwind-tables -s -c -o crack.o crack.c 然后我们在本地目录下，把api_call.asm拷贝一份，并命名为crack_call.asm,后者内容与前者完全相同，只不过稍微有那么一点点改变，例如： BITS 32mov AX, 30 8mov DS, axcall mainmov edx, 4 ;返回内核int 02Dh.... 这里需要注意，语句： mov AX, 30 8mov DS, ax 其中30对应的就是前面显示的0x1E，这两句汇编的作用是，把程序crack的数据段设置成下标为30的全局描述符所指向的内存段一致。这就意味着crack进程所使用的数据段就跟hlt启动的进程所使用的数据段一致了！于是在crack.c中，它对内存地址为0x123的地方写入字符串”crack”,那就意味着对hlt加载用户进程的内存空间写入对应字符串！ 完成上面代码后，我们在java项目中，增加代码，一是用来编译crack进程，而是把crack代码写入虚拟磁盘。在OperatingSystem.java中，将代码做如下添加： public void makeFllopy() {writeFileToFloppy("kernel.bat", false, 1, 1);....header = new FileHeader();header.setFileName("crack");header.setFileExt("exe");file = new File("crack.bat");in = null;try {in = new FileInputStream(file);long len = file.length();int count = 0;while (count < file.length()) {bbuf[count] = (byte) in.read();count++;}in.close();}catch(IOException e) {e.printStackTrace();return;}header.setFileContent(bbuf);fileSys.addHeader(header);....}public static void main(String[] args) {CKernelAsmPrecessor kernelPrecessor = new CKernelAsmPrecessor();kernelPrecessor.process();kernelPrecessor.createKernelBinary();CKernelAsmPrecessor appPrecessor = new CKernelAsmPrecessor("hlt.bat", "app_u.asm", "app.asm", "api_call.asm");appPrecessor.process();appPrecessor.createKernelBinary();CKernelAsmPrecessor crackPrecessor = new CKernelAsmPrecessor("crack.bat", "crack_u.asm", "crack.asm", "crack_call.asm");crackPrecessor.process();crackPrecessor.createKernelBinary();OperatingSystem op = new OperatingSystem("boot.bat");op.makeFllopy();} 在main函数中，我们把crack.c及其附属汇编文件结合在一起，编译成二进制文件crack.bat，在makeFllopy中，我们把编译后的crack.bat二进制数据读入，并把它写入到虚拟磁盘中，当系统运行起来后，可以把crack.bat二进制内容作为进程加载执行。 完成上面代码后，回到内核的C语言部分，也就是write_vga_desktop.c做一些修改，在kernel_api函数中，修改如下： int kernel_api(int edi, int esi, int ebp, int esp,int ebx, int edx, int ecx, int eax) {....else if (edx == 14) {sheet_free(shtctl, (struct SHEET)ebx);//change herecons_putstr((char)(task->pTaskBuffer->pDataSeg + 0x123));}....}void console_task(struct SHEET sheet, int memtotal) {....for(;;) {....else if (i == KEY_RETURN) {....else if (strcmp(cmdline, "crack") == 1) {cmd_execute_program("crack.exe");}....}....} 在kernel_api中，if(edx == 14)对应的api调用是api_closewin，也就是当用户进程关闭窗口时，我们把进程数据偏移0x123处的数据当做字符串打印到控制台窗口上，在console_task控制台进程主函数中，我们增加了对命令crack的响应，当用户在控制台上输入命令”crack”时，将crack代码加载到内核中运行。上面代码完成后，编译内核，然后用虚拟机将内核加载，系统启动后，我们现在一个控制台中输入hlt，先启动用户进程。然后点击”shift + w”,启动另一个控制台窗口，在其中输入crack，运行crack程序： 接着把点击tab键，把焦点恢复到窗口task_a，然后用鼠标点击运行hlt命令的窗口，把输入焦点切换到该控制台，然后再次点击tab键，把执行权限提交给运行hlt命令的控制台，此时点击回车，介绍用户进程启动的窗口，结果情况如下： 此时我们可以看到，运行hlt命令，执行用户进程的控制台窗口居然输出了字符串”crack”,而这个字符串正是crack.c在执行时，写入地址0x123的字符串。这就意味着一个恶意进程成功修改了另一个进程的内存数据，也相当于一个流氓程序把一只咸猪手伸到其他用户进程的裙底，蹂躏一番后留下了猥琐的证据。 那么如何防范恶意进程对其他程序的非法入侵呢，这就得使用CPU提供的LDT机制，也就是局部描述符表，该机制的使用，我们将在下一节详细讲解。更详细的讲解和代码演示调试，请参看视频： 更详细的讲解和代码调试演示过程，请参看视频 Linux kernel Hacker, 从零构建自己的内核 更多技术信息，包括操作系统，编译器，面试算法，机器学习，人工智能，请关照我的公众号： 本篇文章为转载内容。原文链接：https://blog.csdn.net/tyler_download/article/details/78731905。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...性导航的技术，并不断优化以提高实时定位和姿态估计的准确性。例如，一篇发布于《Nature》子刊《Machine Intelligence》上的文章揭示了他们如何将VIO与高精地图信息深度融合，以应对城市道路中的各种挑战。 此外，对于学术界和工业界来说，开源项目如OpenVINS、OKVIS以及本文提及的VINS-Fusion等持续迭代更新，不仅推动了VIO技术的发展，也为广大研究者提供了宝贵的实验平台。这些项目通过融合多传感器数据，实现了在无人机、机器人以及其他移动设备上的高效稳定定位导航。 总的来说，随着硬件性能的提升和算法优化的深化，视觉惯性里程计正逐渐成为自主导航系统中不可或缺的核心组件。在未来，我们期待看到更多创新性的研究成果和技术突破，进一步提升VIO在复杂环境下的适用性和可靠性。

...程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。Quartz 是个开源的作业调度框架，为在 Java 应用程序中进行作业调度提供了简单却强大的机制。Quartz 允许开发人员根据时间间隔（或天）来调度作业。它实现了作业和触发器的多对多关系，还能把多个作业与不同的触发器关联。整合了 Quartz 的应用程序可以重用来自不同事件的作业，还可以为一个事件组合多个作业。虽然可以通过属性文件（在属性文件中可以指定 JDBC 事务的数据源、全局作业和/或触发器侦听器、插件、线程池，以及更多）配置 Quartz，但它根本没有与应用程序服务器的上下文或引用集成在一起。结果就是作业不能访问 Web 服务器的内部函数；例如，在使用 WebSphere 应用服务器时，由 Quartz 调度的作业并不能影响服务器的动态缓存和数据源。 二、java中实现定时任务分类 从实现的技术上来分类，目前主要有三种技术（或者说有三种产品）： Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行。一般用的较少，这篇文章将不做详细介绍。 使用Quartz，这是一个功能比较强大的的调度器，可以让你的程序在指定时间执行，也可以按照某一个频度执行，配置起来稍显复杂，稍后会详细介绍。 Spring3.0以后自带的task，可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多，稍后会介绍。 从作业类的继承方式来讲，可以分为两类： 作业类需要继承自特定的作业类基类，如Quartz中需要继承自org.springframework.scheduling.quartz.QuartzJobBean；java.util.Timer中需要继承自java.util.TimerTask。 作业类即普通的java类，不需要继承自任何基类。 注:个人推荐使用第二种方式，因为这样所以的类都是普通类，不需要事先区别对待。 从任务调度的触发时机来分，这里主要是针对作业使用的触发器，主要有以下两种： 每隔指定时间则触发一次，在Quartz中对应的触发器为：org.springframework.scheduling.quartz.SimpleTriggerBean 每到指定时间则触发一次，在Quartz中对应的调度器为：org.springframework.scheduling.quartz.CronTriggerBean 注：并非每种任务都可以使用这两种触发器，如java.util.TimerTask任务就只能使用第一种。Quartz和spring task都可以支持这两种触发条件。 三、Quartz与Spring的集成 第一种，作业类继承自特定的基类：org.springframework.scheduling.quartz.QuartzJobBean。 第一步：定义作业类 Java代码 import org.quartz.JobExecutionContext; import org.quartz.JobExecutionException; import org.springframework.scheduling.quartz.QuartzJobBean; public class Job1 extends QuartzJobBean { private int timeout; private static int i = 0; //调度工厂实例化后，经过timeout时间开始执行调度 public void setTimeout(int timeout) { this.timeout = timeout; } / 要调度的具体任务 / @Override protected void executeInternal(JobExecutionContext context) throws JobExecutionException { System.out.println("定时任务执行中…"); } } 第二步：spring配置文件中配置作业类JobDetailBean Xml代码 <bean name="job1" class="org.springframework.scheduling.quartz.JobDetailBean"> <property name="jobClass" value="com.gy.Job1" /> <property name="jobDataAsMap"> <map> <entry key="timeout" value="0" /> </map> </property> </bean> 说明：org.springframework.scheduling.quartz.JobDetailBean有两个属性，jobClass属性即我们在java代码中定义的任务类，jobDataAsMap属性即该任务类中需要注入的属性值。 第三步：配置作业调度的触发方式（触发器） Quartz的作业触发器有两种，分别是 org.springframework.scheduling.quartz.SimpleTriggerBean org.springframework.scheduling.quartz.CronTriggerBean 第一种SimpleTriggerBean，只支持按照一定频度调用任务，如每隔30分钟运行一次。 配置方式如下： Xml代码 <bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean"> <property name="jobDetail" ref="job1" /> <property name="startDelay" value="0" /><!-- 调度工厂实例化后，经过0秒开始执行调度 --> <property name="repeatInterval" value="2000" /><!-- 每2秒调度一次 --> </bean> 第二种CronTriggerBean，支持到指定时间运行一次，如每天12:00运行一次等。 配置方式如下： Xml代码 <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"> <property name="jobDetail" ref="job1" /> <!—每天12:00运行一次 --> <property name="cronExpression" value="0 0 12 ?" /> </bean> 关于cronExpression表达式的语法参见附录。 第四步：配置调度工厂 Xml代码 <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> <property name="triggers"> <list> <ref bean="cronTrigger" /> </list> </property> </bean> 说明：该参数指定的就是之前配置的触发器的名字。 第五步：启动你的应用即可，即将工程部署至tomcat或其他容器。 第二种，作业类不继承特定基类。 Spring能够支持这种方式，归功于两个类： org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBean org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean 这两个类分别对应spring支持的两种实现任务调度的方式，即前文提到到java自带的timer task方式和Quartz方式。这里我只写MethodInvokingJobDetailFactoryBean的用法，使用该类的好处是,我们的任务类不再需要继承自任何类，而是普通的pojo。 第一步：编写任务类 Java代码 public class Job2 { public void doJob2() { System.out.println("不继承QuartzJobBean方式-调度进行中..."); } } 可以看出，这就是一个普通的类，并且有一个方法。 第二步：配置作业类 Xml代码 <bean id="job2" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"> <property name="targetObject"> <bean class="com.gy.Job2" /> </property> <property name="targetMethod" value="doJob2" /> <property name="concurrent" value="false" /><!-- 作业不并发调度 --> </bean> 说明：这一步是关键步骤，声明一个MethodInvokingJobDetailFactoryBean，有两个关键属性：targetObject指定任务类，targetMethod指定运行的方法。往下的步骤就与方法一相同了，为了完整，同样贴出。 第三步：配置作业调度的触发方式（触发器） Quartz的作业触发器有两种，分别是 org.springframework.scheduling.quartz.SimpleTriggerBean org.springframework.scheduling.quartz.CronTriggerBean 第一种SimpleTriggerBean，只支持按照一定频度调用任务，如每隔30分钟运行一次。 配置方式如下： Xml代码 <bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean"> <property name="jobDetail" ref="job2" /> <property name="startDelay" value="0" /><!-- 调度工厂实例化后，经过0秒开始执行调度 --> <property name="repeatInterval" value="2000" /><!-- 每2秒调度一次 --> </bean> 第二种CronTriggerBean，支持到指定时间运行一次，如每天12:00运行一次等。 配置方式如下： Xml代码 <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"> <property name="jobDetail" ref="job2" /> <!—每天12:00运行一次 --> <property name="cronExpression" value="0 0 12 ?" /> </bean> 以上两种调度方式根据实际情况，任选一种即可。 第四步：配置调度工厂 Xml代码 <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> <property name="triggers"> <list> <ref bean="cronTrigger" /> </list> </property> </bean> 说明：该参数指定的就是之前配置的触发器的名字。 第五步：启动你的应用即可，即将工程部署至tomcat或其他容器。 到此，spring中Quartz的基本配置就介绍完了，当然了，使用之前，要导入相应的spring的包与Quartz的包，这些就不消多说了。 其实可以看出Quartz的配置看上去还是挺复杂的，没有办法，因为Quartz其实是个重量级的工具，如果我们只是想简单的执行几个简单的定时任务，有没有更简单的工具，有！ 四、Spring-Task 上节介绍了在Spring 中使用Quartz，本文介绍Spring3.0以后自主开发的定时任务工具，spring task，可以将它比作一个轻量级的Quartz，而且使用起来很简单，除spring相关的包外不需要额外的包，而且支持注解和配置文件两种 形式，下面将分别介绍这两种方式。 第一种：配置文件方式 第一步：编写作业类 即普通的pojo，如下： Java代码 import org.springframework.stereotype.Service; @Service public class TaskJob { public void job1() { System.out.println(“任务进行中。。。”); } } 第二步：在spring配置文件头中添加命名空间及描述 Xml代码 <beans xmlns="http://www.springframework.org/schema/beans" xmlns:task="http://www.springframework.org/schema/task" 。。。。。。 xsi:schemaLocation="http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd"> 第三步：spring配置文件中设置具体的任务 Xml代码 <task:scheduled-tasks> <task:scheduled ref="taskJob" method="job1" cron="0 ?"/> </task:scheduled-tasks> <context:component-scan base-package=" com.gy.mytask " /> 说明：ref参数指定的即任务类，method指定的即需要运行的方法，cron及cronExpression表达式，具体写法这里不介绍了，详情见上篇文章附录。 <context:component-scan base-package="com.gy.mytask" />这个配置不消多说了，spring扫描注解用的。 到这里配置就完成了，是不是很简单。 第二种：使用注解形式 也许我们不想每写一个任务类还要在xml文件中配置下，我们可以使用注解@Scheduled，我们看看源文件中该注解的定义： Java代码 @Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.ANNOTATION_TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Scheduled { public abstract String cron(); public abstract long fixedDelay(); public abstract long fixedRate(); } 可以看出该注解有三个方法或者叫参数，分别表示的意思是： cron：指定cron表达式 fixedDelay：官方文档解释：An interval-based trigger where the interval is measured from the completion time of the previous task. The time unit value is measured in milliseconds.即表示从上一个任务完成开始到下一个任务开始的间隔，单位是毫秒。 fixedRate：官方文档解释：An interval-based trigger where the interval is measured from the start time of the previous task. The time unit value is measured in milliseconds.即从上一个任务开始到下一个任务开始的间隔，单位是毫秒。 下面我来配置一下。 第一步：编写pojo Java代码 import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component; @Component(“taskJob”) public class TaskJob { @Scheduled(cron = "0 0 3 ?") public void job1() { System.out.println(“任务进行中。。。”); } } 第二步：添加task相关的配置： Xml代码 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:task="http://www.springframework.org/schema/task" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd" default-lazy-init="false"> <context:annotation-config /> <!—spring扫描注解的配置 --> <context:component-scan base-package="com.gy.mytask" /> <!—开启这个配置，spring才能识别@Scheduled注解 --> <task:annotation-driven scheduler="qbScheduler" mode="proxy"/> <task:scheduler id="qbScheduler" pool-size="10"/> 说明：理论上只需要加上<task:annotation-driven />这句配置就可以了，这些参数都不是必须的。 Ok配置完毕，当然spring task还有很多参数，我就不一一解释了，具体参考xsd文档http://www.springframework.org/schema/task/spring-task-3.0.xsd。 附录： cronExpression的配置说明，具体使用以及参数请百度google 字段 允许值 允许的特殊字符 秒 0-59 , - / 分 0-59 , - / 小时 0-23 , - / 日期 1-31 , - ? / L W C 月份 1-12 或者 JAN-DEC , - / 星期 1-7 或者 SUN-SAT , - ? / L C 年（可选） 留空, 1970-2099 , - / - 区间 通配符 ? 你不想设置那个字段 下面只例出几个式子 CRON表达式 含义 "0 0 12 ?" 每天中午十二点触发 "0 15 10 ? " 每天早上10：15触发 "0 15 10 ?" 每天早上10：15触发 "0 15 10 ? " 每天早上10：15触发 "0 15 10 ? 2005" 2005年的每天早上10：15触发 "0 14 ?" 每天从下午2点开始到2点59分每分钟一次触发 "0 0/5 14 ?" 每天从下午2点开始到2：55分结束每5分钟一次触发 "0 0/5 14,18 ?" 每天的下午2点至2：55和6点至6点55分两个时间段内每5分钟一次触发 "0 0-5 14 ?" 每天14:00至14:05每分钟一次触发 "0 10,44 14 ? 3 WED" 三月的每周三的14：10和14：44触发 "0 15 10 ? MON-FRI" 每个周一、周二、周三、周四、周五的10：15触发 Cron 表达式包括以下 7 个字段： 秒 分 小时 月内日期 月 周内日期 年（可选字段） 特殊字符 Cron 触发器利用一系列特殊字符，如下所示： 反斜线（/）字符表示增量值。例如，在秒字段中“5/15”代表从第 5 秒开始，每 15 秒一次。 问号（?）字符和字母 L 字符只有在月内日期和周内日期字段中可用。问号表示这个字段不包含具体值。所以，如果指定月内日期，可以在周内日期字段中插入“?”，表示周内日期值无关紧要。字母 L 字符是 last 的缩写。放在月内日期字段中，表示安排在当月最后一天执行。在周内日期字段中，如果“L”单独存在，就等于“7”，否则代表当月内周内日期的最后一个实例。所以“0L”表示安排在当月的最后一个星期日执行。 在月内日期字段中的字母（W）字符把执行安排在最靠近指定值的工作日。把“1W”放在月内日期字段中，表示把执行安排在当月的第一个工作日内。 井号（）字符为给定月份指定具体的工作日实例。把“MON2”放在周内日期字段中，表示把任务安排在当月的第二个星期一。 星号（）字符是通配字符，表示该字段可以接受任何可能的值。 字段 允许值 允许的特殊字符 秒 0-59 , - / 分 0-59 , - / 小时 0-23 , - / 日期 1-31 , - ? / L W C 月份 1-12 或者 JAN-DEC , - / 星期 1-7 或者 SUN-SAT , - ? / L C 年（可选） 留空, 1970-2099 , - / 表达式意义 "0 0 12 ?" 每天中午12点触发 "0 15 10 ? " 每天上午10:15触发 "0 15 10 ?" 每天上午10:15触发 "0 15 10 ? " 每天上午10:15触发 "0 15 10 ? 2005" 2005年的每天上午10:15触发 "0 14 ?" 在每天下午2点到下午2:59期间的每1分钟触发 "0 0/5 14 ?" 在每天下午2点到下午2:55期间的每5分钟触发 "0 0/5 14,18 ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发 "0 0-5 14 ?" 在每天下午2点到下午2:05期间的每1分钟触发 "0 10,44 14 ? 3 WED" 每年三月的星期三的下午2:10和2:44触发 "0 15 10 ? MON-FRI" 周一至周五的上午10:15触发 "0 15 10 15 ?" 每月15日上午10:15触发 "0 15 10 L ?" 每月最后一日的上午10:15触发 "0 15 10 ? 6L" 每月的最后一个星期五上午10:15触发 "0 15 10 ? 6L 2002-2005" 2002年至2005年的每月的最后一个星期五上午10:15触发 "0 15 10 ? 63" 每月的第三个星期五上午10:15触发 每天早上6点 0 6 每两个小时 0 /2 晚上11点到早上8点之间每两个小时，早上八点 0 23-7/2，8 每个月的4号和每个礼拜的礼拜一到礼拜三的早上11点 0 11 4 1-3 1月1日早上4点 0 4 1 1 本篇文章为转载内容。原文链接：https://zhanghaiyang.blog.csdn.net/article/details/51397459。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

... 7、对应第4块创建标签，第一个名称为DB4.0-99，地址为DB4DBW0.100，数据类型为Short，长度100，即定义长度最长为100的Short数组。第二个名称为DB4.100-109，地址为DB4DBW100.10，数据类型为Short，方便快速读取。 5、对应第5块创建3个标签，第一个名称为DB5.0-99，地址为DB5DBW0.100，数据类型为Short，第二个名称为DB5.100-121， 地址为DB5DBW100.22，数据类型为Short，即定义长度最长为100的Short数组。方便快速读取。第三个标签名称为DB5DBW64，地址为DB5DBW64，数据类型为Short。 具体如下图： 关键代码 using System;using System.Collections.Generic;using System.Linq;using Opc.Ua.Helper;using Mesnac.Equips;namespace Mesnac.Equip.OPC.OpcUa.OPCUA{public class Equip : BaseEquip{region 字段定义private bool _isOpen = false; //是否已打开设备private bool _isClosing = false; //是否正在关闭设备private OPCUAClass myOpcHelper; //OPCUA设备访问辅助对象private Dictionary<string, string> dicTags = null; //保存标签集合private Dictionary<string, object> readResult = null; //设备标签数据缓存private int stepLen = 250; //标签变量的步长设置private string groupNamePrefix = "DB"; //数据块号前缀private string childTagFlag = "~"; //子元素标签标志符private System.Threading.Thread innerReadThread = null; //内部读取线程对象private int innerReadRate = 1000; //内部读取频率endregionregion 属性定义/// <summary>/// OPCUA Server Url/// </summary>public string OpcUaServerUrl{get{//return (this.Main.ConnType as Mesnac.Equips.Connection.OPCUA.ConnType).OpcUaServerUrl;return "opc.tcp://192.168.1.102:4840";//return "opc.tcp://192.168.100.1:4840";//return "opc.tcp://192.168.100.2:4840";} }/// <summary>/// 要连接的OPCUA服务器上的服务名/// </summary>public string OpcUaServiceName{get{//return (this.Main.ConnType as Mesnac.Equips.Connection.OPCUA.ConnType).OpcUaServiceName;return "[UaServer@cMT-9F1F] [None] [None] [opc.tcp://192.168.1.102:4840/G01]";//return "[UaServer@cMT-EAB9] [None] [None] [opc.tcp://192.168.100.1:4840/G01]";//return "[UaServer@cMT-EA5B] [None] [None] [opc.tcp://192.168.100.2:4840/G02]";//return "[UaServer@cMT-EA5B] [None] [None] [opc.tcp://192.168.100.2:4840/G01]";} }/// <summary>/// 要连接的OPCUA服务器上指定服务名下的PLC的名称/// </summary>public string PLCName{get{//return (this.Main.ConnType as Mesnac.Equips.Connection.OPCUA.ConnType).PLCName;//return "Feeding";return "Siemens_192.168.2.1";//return "Rockwell_192.168.1.10";} }/// <summary>/// OPCUA服务器的访问账户/// </summary>public string Account{get{//return (this.Main.ConnType as Mesnac.Equips.Connection.OPCUA.ConnType).Account;return "user1";} }/// <summary>/// OPCUA服务器的访问密码/// </summary>public string Password{get{//return (this.Main.ConnType as Mesnac.Equips.Connection.OPCUA.ConnType).Password;return "1";} }endregionregion BaseEquip成员实现/// <summary>/// 打开连接设备/// </summary>/// <returns>成功返回true，失败返回false</returns>public override bool Open(){lock (this){this._isClosing = false;if (this._isOpen == true && this.myOpcHelper != null){return true;}this.State = false;this.myOpcHelper = new OPCUAClass();this.dicTags = this.myOpcHelper.ConnectOPCUA(this.OpcUaServerUrl, this.Account, this.Password, this.OpcUaServiceName, this.PLCName); //连接OPCServerif (this.dicTags == null || this.dicTags.Count == 0){this.myOpcHelper = null;Console.WriteLine("OPC连接失败!");this.State = false;return false;}else{this.State = true;this._isOpen = true;region 初始化读取结果this.readResult = new Dictionary<string, object>();foreach (Equips.BaseInfo.Group group in this.Group.Values){if (!group.IsAutoRead){continue;}int groupMinStart = group.Start;int groupMaxEnd = group.Start + group.Len;int groupMaxLen = group.Len;foreach (Equips.BaseInfo.Group g in this.Group.Values){if (!g.IsAutoRead){continue;}if (g.Block == group.Block){if (g.Start < group.Start){groupMinStart = g.Start;}if (g.Start + g.Len > groupMaxEnd){groupMaxEnd = g.Start + g.Len;} }}groupMaxLen = groupMaxEnd - groupMinStart;int tagCount = groupMaxLen % this.stepLen == 0 ? groupMaxLen / this.stepLen : groupMaxLen / this.stepLen + 1;int currLen = 0;for (int i = 0; i < tagCount; i++){string tagName = String.Empty;if (tagCount == 1){tagName = String.Format("{0}-{1}", groupMinStart, groupMinStart + groupMaxLen - 1);currLen = groupMaxLen;}else if (i == tagCount - 1){tagName = String.Format("{0}-{1}", groupMinStart + (i this.stepLen), groupMinStart + (i this.stepLen) + (groupMaxLen % this.stepLen == 0 ? this.stepLen : groupMaxLen % this.stepLen) - 1);currLen = groupMaxLen % this.stepLen;}else{tagName = String.Format("{0}-{1}", groupMinStart + (i this.stepLen), groupMinStart + (i this.stepLen) + this.stepLen - 1);currLen = this.stepLen;}string tagFullName = String.Format("{0}{1}.{2}", groupNamePrefix, group.Block, tagName);if (!this.readResult.ContainsKey(tagFullName)){bool exists = false;region 判断读取结果标签组的范围是否包括了此标签 比如tagFullName DB5.220-299,在readResult中存在 DB5.200-299，则认为已存在，不需要再添加string[] beginend = null;int begin = 0;int end = 0;string[] startstop = tagFullName.Replace(String.Format("{0}{1}.", groupNamePrefix, group.Block), String.Empty).Split(new char[] { '-' });int start = 0;int stop = 0;bool parseResult = false;if (startstop.Length == 2){parseResult = int.TryParse(startstop[0], out start);if (parseResult){parseResult = int.TryParse(startstop[1], out stop);} }if (parseResult){int existsMinBegin = 0; //已存在标签的最小开始索引int existsMaxEnd = 0; //已存在标签的最大结束索引bool isContinue = true; //标签值是否连续string[] existsTags = this.readResult.Keys.ToArray<string>();foreach (string tag in existsTags){if (tag.StartsWith(String.Format("{0}{1}.", groupNamePrefix, group.Block)) && tag.Contains(".") && tag.Contains("-")){string[] tagname = tag.Split(new char[] { '.' });if (tagname.Length == 2){beginend = tagname[1].Split(new char[] { '-' });if (beginend.Length == 2){parseResult = int.TryParse(beginend[0], out begin);if (parseResult){parseResult = int.TryParse(beginend[1], out end);}region 计算最小开始索引和最大结束索引if (begin < existsMinBegin){existsMinBegin = begin;region 判断标签值是否连续if (existsMaxEnd != 0 && begin != existsMaxEnd + 1){isContinue = false;}endregion}if (end > existsMaxEnd){existsMaxEnd = end;}endregion} }if (parseResult){if (start >= begin && stop <= end){exists = true;break;}if (isContinue){if (start >= existsMinBegin && stop <= existsMaxEnd){exists = true;break;} }} }} }endregionif (!exists){ushort[] groupData = new ushort[currLen];this.readResult[tagFullName] = groupData;Console.WriteLine(tagFullName);} }}//int tagCount = group.Len % this.stepLen == 0 ? group.Len / this.stepLen : group.Len / this.stepLen + 1;//int currLen = 0;//for (int i = 0; i < tagCount; i++)//{// string tagName = String.Empty;// if (tagCount == 1)// {// tagName = String.Format("{0}-{1}", group.Start, group.Start + group.Len - 1);// currLen = group.Len;// }// else if (i == tagCount - 1)// {// tagName = String.Format("{0}-{1}", group.Start + (i this.stepLen), group.Start + (i this.stepLen) + (group.Len % this.stepLen == 0 ? this.stepLen : group.Len % this.stepLen) - 1);// currLen = group.Len % this.stepLen;// }// else// {// tagName = String.Format("{0}-{1}", group.Start + (i this.stepLen), group.Start + (i this.stepLen) + this.stepLen - 1);// currLen = this.stepLen;// }// string tagFullName = String.Format("{0}{1}.{2}", groupNamePrefix, group.Block, tagName);// if (!this.readResult.ContainsKey(tagFullName))// {// short[] groupData = new short[currLen];// this.readResult[tagFullName] = groupData;// }//} }endregionregion 开启内部定时读取if (this.innerReadThread == null){this.innerReadRate = this.Main.ReadHz / 2;this.innerReadThread = new System.Threading.Thread(this.InnerAutoRead);this.innerReadThread.Start();}endregion}return this.State;} }/// <summary>/// 从设备读取数据/// </summary>/// <param name="block">要读取的块号</param>/// <param name="start">要读取的起始字</param>/// <param name="len">要读取的长度</param>/// <param name="buff">读取成功后的输出数据</param>/// <returns>成功返回true，失败返回false</returns>public override bool Read(string block, int start, int len, out object[] buff){lock (this){buff = null;if (this._isClosing){return false;}string readstrflag = String.Format("{0}{1}.{2}-{3}", this.groupNamePrefix, block, start, start + len - 1);System.Text.StringBuilder sbtaglength = new System.Text.StringBuilder();string startTag = String.Empty;string groupName = String.Format("{0}{1}", this.groupNamePrefix, block); //要读取的OPCServer块List<ushort> groupData = new List<ushort>();List<string> groupTagNames = new List<string>();int startIndex = 0;try{if (!Open()){return false;}//return true;string[] keys = this.readResult.Keys.ToArray<string>();foreach (string key in keys){if (key.StartsWith(groupName) && key.Replace(String.Format("{0}.", groupName), String.Empty).Contains("-")){groupTagNames.Add(key);} }groupTagNames.Sort(); //对块标签进行排序foreach (string key in groupTagNames){if (String.IsNullOrEmpty(startTag)){startTag = key.Replace(String.Format("{0}.", groupName), String.Empty);}ushort[] values;if (this.readResult[key] is ushort[]){values = this.readResult[key] as ushort[];}else{values = new ushort[] { (ushort)this.readResult[key] };}sbtaglength.Append(String.Format("tagName={0}, buff length = {1}", key, values.Length));groupData.AddRange(values);}buff = new object[len];if (!String.IsNullOrEmpty(startTag)){string strStartIndex = startTag.Substring(0, startTag.IndexOf("-"));int.TryParse(strStartIndex, out startIndex);startIndex = start - startIndex;Array.Copy(groupData.ToArray(), startIndex, buff, 0, buff.Length);}else{}return true;}catch (Exception ex){Console.WriteLine(String.Join(";", groupTagNames.ToArray<string>()));Console.WriteLine("data length = " + groupData.Count);Console.WriteLine(this.Name + "读取失败[" + readstrflag + "]:" + ex.Message);Console.WriteLine(sbtaglength.ToString());this.State = false;return false;} }}/// <summary>/// 写入数据到设备/// </summary>/// <param name="block">要写入的块号</param>/// <param name="start">要写入的起始字</param>/// <param name="buff">要写如的数据</param>/// <returns>成功返回true，失败返回false</returns>public override bool Write(int block, int start, object[] buff){bool result = true;lock (this){try{if (this._isClosing){return false;}if (!Open()){return false;}bool isWrite = false;region 按标签变量写入string itemId = "";foreach (Equips.BaseInfo.Group group in this.Group.Values){if (group.Block == block.ToString()){foreach (Equips.BaseInfo.Data data in group.Data.Values){if (group.Start + data.Start == start && data.Len == buff.Length){if (this.dicTags.ContainsKey(data.Name)){itemId = this.dicTags[data.Name];}break;} }} }if (!String.IsNullOrEmpty(itemId)){UInt16[] intBuff = new UInt16[buff.Length];for (int i = 0; i < intBuff.Length; i++){intBuff[i] = 0;if (!UInt16.TryParse(buff[i].ToString(), out intBuff[i])){Console.WriteLine("在写入OPCUA标签时把buff中的元素转为UInt16类型失败!");} }result = this.myOpcHelper.WriteUInt16(itemId, intBuff);if (!result){Console.WriteLine(String.Format("标签变量[{0}]写入失败!", itemId));return false;}else{Console.WriteLine("按标签变量写入..." + itemId);isWrite = true;} }if (isWrite){return true;}endregionregion 按块写入region 先读取相应标签数数据string startTag = String.Empty;string groupName = String.Format("{0}{1}", this.groupNamePrefix, block); //要读取的OPCServer块List<ushort> groupData = new List<ushort>();string[] keys = readResult.Keys.Where(o => o.StartsWith(groupName) && o.Contains("-")).OrderBy(c => c).ToArray<string>();foreach (string key in keys){if (String.IsNullOrEmpty(startTag)){startTag = key.Replace(String.Format("{0}.", groupName), String.Empty);}string[] beginEnd = key.Replace(String.Format("{0}.", groupName), String.Empty).Split(new char[] { '-' });if (beginEnd.Length != 2){Console.WriteLine(String.Format("标签变量[{0}]未按约定方式命名，请按[DB块号].[起始字-结束字]方式标签变量进行命名！", String.Format("{0}.{1}", key)));return false;}int begin = 0;int end = 0;int.TryParse(beginEnd[0], out begin);int.TryParse(beginEnd[1], out end);region 写入之前，先读取一下PLC的值if ((start >= begin && start <= end) || ((start + buff.Length - 1) >= begin && (start + buff.Length - 1) <= end) || (start < begin && (start + buff.Length - 1) > end)){this.ReadTag(key);if (this.readResult.ContainsKey(key) && this.readResult[key] is Array){Console.WriteLine("read = " + key);groupData.AddRange(this.readResult[key] as ushort[]);}else{Console.WriteLine(String.Format("读取结果中不包含标签变量[{0}]的值!", String.Format("{0}", key)));} }else{if (this.readResult.ContainsKey(key) && this.readResult[key] is Array){Console.WriteLine("no read = " + key);groupData.AddRange(this.readResult[key] as ushort[]);} }endregion}endregionif (String.IsNullOrEmpty(startTag)){Console.WriteLine("写入失败，未在OPCUAserver中找到对应的标签,block = {0}, start = {1}, len = {2}", block, start, buff.Length);return false;}region 更新标签中对应的数据后，再写回OPCServerint startIndex = 0;string strStartIndex = startTag.Substring(0, startTag.IndexOf("-"));int.TryParse(strStartIndex, out startIndex);startIndex = start - startIndex;ushort[] newDataBuffer = groupData.ToArray();for (int i = 0; i < buff.Length; i++){ushort svalue = 0;ushort.TryParse(buff[i].ToString(), out svalue);newDataBuffer[startIndex + i] = svalue;}int index = 0;string[] keys2 = readResult.Keys.Where(o => o.StartsWith(groupName) && o.Contains("-")).OrderBy(c => c).ToArray<string>();foreach (string key2 in keys2){string[] beginEnd = key2.Replace(String.Format("{0}.", groupName), String.Empty).Split(new char[] { '-' });if (beginEnd.Length != 2){Console.WriteLine(String.Format("标签变量[{0}]未按约定方式命名，请按[DB块号].[起始字-结束字]方式标签变量进行命名！", String.Format("{0}", key2)));return false;}int begin = 0;int end = 0;int.TryParse(beginEnd[0], out begin);int.TryParse(beginEnd[1], out end);if ((start >= begin && start <= end) || ((start + buff.Length - 1) >= begin && (start + buff.Length - 1) <= end) || (start < begin && (start + buff.Length - 1) > end)){//Console.WriteLine("---------------------------------------------------------");//Console.WriteLine("start = " + start);//Console.WriteLine("start + buff.Length - 1 = " + (start + buff.Length -1));//Console.WriteLine("begin = " + begin);//Console.WriteLine("end = " + end);//Console.WriteLine("---------------------------------------------------------");if (!this.dicTags.ContainsKey(key2)){Console.WriteLine(String.Format("写入失败：标签变量[{0}]在OpcUA Server中未定义!", String.Format("{0}", key2)));return false;}int len = (this.readResult[key2] as ushort[]).Length;ushort[] tagDataBuff = new ushort[len];//Console.WriteLine("newDataBuff");//Console.WriteLine(String.Join(",", newDataBuffer));//Console.WriteLine("index = " + index);//Console.WriteLine("tagDataBuff.Length = " + tagDataBuff.Length);//Array.Copy(newDataBuffer, begin, tagDataBuff, 0, tagDataBuff.Length);int existsMinBegin = this.GetExistsMinBeginByBlock(block.ToString());Array.Copy(newDataBuffer, begin - existsMinBegin, tagDataBuff, 0, tagDataBuff.Length);index += tagDataBuff.Length;//Console.WriteLine("Write " + key2);//Console.WriteLine(String.Join(",", tagDataBuff));//Console.WriteLine("写入标签：" + this.dicTags[key2]);result = this.myOpcHelper.WriteUInt16(this.dicTags[key2], tagDataBuff);if (!result){Console.WriteLine(String.Format("向标签变量[{0}]中写入值失败!", String.Format("{0}", key2)));return false;}else{this.ReadTag(key2);Console.WriteLine("写入...");}//Console.WriteLine("---------------------------------------------------------");} }endregionendregionreturn result;}catch (Exception ex){Console.WriteLine(this.Name + "写入失败:" + ex.Message);return false;} }}/// <summary>/// 关闭方法，断开与设备的连接释放资源/// </summary>public override void Close(){try{this._isClosing = true;System.Threading.Thread.Sleep(this.Main.ReadHz);if (this.innerReadThread != null){this.innerReadThread.Abort();this.innerReadThread = null;} }catch (Exception ex){Console.WriteLine("关闭内部读取OPCUA线程异常：" + ex.Message);}try{if (this.myOpcHelper != null){this.myOpcHelper.Close();this.myOpcHelper = null;this.State = false;this._isOpen = false;} }catch (Exception ex){Console.WriteLine("关于与OPCUA服务连接异常：" + ex.Message);} }endregionregion 辅助方法/// <summary>/// 获取某个数据块标签的最小开始索引/// </summary>/// <param name="block">块号</param>/// <returns>返回数据块标签的最小开始索引</returns>private int GetExistsMinBeginByBlock(string block){int existsMinBegin = 99999; //已存在标签的最小开始索引int existsMaxEnd = 0; //已存在标签的最大结束索引bool isContinue = true; //标签值是否连续string[] existsTags = this.readResult.Keys.ToArray<string>();string[] beginend = null;bool parseResult = false;int begin = 0;int end = 0;foreach (string tag in existsTags){if (tag.StartsWith(String.Format("{0}{1}.", groupNamePrefix, block)) && tag.Contains(".") && tag.Contains("-")){string[] tagname = tag.Split(new char[] { '.' });if (tagname.Length == 2){beginend = tagname[1].Split(new char[] { '-' });if (beginend.Length == 2){parseResult = int.TryParse(beginend[0], out begin);if (parseResult){parseResult = int.TryParse(beginend[1], out end);}region 计算最小开始索引和最大结束索引if (begin < existsMinBegin){existsMinBegin = begin;region 判断标签值是否连续if (existsMaxEnd != 0 && begin != existsMaxEnd + 1){isContinue = false;}endregion}if (end > existsMaxEnd){existsMaxEnd = end;}endregion} }if (parseResult){//} }}return existsMinBegin;}/// <summary>/// 读取标签/// </summary>/// <param name="tagName"></param>private void ReadTag(string tagName){UInt16[] buff = null;if (this.dicTags.ContainsKey(tagName)){if (this.myOpcHelper.ReadUInt16(this.dicTags[tagName], out buff)){//Console.WriteLine("tagName={0}, buff length = {1}", tagName, buff.Length);if (this.readResult.ContainsKey(tagName)){this.readResult[tagName] = buff;}else{this.readResult.Add(tagName, buff);} }else{Console.WriteLine("Mesnac.Equip.OPC.OpcUa.OPCUA.Equip.ReadTag Exception 读取标签：[{0}]失败!", tagName);} }else{Console.WriteLine("Mesnac.Equip.OPC.OpcUa.OPCUA.Equip.ReadTag Exception OPCUA Server中未定义此标签：[{0}]!", tagName);} }/// <summary>/// 内部自动读取方法/// </summary>private void InnerAutoRead(){while (this._isOpen && this._isClosing == false){try{if (this.myOpcHelper == null){this._isClosing = true;this.State = false;return;}lock (this){string[] keys = this.readResult.Keys.ToArray<string>();foreach (string key in keys){this.ReadTag(key);} }System.Threading.Thread.Sleep(this.innerReadRate);}catch (Exception ex){Console.WriteLine("Mesnac.Equip.OPC.OpcUa.OPCUA.Equip.InnerAutoRead Exception : " + ex.Message);} }this.innerReadThread = null;}endregionregion 析构方法~Equip(){this.Close();}endregion} } 代码下载 代码下载 本篇文章为转载内容。原文链接：https://blog.csdn.net/zlbdmm/article/details/96714776。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...解放双手，开发智力，使用工具，到探索宇宙，最大的进步莫过于发现自己其实仍处于囚笼之中。要怪就怪这囚笼建造地太过美好。而创建这一囚笼的“上帝”，把我们关在肉体这个囚笼里面，并且把我们的感知限制在有限的范围内，有限的嗅觉，16至20000赫兹的听觉，400纳米到700纳米的视觉，在感知中隔绝了我们对我们的唯一存在——“灵魂”的感知。 第二个问题，对于自己本身来说，表征自己存在的“灵魂”自己是可以确定的，而对于其他人，因为限制了对“灵魂”的感知，所以无法确认别人，别的生物体内这一旁观者的存在。也可以这么理解，你知道自己被关在一间囚笼里面，而不知道隔壁囚笼是否也关了一个存在。那么世界这个大监狱里面，可能只有一小部分，甚至只有你一个孤独的存在。而究竟为何我们或我被困于此，我不得而知，可能就像我们做研究的时候的小白鼠一样，“上帝”也在观察着我们或我的一举一动，这也是我这篇文章取这个题目的原因。小白鼠的逆袭，一开始我只是平凡的活着，说实在的其实做一个平凡人安安稳稳的一生还是很不错的，但是知道了这个囚笼的存在，就总想着打破它，因为在想到可能只有自己一个存在的时候，会是多么的孤独。就像一个人去看电影，哪怕电影的内容再精彩，再引人入胜，但当电影结束的时候，你才发现，原来我是一个人来的呀。 联系作者 有志向联系读者的：1612860@mail.nankai.edu.cn 未完待续。。。 本篇文章相当于《小白鼠的逆袭》的导读，下一篇我会出逆袭第一步：《思考的最简单模型及其编程实现》，可能用C++，也可能用Java，Python，看作者的心情吧。预计近几个月出吧，快则个把月，多则不知道了，毕竟作者本身还是比较忙的，忙七忙八也不知道在忙什么，嗯，就这样。 小号：在有多个游戏账号的前提下，等级高的号叫作大号，等级较低或者新创建的号叫作小号。 ↩︎ https://baijiahao.baidu.com/s?id=1586028525096880374&wfr=spider&for=pc. ↩︎ http://tieba.baidu.com/p/5127924201. ↩︎ http://tieba.baidu.com/p/5127924201. ↩︎ http://www.lwlm.com/sixiangzhexue/201704/840820.htm. ↩︎ 详细讨论请参见：《未来简史：从智人到智神》第三章：人类的特质。 ↩︎ “Unconscious determinants of free decisions in the human brain” in nature neuroscience, http://www.rifters.com/real/articles/NatureNeuroScience_Soon_et_al.pdf. ↩︎ 本篇文章为转载内容。原文链接：https://blog.csdn.net/qq_39384184/article/details/79288150。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...开源项目，所有人都在使用而没有人贡献之时，最终都会因为过度使用和投入不足而崩溃坍塌。 这种方式可以在短期内为你节省资金，但随着时间的推移，它可能会变成项目里致命的缺陷。 拿Linux来说，这个开源操作系统在全球前100万台服务器中运行率在96%以上，且这些服务器90%的云基础设施也都在Linux上。更不用说世界上85%的智能手机都运行着Linux，即Android操作系统。 这些常见开源项目的列表还在逐渐增加着。 所以没有开源，今天的大部分技术基础设施的建设也将会戛然而止。 “这是一个很现实的问题”，Data.org的执行董事Danil Mikhailov说，该组织是由万事达包容性发展中心和洛克菲勒基金会支持，旨在促进使用数据科学来应对当今社会所面临的巨大挑战的非营利性组织。 虽然几乎所有组织都在使用着开源软件，但只有少数组织为这些项目作出了贡献。The New Stack、Linux Foundation Research 和 TODO Group 在 9 月发布的一项调查中，42% 的参与者表示，他们至少有时会为开源项目做出贡献。 而同一项研究表明，只有36%的组织会培训他们的工程师为开源作出贡献。 个体公司应该支持贡献这些他们使用最多且对他们成功至关重要的项目，Mikhailov认为：“如果你使用开源，你就应该为他做出属于你自己的贡献。” Part2OSPO的好处：更少的技术负债，更好的招聘效果 参与开源社区----特别是在内部开源计划办公室（OSPO）的指导下----不仅可以保证对组织成功至关重要项目的健康发展，还可以提高项目安全性，同时可以允许工程师在项目发展规划中起到更大的作用。 例如，如果一家公司使用了开源工具，并对其进行了一些调整使其变得更好。但如果这项改进没有反馈到开源社区，那么开源项目的正式版本就会一开始与该公司所使用的版本有所不同。 “当原始数据来源发生变化且你所使用的是不同的版本时，你的技术负债将越来越多。而这些差异是以天为单位迅速增长的。”VMware 开源营销和战略总监 Suzanne Ambiel 表示，“所以你很快就会变成一个开源项目里独一无二变体的‘自豪’用户和维护人员。” “如果技术负债越来越多，那么公司的管理成本则会非常昂贵”。 实际上对于开源活动的支持也变成了一种招聘途径。“这真是一块吸引人才的磁铁，”Ambiel说，“这也是新员工所寻求的“。 她还提到，一些工程经理可能会对贡献开源而减损核心产品的开发的精力而感到担忧。她补充到，他们的理由有可能是这样的：“我只有有限的才华与时间，且我需要这些只做我认为可以处理且看到投资回报的事情。” 但她说，这是一种鼠目寸光的态度。支持开源社区并且作出贡献的员工，可以从中培养技能与增长才干。 云安全供应商 Sysdig 的首席技术官兼创始人 Loris Degionni 也赞同这一观点：“找到为开源做出贡献的员工无疑就找到一座金矿，”他说。 他认为，这些参与开源的员工更具备公司想拥有的竞争力并将一些功能融入至社区所支持的标准中。且在人才争夺战中，拥抱开源的公司也更受到开发人员的青睐。 “最后，开源项目是由你可能无法聘请的技术专家社区推动的”，他说，“当员工积极参与并于这些专家合作时，他们将能更好地深入这些顶级的实践，并将这些收获带回到你的组织之中。” “当原始数据来源发生变化且你所使用的是不同的版本时，你的技术负债将越来越多...所以你很快就会变成一个开源项目里独一无二变体的”自豪“用户和维护人员。”— Suzanne Ambiel，VMware 开源营销和战略总监 “但是这一切终究不会白费--开发人员不应该把空闲时间用在磨练他们的技能上，因为你的公司很快就会在他们的努力中看到好处。” Degionni认为，OSPO（开源计划办公室）可以帮助公司实现这些目标，以及帮助确定贡献的优先级并确保合作的进行。除此之外，他们也可以对公司内部开发应用程序方面的治理提供相关帮助。 “开源团队的成员也可以成为开源技术的伟大内部传播者，并充当组织与更广泛社区之间的桥梁。”他补充道。 在 The New Stack、Linux Foundation Research 和 TODO Group 的 9 月调查中，近 53% 的拥有 OSPO的组织表示，由于拥有了OSPO，他们看到了更多创新，而近 43% 的组织表示，他们在外部开源项目的参与度上有所增加。 Part3更多OSPO的好处：商业优势 网络安全公司 ThreatX 的首席创新官 Tom Hickman 表示，为开源社区做出贡献，不仅有助于社区，还有助于为社区做出贡献的公司。 “围绕一个项目而发展的开发人员社区，有助于代码库的形成，并吸引更多的开发人员参与”，他说，“这可以变成一个良性循环。” 此外，根据哈佛商学院的研究，为开源项目作出贡献的公司从使用开源的项目中获得的生产价值，是不参与开源项目公司的两倍。 Cloud Native Computing Foundation 的首席技术官 Chris Aniszczyk 说，世界上许多巨头公司都为开源作出了贡献。他还提到，开源贡献者的指数是作为公司是否有所作为的参考。 科技巨头占据了这份榜单的主导地位：谷歌、微软、红帽、英特尔、IBM、亚马逊、Facebook、VMware、GitHub 和 SAP 依次是排名前 10 的贡献者。但Aniszczyk 表示，但也有很多终端用户公司进入前 100 名，包括 Uber、BBC、Orange、Netflix 和 Square。 “我们一直知道，在上游项目中工作不仅仅是关正确与否----它是开源软件开发的最佳方法，也是向客户提供开源福利的最佳方式”他说，“很高兴看到IT领导者们也认识到了这一点。” 为了和这些公司一起作出贡献，公司也需要有自己的开源策略，而拥有一个开源计划办公室则可以为其提供帮助。 “在使用开源软件方面，OPSO为公司提供了一个至关重要的能力中心”他说。 这与公司拥有安全运营中心的方式类似，他说。 “围绕一个项目而发展的开发人员社区，有助于代码库的形成，并吸引更多的开发人员参与，这可以变成一个良性循环。” ——Tom Hickman，ThreatX 首席创新官 “如果你对安全团队进行相应投资，你通常是不会期望你的软件是安全的，也无法及时应对安全事件。”他说。 “同样的逻辑也适用于 OSPO，这就是为什么你会看到许多领先的公司，例如Apple、Meta、Twitter、Goldman Sachs、Bloomberg 和 Google 都拥有 OSPO。他们走在了趋势的前面。” 而对组织内的开源活动的支持态度亦可成为软件供应商们的差异化原因与营销的机会。 根据Red Hat 2月分发布的一项调查，82%的IT领导者更倾向于选择为开源社区作出贡献的软件供应商。 受访者表示，当供应商支持开源社区时，就表示着他们更熟悉开源的流程并且在客户遇到技术难题时会更加有效。 但收益的不仅仅是软件供应商们。 根据 The New Stack、Linux Foundation Research 和 TODO Group 9 月份的调查，57% 拥有 OSPO 的组织将使用它们来进一步发展战略关系和建立合作伙伴关系。 十年前，Mark Hinkle 在 Citrix 工作时创办了一个开源计划办公室。他指出了在内部拥有一个 OSPO将如何使公司受益。 “对于我们来说，最大的工作是让不熟悉开源的员工学会并参与其中，成为优秀的社区成员”，他说，“我们还就如何确保我们的IP不会在没有正确理解的情况下进入项目的情况提供了指导，并确保我们没有与我们企业软件许可相冲突的开源项目合作。” 他说，OSPO还帮助Citrix确定了公司参与开源项目和Linux基金会等贸易组织的战略机会。 如今，他是云原生开源集成平台 TriggerMesh 的首席执行官兼联合创始人。 他说，参与开源系统对公司来说有着重大的经济效益。 “我们参与Knative是为了分享我们基础底层平台的开发，但作为业务的一部分，我们也拥有相关的增值服务。”他说，“通过共享该平台的研发，这为我们提供了更多的资源来改进我们自己的差异化技术。” Part4如何入门开源 在 The New Stack、Linux Foundation Research 和 TODO Group 的 9 月份调查中，有 63% 的公司表示，拥有OSPO 对其工程或产品团队的成功至关重要，高于上一年度该项研究数据的 54%。 其中77% 的人表示他们的开源程序对他们的软件实践产生了积极影响，例如提高了代码质量。 但公司也不可能总是为他们使用的每一个开源项目而花费精力。 “首先，节流一下”，VMware 的 Ambiel 建议道。 公司应该关注投入使用中最有意义的项目。而这也是OSPO可以帮助确定优先事项并确保技术与战略一致性的领域。 之后，开发人员应该自己去了解一下。项目通常提供相关在线文档，一般包含贡献着指南、治理文档和未解决问题列表。 “对于那些你较感兴趣的项目中，你可以介绍一下自己----打个招呼”，她说。“然后转到Slack频道或者分发列表，询问他们需要帮助的地方。也许他们不需要帮助，一切完好；又或者他们也有可能使用新人来审查核验代码。” Ambiel 说，开源计划办公室不仅可以帮助制定为开源社区做出贡献的商业案例，还可以帮助公司以安全、可靠和健全的方式来做这件事。 “如果我为一家公司工作，并想为开源做出贡献，我不想意外披露、泄露或破坏任何专利，”她说。“而OSPO可以帮助您做出明智的选择。” 她说，OSPO还可以在开源方面提供领导力和指导理念的支持。“它可以提供引领、指导、辅导和最佳实践的作用。” Aqua Security的开发人员倡导者Anaïs Urlichs则认为，支持开源的承诺必须从高层开始。 她说，“公司在多数时候往往不重视对开源的投资，所以员工自然而然不被鼓励对此作出贡献。” 在这些情况下，员工对于开源的热情也会在空闲时间里对开源的建设而消散殆尽，这对于开源的发展来说是不可持续的。 “如果公司对开源项目依赖度高，那么将开源贡献纳入工程师的日程安排是很重要的，”她说。“一些公司定义了员工可以为开源建设的时间百分比，将其作为他们正常工作日的一部分。” The New Stack 是 Insight Partners 的全资子公司，Insight Partners 是本文提到的以下公司的投资者：Sysdig、Aqua Security。 中英对照版 How an OSPO Can Help Your Engineers Give Back to Open Source OSPO （开源项目办公室）是如何使工程师回馈开源的 When it comes to open source software, there’s a big and growing problem: most organizations are takers, not givers. 谈到开源软件，有一个较大且日益严重的问题：大多数组织都是索取者，而不是给予者。 There’s a classic XKCD comic that shows a giant structure representing modern digital infrastructure, dependent on a tiny component created by “some random person in Nebraska” who has been “thanklessly maintaining since 2003.” 经典漫画XKCD展示了一个代表现代数字基础设施的巨大结构，它依赖于“内布拉斯加州的某位人士”创建的微小组件，该组件“自2003年来一直都处于吃力不讨好的状态”。 Randall Monroe’s XKCD comic illustrates the open source dilemma: overreliance on a small number of volunteer project maintainers. Randall Monroe 的XKCD漫画展示了目前开源面临的窘境：过度依赖少数项目维护志愿者的志愿服务。 This would have been funny, except that this is exactly what happened when security vulnerabilities were discovered in Log4j last December. （开源项目由志愿者自发来维护，）这听起来像是一件很滑稽的事情，但事实上去年十二月在Log4j中发现的安全漏洞也确实存在着上述情况。 The Java-based logging tool is ubiquitous in enterprise publications. In the last three months, for example, Log4j has been downloaded more than 30 million times, according to a report by the enterprise software company Sonatype. 然而这个基于Java的日志记录工具已经在企业内部刊物中无处不在。例如根据软件公司Sonatype的一份报告显示，在过去的三个月里，Log4j的下载量就已经超过3000万次。 The tool has 440,000 lines of code, according to Synopsys‘ Black Duck Open Hub research tool, with nearly 24,000 contributions by nearly 200 developers. That’s a large dev team compared to other open source projects. But looking closer at the numbers, more than 70% of commits were by just five people. 根据Synopsys(新思）公司旗下的Black Duck Open Hub 研究工具显示。Log4j有着440,000行代码，由近200名开发人员贡献了将近24,000行代码。其实与其他开源项目相比，这是一个庞大的开发团队。但是如果关注数据的话，就会发现超过70%的提交是仅仅靠五个人来完成的。 Log4j’s home page lists about a dozen members on its project team. Most projects have far fewer developers working on them — and that presents a problem for the organizations that depend on them. Log4j的主页上展示了十几位项目团队的成员。而大多项目的开发人员要比其原本需要的少得多----这是高度依赖开发人员团队所呈现出来的问题。 “There is little incentive for anyone today to contribute to an existing open source project,” said Jeremy Stretch, distinguished engineer at NS1, a DNS network company. “There’s usually no direct compensation, and few accolades are offered — most users don’t even know who maintains the software that they use.” “如今的人没有什么动力去为现有的开源项目做贡献”，来自DNS网络公司NS1的杰出工程师Jeremy Strech说，“因为通常来说，这没有直接的物质回报，也很少提供荣誉----大多数用户甚至不知道他们所用的软件是谁维护的。” The most common motivation among open source contributors is to add a feature that they themselves want to see, he said. “Once this has been achieved, the contributor rarely sticks around.” 他说，开源贡献者们最常见的动机就是添加他们自己想要的功能。“一旦实现了这一点，他们几乎都不会留下来。” Meanwhile, as a project becomes more popular, the burden on the core team of maintainers keeps increasing. 与此同时，随着项目的逐渐流行，对于维护方面的核心团队来说，他们的负担也在不断增加。 “More users means more feature requests and more bug reports — but not more maintainers,” Stretch said. “What was once an enjoyable hobby can quickly become a tedious chore, and many maintainers understandably opt to simply abandon their projects altogether.” “更多的用户意味有着更多的功能需求和错误报告----但不是更多的维护人员”，Stretch说。“曾经令人愉快的爱好很快就会变成一项乏味的项目，所以很多维护人员选择干脆完全放弃他们的项目，这也是可以理解的。” Part1The Tragedy of the Commons The open source software ecosystem is a perfect example of the “tragedy of the commons.” 开源软件的生态系统，就是“公地悲剧”的一个完美例子。 And the tragedy is — when everyone uses, but no one contributes, that resource — whether it’s an overrun park or an open source project — eventually collapses from overuse and underinvestment. Everyone loves using free stuff, but everyone expects someone else to take care of it. 这个悲剧就是---当一种资源，无论是一个超限的公园还是一个开源项目，所有人都在使用而没有人贡献之时，最终都会因为过度使用和投入不足而崩溃坍塌。 This approach can save you money in the short term, but it can become a fatal flaw over time. Especially since open source software is everywhere, running everything. 这种方式可以在短期内为你节省资金，但随着时间的推移，它可能会变成项目里致命的缺陷。 Linux, for example, the open source operating system, runs on 96% of the world’s top 1 million servers, and 90% of all cloud infrastructure is on Linux. Not to mention that 85% of all smartphones in the world run Linux, in the form of the Android OS. 拿Linux来说，这个开源操作系统在全球前100万台服务器中运行率在96%以上，且这些服务器90%的云基础设施也都在Linux上。更不用说世界上85%的智能手机都运行着Linux，即Android操作系统。 Then there’s Java, Apache, WordPress, Cassandra, Hadoop, MySQL, PHP, ElasticSearch, Kubernetes — the list of ubiquitous open source projects goes on and on. 还有Java, Apache, WordPress, Cassandra, Hadoop, MySQL, PHP, ElasticSearch, Kubernetes--这些常见开源项目的列表还在逐渐增加着。 Without open source, much of today’s technical infrastructure would immediately grind to a halt. 如果没有开源，今天的大部分技术基础设施的建设也将会戛然而止。 “It is a real problem,” said Danil Mikhailov, executive director at Data.org, a nonprofit backed by the Mastercard Center for Inclusive Growth and The Rockefeller Foundation that promotes the use of data science to tackle society’s greatest challenges. “这是一个很现实的问题”，Data.org的执行董事Danil Mikhailov说，该组织是由万事达包容性发展中心和洛克菲勒基金会支持，旨在促进使用数据科学来应对当今社会所面临的巨大挑战的非营利性组织。 While nearly all organizations use open source software, only a minority contribute to those projects. Forty-two percent of participants in a survey released in September by The New Stack, Linux Foundation Research, and the TODO Group said tthey contribute at least sometimes to open source projects. 虽然几乎所有组织都在使用着开源软件，但只有少数组织为这些项目作出了贡献。The New Stack、Linux Foundation Research 和 TODO Group 在 9 月发布的一项调查中，42% 的参与者表示，他们至少有时会为开源项目做出贡献。 The same study showed that only 36% of organizations train their engineers to contribute to open source. 而同一项研究表明，只有36%的组织会培训他们的工程师为开源作出贡献。 Individual companies should support projects that they use the most and are critical to their success, Mikhailov said: “If you use, you contribute.” 个体公司应该支持贡献这些他们使用最多且对他们成功至关重要的项目，Mikhailov认为：“如果你使用开源，你就应该为他做出属于你自己的贡献。” Part2OSPO Benefits:Less Tech Debt,Better Recruiting Participating in open source communities — especially when guided by an in-house open source program office (OSPO) — can help ensure the health of projects critical to your organization’s success, improve those projects’ security, and allow your engineers to have more impact in the projects’ development road map. 参与开源社区——特别是在内部开源项目办公室（OSPO）的指导下——不仅可以保证对组织成功至关重要项目的健康发展，还可以提高项目安全性，同时可以允许工程师在项目发展规划中起到更大的影响。 Say, for example, a company uses an open source tool and modifies it a little to make it better. If that improvement isn’t contributed back to the community, then the official version of the open source project will start to diverge from what the company is using 例如，如果一家公司使用了开源工具，并对其进行了一些调整使其变得更好。但如果这项改进没有反馈到开源社区，那么开源项目的正式版本就会一开始与该公司所使用的版本有所不同。 “You start to grow technical debt because when the original source changes and you’ve got a different version. Those differences grow rapidly, compounding daily. It doesn’t take long for you to be the proud user and maintainer of a one-of-a-kind open source project variant,” said Suzanne Ambiel, director, open source marketing and strategy at VMware. “当原始代码来源发生变化且你所使用的是不同的版本时，你的技术负债将越来越多。而这些差异是以天为单位迅速增长的。”VMware 开源营销和战略总监 Suzanne Ambiel 表示，“所以你很快就会变成一个开源项目里独一无二变体的‘自豪’用户和维护人员。” “The technical debt gets bigger and bigger and it gets very expensive for a company to manage.” “如果技术负债越来越多，那么公司的管理成本则会非常昂贵”。 Support for open source activity can also be a recruiting tool. “It’s really a talent magnet,” said Ambiel. “It’s one of the things that new hires look for.” 实际上对于开源活动的支持也变成了一种招聘途径。“这真是一块吸引人才的磁铁，”Ambiel说，“这也是新员工所寻求的“。 Some engineering managers might worry that open source contributions will detract from core product development, she said. Their rationale, she added, might run along the lines of, “I only have so much talent, and so many hours, and I need them to only work on things where I can measure and see the return on investment.” 她还提到，一些工程经理可能会对贡献开源而减损核心产品的开发的精力而感到担忧。她补充到，他们的理由有可能是这样的：“我只有有限的才华与时间，且我需要这些只做我认为可以度量且看到投资回报的事情。” But that attitude, she said, is shortsighted. Supporting employees who contribute to open source communities can build skills and develop talent, she said. 但她说，这是一种鼠目寸光的态度。支持开源社区并且作出贡献的员工，可以从中培养技能与增长才华。 Loris Degionni, chief technology officer and founder at Sysdig, a cloud security vendor, echoed this notion: “Finding employees who contribute to open source is a gold mine,” said. 云安全供应商 Sysdig 的首席技术官兼创始人 Loris Degionni 也赞同这一观点：“找出为开源做出贡献的员工无疑就找到一座金矿，”他说。 These employees are more capable of delivering features a company wants to use and merge them into community-supported standards, he said. And in a war for talent, companies that embrace open source are more attractive to developers. 他认为，这些参与开源的员工更具备公司想拥有的竞争力并将一些功能融入至社区所支持的标准中。且在人才争夺战中，拥抱开源的公司也更受到开发人员的青睐。 “Lastly, open source is driven by a community of technical experts you may not be able to hire,” he said. “When employees actively contribute and collaborate with these experts, they’ll be better informed of best practices and bring them back to your organization. “最后，开源项目是由你可能无法聘请的技术专家社区推动的”，他说，“当员工积极参与并于这些专家合作时，他们将能更好地深入这些最佳实践，并将这些收获带回到你的组织之中。” “You start to grow technical debt because when the original source changes and you’ve got a different version … It doesn’t take long for you to be the proud user and maintainer of a one-of-a-kind open source project variant.” —Suzanne Ambiel, director, open source marketing and strategy, VMware “当原始数据来源发生变化且你所使用的是不同的版本时，你的技术负债将越来越多...所以你很快就会变成一个开源项目里独一无二变体的”自豪“用户和维护人员。” — Suzanne Ambiel，VMware 开源营销和战略总监 “All of this should be rewarded — developers shouldn’t have to spend their free time honing their skills, as your company will quickly see benefits from their efforts.” “但是这一切终究不会白费--开发人员不应该把业余时间用在磨练他们的技能上，因为你的公司很快就会在他们的努力中看到好处。” An OSPO, Degionni suggested, can help achieve these goals, as well as help prioritize contributions and ensure collaboration. In addition, they can help provide governance that mirrors what companies would have for internally developed applications. Degionni认为，OSPO（开源计划办公室）可以帮助公司实现这些目标，以及帮助确定贡献的优先级并确保合作的进行。除此之外，他们也可以对公司内部开发应用程序方面的治理提供相关帮助。 “Members of the open source team are also in a position to be great internal evangelists for open source technologies, and act as bridges between the organization and the broader community,” he added. “开源团队的成员也可以成为开源技术的伟大内部布道师，并充当组织与更广泛社区之间的桥梁。”他补充道。 In the September survey from The New Stack, Linux Foundation Research and the TODO Group, nearly 53% of organizations with OSPOs said they saw more innovation as a result of having an OSPO, while almost 43% said they saw increased participation in external open source projects. 在 The New Stack、Linux Foundation Research 和 TODO Group 的 9 月调查中，近 53% 的拥有 OSPO的组织表示，由于拥有了OSPO，他们看到了更多创新，而近 43% 的组织表示，他们在外部开源项目的参与度上有所增加。 Part3More OSPO Benefits:A Business Edge Contributing to open source communities doesn’t just help the communities, but the companies that contribute to them, said Tom Hickman, chief innovation officer at ThreatX, a cybersecurity firm. 网络安全公司 ThreatX 的首席创新官 Tom Hickman 表示，为开源社区做出贡献，不仅有助于社区，还有助于为社区做出贡献的公司。 “Growing the community of developers around a project helps the code base, and attracts more developers,” he said. “It can become a virtuous circle.” “围绕一个项目而发展的开发人员社区，有助于代码库的形成，并吸引更多的开发人员参与”，他说，“这可以变成一个良性循环。” Also, companies that contribute to open source projects get twice the productive value from their use of open source than companies that don’t, according to research by Harvard Business School. 此外，根据哈佛商学院的研究，为开源项目作出贡献的公司从使用开源的项目中获得的生产价值，是不参与开源项目公司的两倍。 Many of the biggest companies in the world are contributing to open source, said Chris Aniszczyk, chief technology officer at Cloud Native Computing Foundation. He pointed to the Open Source Contributor Index as a reference for exactly just how much companies are doing. Cloud Native Computing Foundation 的首席技术官 Chris Aniszczyk 说，世界上许多巨头公司都为开源作出了贡献。他还提到，开源贡献者的指数是作为公司是否有所作为的参考。 The tech giants dominate the list: Google, Microsoft, Red Hat, Intel, IBM, Amazon, Facebook, VMware, GitHub and SAP are the top 10 contributors, in that order. But there are also a lot of end users on the top 100 list, said Aniszczyk, including Uber, the BBC, Orange, Netflix, and Square. 科技巨头占据了这份榜单的主导地位：谷歌、微软、红帽、英特尔、IBM、亚马逊、Facebook、VMware、GitHub 和 SAP 依次是排名前 10 的贡献者。但Aniszczyk 表示，但也有很多终端用户公司进入前 100 名，包括 Uber、BBC、Orange、Netflix 和 Square。 “We’ve always known working in upstream projects is not just the right thing to do —it’s the best approach to open source software development and the best way to deliver open source benefits to our customers,” he said. “It’s great to see that IT leaders recognize this as well.” “我们一直知道，在上游项目中工作不仅仅是关正确与否----它是开源软件开发的最佳方法，也是向客户提供开源福利的最佳方式“他说，“很高兴看到IT领导者们也认识到了这一点。” To contribute alongside these giants, companies need to have their own open source strategies, and having an open source program office can help. 为了和这些公司一起作出贡献，公司也需要有自己的开源策略，而拥有一个开源项目办公室则可以为其提供帮助。 “OSPOs provide a critical center of competency in a company when it comes to utilizing open source software,” he said. “在使用开源软件方面，OPSO为公司提供了一个至关重要的能力中心”他说。 It’s similar to the way that companies have security operations centers, he said. 这与公司拥有安全运营中心的方式类似，他说。 “Growing the community of developers around a project helps the code base, and attracts more developers. It can become a virtuous circle.” —Tom Hickman, chief innovation officer, ThreatX “围绕一个项目而发展的开发人员社区，有助于代码库的形成，并吸引更多的开发人员参与，这可以变成一个良性循环。” ——Tom Hickman，ThreatX 首席创新官 “If you don’t make the investment in a security team, you generally don’t expect your software to be secure or be able to respond to security incidents in a timely fashion,” he said. “如果你没有对安全团队进行相应投资，你通常是不会期望你的软件是安全的，也无法及时响应安全事件。”他说。 “The same logic applies to OSPOs and is why you see many leading companies out there such as Apple, Meta, Twitter, Goldman Sachs, Bloomberg, and Google all have OSPOs. They are ahead of the curve.” “同样的逻辑也适用于 OSPO，这就是为什么你会看到许多领先的公司，例如 Apple、Meta、Twitter、Goldman Sachs、Bloomberg 和 Google 都拥有 OSPO。他们走在了趋势的前面。” Support for open source activity within your organization can become a differentiator and marketing opportunity for software vendors. 而对组织内的开源活动的支持态度亦可成为软件供应商们的差异化原因与营销的机会。 According to a Red Hat survey released in February, 82% of IT leaders are more likely to select a vendor who contributes to the open source community. 根据Red Hat2月分发布的一项调查，82%的IT领导者更倾向于选择为开源社区作出贡献的软件供应商。 Respondents said that when vendors support open source communities they are more familiar with open source processes and are more effective if customers have technical challenges. 受访者表示，当供应商支持开源社区时，就表示着他们更熟悉开源的流程并且在客户遇到技术难题时会更加有效。 But it’s not just software vendors who benefit. 但收益的不仅仅是软件供应商们。 According to September’s survey by The New Stack, Linux Foundation Research, and the TODO Group, 57% of organizations with OSPOs use them to further strategic relationships and build partnerships. 根据 The New Stack、Linux Foundation Research 和 TODO Group 9 月份的调查，57% 拥有 OSPO 的组织将使用它们来进一步发展战略关系和建立合作伙伴关系。 Mark Hinkle started an open source program office back when he worked at Citrix a decade ago. He pointed out how having an OSPO in-house benefited the company. 十年前，Mark Hinkle 在 Citrix 工作时创办了一个开源计划办公室。他指出了在内部拥有一个 OSPO将如何使公司受益。 “For us the biggest job was to educate our employees who weren’t familiar with open source to get involved and be good community members,” he said. “We also provided guidance on how to make sure our IP didn’t enter projects without proper understanding and we made sure we didn’t incorporate open source that conflicted with our enterprise software licensing.” “对于我们来说，最大的工作是让不熟悉开源的员工学会并参与其中，成为优秀的社区成员”，他说，“我们还就如何确保我们的IP不会在没有正确理解的情况下进入项目的情况提供了指导，并确保我们没有与我们企业软件许可相冲突的开源项目合作。” The OSPO also helped Citrix identify strategic opportunities for the company to participate in open source projects and trade organizations like The Linux Foundation, he said. 他说，OSPO还帮助Citrix确定了公司参与开源项目和Linux基金会等贸易组织的战略机会。 Today, he’s the CEO and co-founder of TriggerMesh, a cloud native, open source integration platform. 如今，他是云原生开源集成平台 TriggerMesh 的首席执行官兼联合创始人。 There are some significant economic benefits to participating in the open source ecosystem, he said. 他说，参与开源系统对公司来说有着重大的经济效益。 “We participate in Knative to share the development of our underlying platform but we develop value-added services as part of our business,” he said. “By sharing the R and D for the platform, it gives us more resources to develop our own differentiated technology.” “我们参与Knative是为了分享我们基础底层平台的开发，但作为业务的一部分，我们也拥有相关的增值服务。”他说，“通过共享该平台的研发，这为我们提供了更多的资源来改进我们自己的差异化技术。” Part4How to Get Started in Open Source Sixty-three percent of companies in the September survey from The New Stack, Linux Foundation Research and the TODO Group said that having an OSPO was very or extremely critical to the success of their engineering or product teams, up from 54% in the previous annual study. 在 The New Stack、Linux Foundation Research 和 TODO Group 的 9 月份调查中，有 63% 的公司表示，拥有OSPO 对其工程或产品团队的成功至关重要，高于上一年度该项研究数据的 54%。 In particular, 77% said that their open source program had a positive impact on their software practices, such as improved code quality. 其中77% 的人表示他们的开源程序对他们的软件实践产生了积极影响，例如提高了代码质量。 But companies can’t always contribute to every single open source project that they use. 但公司也不可能总是为他们使用的每一个开源项目而花费精力。 “First, thin the herd a little bit,” advised VMware’s Ambiel. “首先，节流一下”，VMware 的 Ambiel 建议道。 Companies should look at the projects that make the most sense for their use cases. This is an area where an OSPO can help set priorities and ensure technical and strategic alignment. 公司应该关注投入使用中最有意义的项目。而这也是OSPO可以帮助确定优先事项并确保技术与战略一致性的领域。 Then, developers should go and check out the projects themselves. Projects typically offer online documentation, often with contributor guides, governance documents, and lists of open issues. 之后，开发人员应该自己去了解一下。项目通常提供相关在线文档，一般包含贡献着指南、治理文档和未解决问题列表。 “For the projects that rise to the top of your strategic list, introduce yourself — say hello,” she said. “Go to the Slack channel or the distribution list and ask where they need help. Maybe they don’t need help and everything is good. Or maybe they can use a new person to review code.” “对于那些上升到你的战略清单顶端的项目，你可以介绍一下自己----打个招呼”，她说。“然后转到Slack频道或者分发列表，询问他们需要帮助的地方。也许他们不需要帮助，一切完好；又或者他们也有可能使用新人来审查核验代码。” An open source program office can not only help make a business case for contributing to the open source community, Ambiel said, but can help companies do it in a way that’s safe, secure and sound. Ambiel 说，开源项目办公室不仅可以帮助制定为开源社区做出贡献的商业案例，还可以帮助公司以安全、可靠和健全的方式来做这件事。 “If I work for a company and want to contribute to open source, I don’t want to accidentally disclose, divulge or undermine any patents,” she said. “An OSPO helps you make smart choices.” “如果我为一家公司工作，并想为开源做出贡献，我不想意外披露、泄露或破坏任何专利，”她说。“而OSPO可以帮助您做出明智的选择。” An OSPO can also help provide leadership and the guiding philosophy about supporting open source, she said. “It can provide guidance, mentorship, coaching and best practices.” 她说，OSPO还可以在开源方面提供领导力和指导理念的支持。“它可以提供引领、指导、辅导和最佳实践的作用。” Commitment to support open source has to start at the top, said Anaïs Urlichs, developer advocate at Aqua Security. Aqua Security的开发人员倡导者Anaïs Urlichs则认为，支持开源的承诺必须从高层开始。 “Too often,” she said, “companies do not value investment into open source, so employees are not encouraged to contribute to it.” 她说，“公司在多数时候往往不重视对开源的投资，所以员工自然而然不被鼓励对此作出贡献。” In those cases, employees with a passion for open source end up contributing during their free time, which is not sustainable. 在这些情况下，员工对于开源的热情也会在空闲时间里对开源的建设而消散殆尽，这对于开源的发展来说是不可持续的。 “If companies rely on open source projects, it is important to make open source contributions part of an engineer’s work schedule,” she said. “Some companies define a time percentage that employees can contribute to open source as part of their normal workday.” “如果公司对开源项目依赖度高，那么将开源贡献纳入工程师的日程安排是很重要的，”她说。“一些公司定义了员工可以为开源建设的时间百分比，将其作为他们正常工作日的一部分。” The New Stack is a wholly owned subsidiary of Insight Partners, an investor in the following companies mentioned in this article: Sysdig, Aqua Security. The New Stack 是 Insight Partners 的全资子公司，Insight Partners 是本文提到的以下公司的投资者：Sysdig、Aqua Security。 相关阅读 | Related Reading 《开源合规指南（企业篇）》正式发布，为推动我国开源合规建设提供参考 “目标->用户->指标”——企业开源运营之道｜瞰道@谭中意 开源之夏邀请函——仅限高校学子开启 开源社简介 开源社成立于 2014 年，是由志愿贡献于开源事业的个人成员，依 “贡献、共识、共治” 原则所组成，始终维持厂商中立、公益、非营利的特点，是最早以 “开源治理、国际接轨、社区发展、开源项目” 为使命的开源社区联合体。开源社积极与支持开源的社区、企业以及政府相关单位紧密合作，以 “立足中国、贡献全球” 为愿景，旨在共创健康可持续发展的开源生态，推动中国开源社区成为全球开源体系的积极参与及贡献者。 2017 年，开源社转型为完全由个人成员组成，参照 ASF 等国际顶级开源基金会的治理模式运作。近八年来，链接了数万名开源人，集聚了上千名社区成员及志愿者、海内外数百位讲师，合作了近百家赞助、媒体、社区伙伴。 本篇文章为转载内容。原文链接：https://blog.csdn.net/kaiyuanshe/article/details/124976824。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。