nod

nodoubt的意思是：adv.无疑地；很可能地。nodoubt的意思是：adv.无疑地；很可能地。nodoubt的例句是Nodoubtherdeathisrelatedtopolitics.她的死无疑和政治有关。nodoubt的读音是英[n__da_t]；美[no_da_t]。一、参考翻译点此查看nodoubt的详细内容无疑,确实二、网络解释1.不要_疑合唱_：不过麦莉(MileyCyrus)已经拥有许多成年人难以望其项背的成重新振作回到巅峰,玛丽亚凯莉(MariahCarey)无论在私生活或是音乐事到他离开白宫之前,不要怀疑合唱团(NoDoubt)发了一张专辑-「摇滚万万奴比狗狗(SnoopDogg)这礼拜上遍了美国各大电视节目打歌,2.2.无疑地：nextto紧接着,相邻,次于|nodoubt无疑地|nolonger不再三、例句Nodoubtherdeathisrelatedtopolitics.她的死无疑和政治有关。Nodoubtthechairmanwillwantonelastchange.无疑地主席意志需要一最后的变化。Nodoubtshe"llcalluswhenshegetsthere.她到达那儿时必定会给我们打电话。Shehadnorenownedancestorsandthoughtpeoplewhohadweresnobs.她没有显赫的祖先，于是以为有的人必定势利。四、词汇搭配makenodoubt毫不怀疑(确信)...nodoubt的相关近义词withoutdoubt、tobesurenodoubt的相关临近词no、Noerr点此查看更多关于nodoubt的详细信息

固定用法是：There is no doubt that毫无疑问

webstorm中新建项目后比如：node.js项目 项目路径中有bin目录，目录中有个www的文件。可以debug或者run这个文件，代表启动应用。 如下图：

在webStorm中调试node.js程序，不使用命令行形式、不使用node-inspector模块调试，纯粹使用webStorm调试可能是你的环境的问题。 webstorm那个版本的都可以集成调试。 注意启动程序的时候使用debug 模式次可以调试。

诺顿防毒软件的英文名称是Norton Antivirus NOD32是ESET公司的防毒产品，与诺顿完全是两回事。

Iur用于呼叫切换的RNC到RNC连接，通常通过OC-3链路实现。lu-csRNC与电路交换语音网络之间的核心网接口。通常作为OC-12速率链路实施。lu-psRNC与分组交换数据网络之间的核心网接口。通常作为OC-12速率链路实施。

1、OML：Operation and Maintenance Link 操作维护链路；2、2G网络中，在基站和NodeB之间的接口成为Abis口。该接口是一个私有接口，在不同的厂家间是不公开的Abis接口中包含了3中链路：（1）、OML操作维护链路，是用来传递基站的控制命令的，通常后台所作的修改就是通过此链路发给基站；（2）、Sig信令链路，用于传递BSC与BTS之间的带外信令（3）、Trf业务链路，用于传递业务。通常开通基站时，首先要检查的就是OML，如果OML不同，那么是没有办法对基站进行任何操作的。3、一旦OML链路中断，那么基站会失去控制，也就是说后台的BAM上或者，网管上就无法对该基站进行任何额操作或者管理；4、一般出现OML中断的原因有：（1）传输链路断，导致OML链路断；（2）基站接口板出现问题；（3）基站或者NodeB上的数据配置错误。

1、进入thrift.exe所在目录执行thrift-0.9.2.exe –gen js:node hello.thrift编译hello.thrift生成nodejs的实现文件。2、在cmd窗口进入生成的gen-nodejs目录，使用npm install thrift安装nodejs的thrift模块，安装完多了一个node_modules目录。3、新建一个js文件作为thrift的客户端。内容如下：//引入thrift模块var thrift = require("thrift");//引入hello服务定义文件在同一路径下也要加 ./var Hello = require("./Hello.js"),ttypes = require("./hello_types");//创建连接和客户端var connection = thrift.createConnection("localhost", 19090),client = thrift.createClient(Hello, connection);//连接connection.on("error", function(err) {console.error(err);});//调用helloString函数console.log(client.helloString("tomdog").toString());4、启动上一篇文章中Java server程序，用node指令运行nodejsclient.js,看到控制台输出：[object Promise]。在这里js把Java返回的string当成object。

　　1. 首先，要确认在安装Weblogic Server的过程中，勾选NodeManager选项，如下图，默认是不选中的，为了后期能简单的使用节点管理器，这里需要选择Yes，然后完成软件安装。　　2. 其次，创建Domain的过程参考：　　a) 选择创建Domain的类型　　　　b) 确认创建Domain的类型　　a) 确认集群名称　　　　b) 确认管理员用户名、口令　　　　c) 选择Domain的模式　　　　d) 选择修改Domain选项Yes，选择不配置DBMS　　　　e) 确认主管服务器的IP地址、端口、名称　　　　f) 确认受管服务器的IP地址、端口、名称　　　　g) 确认集群的地址、端口、名称　　　　h) 确认集群中有哪些受管服务　　　　i) 确认代理服务器的配置　　　　j) 确认物理服务器的信息（以Linux服务器为例）　　　　k) 确认哪些服务器运行在哪些物理机器上　　　　l) 确认集群Domain创建设置　　　　m) 完成集群创建　　　　3. 配置weblogic访问口令脚本　　要确认在启动Domain的Server时，不需要输入用户名、口令，方法(Linux平台，Windows平台参考修改setDomainEnv.cmd)如下：　　a) 第一步，按11g版本前的方法，在自己的${DOMAIN_HOME}文件夹下，创建boot.properties文件，内容为：　　username=weblogic　　password=welcome1　　b) 第二步，修改${DOMAIN_HOME}/bin文件夹下的setDomainEnv.sh，找到【# SET THE CLASSPATH】这行，修改其上面两行内容：　　从：　　JAVA_OPTIONS="${JAVA_OPTIONS}"export JAVA_OPTIONS　　修改为：　　JAVA_OPTIONS="${JAVA_OPTIONS} -Dweblogic.system.BootIdentityFile=${DOMAIN_HOME}/boot.properties"export JAVA_OPTIONS　　4. 配置主机名与IP映射关系　　要确认主机名与IP地址有对应关系，修改主机的hosts文件，加入　　192.168.182.12 oradb2　　这里，如果发现127.0.0.1对应到了oradb2这个主机名，应将其对应去掉，只需要127.0.0.1映射到localhost即可。　　　　5. 如何用NodeManager管理集群服务器　　为了能让nodemanager可以管理weblogic的domain，必须先启动nodemanager进程，方法为：　　cd /home/weblogic/bea/wlserver_10.3/server/bin　　./startNodeManager.sh　　接下来，可以启动AdminServer，方法为：　　cd /home/weblogic/bea/user_projects/domains/my_domain/bin　　./startWebLogic.sh　　接下来的服务都可以在weblogic的console中进行启动了，登录访问控制台页面：http://192.168.182.12:7001/console　　　　点击服务器，打开服务器管理页面：　　　　点击【控制】标签页，要管理哪个服务器，就勾选哪个，比如勾选MS_1，点击【启动】，就可以完成MS_1这个服务器：　　　　点击【是】按钮：　　　　这时【MS_1】，状态已经为STARTING　　　　等待一段时间后：　　　　最终MS_1就正常运行了，状态RUNNING

option主要为一些密码加密选项-c, --crypt-methodUse the specified method to encrypt the passwords.The available methods are DES, MD5, NONE, and SHA256 or SHA512 if your libc support these methods.-e, --encryptedSupplied passwords are in encrypted form.-h, --helpDisplay help message and exit.-m, --md5Use MD5 encryption instead of DES when the supplied passwords are not encrypted.-s, --sha-roundsUse the specified number of rounds to encrypt the passwords.The value 0 means that the system will choos输入命令后，按 username:password 格式输入用户名密码，一行一个，如：chpasswdnewghost:4567用这种方法可在node.js中使用：var cp = require("child_process")//更新密码var chpasswd = cp.spawn("chpasswd")var errmsg//查看是否有错误chpasswd.stderr.on("data", function (data) { errmsg += data.toString()})chpasswd.on("exit", function(code) { if (cb) { errmsg ? cb(new Error(errmsg)) : cb() }})//写入密码chpasswd.stdin.write(username + ":" + password)chpasswd.stdin.end()总结

前言node本身为单进程，并使用驱动模式处理并发，为了解决单进程在多核cpu上的资源浪费，node提供了cluster和child_process模块来创建多个子进程。Node.js是单线程的,对于现在普遍是多处理器的机器是一种浪费,怎么能利用起来呢？于是child_process模块出现了。child_process模块可以在其他进程上产生、派生，并执行工作。child_process模块提供了一个ChildProcess的新类，它可以作为从父进程访问子进程的表示形式。Process模块也是ChildProcess对象。当你从父模块访问process时，它是父ChildProcess对象，当你从子进程访问Process是，它是ChildProcess对象了解一个对象无外乎事件、方法、属性。ChildProcess也是一样。每个子进程总带有三个流对象：child.stdin、child.stdout、child.stderr。他们可能会共享父进程的stdio流。这里我们先介绍利用child_process模块中exec、spawn、fork三个方法对子进程的操作。建立node-childProcess文件，在其中创建node-childPro.js文件。其中就一行代码如下：console.log("进程 " + process.argv[2] + " 执行。" );//换成下面的查看process.argv//console.log("进程 " + process.argv + " 执行。" );exec()方法在node-childProcess文件中新建node-childPro-exec.js文件，其中代码如下：const fs = require("fs");const child_process = require("child_process");for (var i = 0; i < 3; i++) { //这里有空格请注意。分别代表node路径 node-childPro.js路径 i第几个进程。 node-childPro.js中的process.argv可以获取这些信息值 var childProcess = child_process.exec("node node-childPro.js "+i, // 回调函数 子进程的输出以回调函数参数的形式返回 function (error, stdout, stderr) { if (error) { console.log(error.stack); console.log("Error code: " + error.code); console.log("Signal received: " + error.signal); } console.log("stdout: " + stdout); console.log("stderr: " + stderr); }); childProcess.on("exit", function (code) { console.log("子进程已退出，退出码 " + code); });}终端执行代码结果如下：G: ode ode-childProcess> node node-childPro-exec.js子进程已退出，退出码 0stdout: 进程 0 执行。stderr:子进程已退出，退出码 0stdout: 进程 1 执行。stderr:子进程已退出，退出码 0stdout: 进程 2 执行。stderr:spawn()方法在node-childProcess文件中新建node-childPro-spawn.js,其中代码如下：const fs = require("fs");const child_process = require("child_process"); for(var i=0; i<3; i++) { var childProcess = child_process.spawn("node", ["node-childPro-spawn.js", i]); childProcess.stdout.on("data", function (data) { console.log("stdout: " + data); });childProcess.stderr.on("data", function (data) { console.log("stderr: " + data); }); childProcess.on("close", function (code) { console.log("子进程已退出，退出码 "+code); });}终端执行代码结果如下：G: ode ode-childProcess> node node-childPro-spawn.jsstdout: 进程 0 执行。子进程已退出，退出码 0stdout: 进程 1 执行。stdout: 进程 2 执行。子进程已退出，退出码 0子进程已退出，退出码 0fork()方法在node-childProcess文件中新建node-childPro-fork.js,其中代码如下：const fs = require("fs");const child_process = require("child_process"); for(var i=0; i<3; i++) { var childProcess = child_process.fork("node-childPro.js", [i]); childProcess.on("close", function (code) { console.log("子进程已退出，退出码 " + code); });}终端执行代码结果如下：G: ode ode-childProcess> node node-childPro-fork.js进程 0 执行。进程 1 执行。子进程已退出，退出码 0进程 2 执行。子进程已退出，退出码 0子进程已退出，退出码 0关于exec、spawn、fork 1.exec函数是对spawn的一种友好封装，增加Shell命令解析，可以直接嵌入复杂的命令 2.exec函数缓存子进程的输出，并将子进程的输出以回调函数参数的形式返回 3.spawn在子线程开始执行后，就开始不断将数据从子进程返回给主进程（应用场景如“系统监控”） 4.spawn是不支持callback函数的，它通过流的方式发数据传给主进程，从而实现了多进程之间的数据交换 5.fork()是spawn()的特殊情景，用于派生Node进程。除了普通ChildProcess实例所具有的所有方法，所返回的对象还具有内建的通讯通道。下载地址：https://gitee.com/wangFengJ/node/tree/master/node-childProcess总结

NOD32杀毒能力:★★★★金山毒霸杀毒能力：★★★NOD32监控：★★★★金山毒霸监控：★★自我表达:总体说nod32比金山好，但是nod32占用内存较大，也影响开机速度，金山虽说逊于nod32，但内存占用较少。

前言在开始之前，我们先来简单介绍下Travis-ci，Travis-ci是一款持续集成（Continuous Integration）服务，它能够很好地与Github结合，每当代码更新时自动地触发集成过程。Travis-ci配置简单，很多nodejs项目都用它做自动测试。然而，对于持续集成，仅做到自动测试是不够的，还要有后续的自动部署，才能完成“提交代码 => 自动测试 => 自动部署”的集成链条。本文以nodejs应用为例，来谈谈如何利用travis-ci完成自动部署。话不多说，来一起看看详细的介绍：基本原理从自动测试到自动部署的核心问题是测试机与生产服务器的信任问题，即如何安全地把程序包传输到生产服务器。市面上的部署工具如scp、ansible、chef，都绕不开这个核心问题。以scp为例，测试机登录生产服务器的方式有两种：密码和秘钥。密码登录方式需要交互式地输入密码，总不能每次测试的时候，人为地输入密码吧，所以密码方式行不通。秘钥的方式可以实现自动登录，但首次将测试机的公钥传输给生产服务器仍然需要密码。似乎走入了死胡同，但办法总是有的。我们知道开发机是可以登录到生产服务器的，那么我们就可以将开发机的公钥复制到生产服务器，将开发机的私钥复制到测试机，测试机通过私钥来伪装成开发机，自动地登录到生产服务器。解决了自动登录的问题，另一个问题是怎么将开发机的私钥复制到测试机上。由于测试机每次都是新开的一个虚拟机，这个新开的虚拟机IP不固定，所以没办法直接登录上去。解决办法是将私钥文件作为代码库的一部分提交，这样测试机每次从代码库上拉取代码的同时也获取到了秘钥文件，通过这种方式就实现了私钥从开发机复制到测试机。将私钥文件提交到代码库有一个很严重的安全性问题，即任何人只要得到了这个私钥文件，他就可以随心所欲的操纵生产服务器。幸好，travis-ci提供了加密方案，它能够将私钥文件加密，加密后的文件只在当前代码库有效。总的来说，通过复制私钥完成自动登录以及对私钥加密来保障安全性，我们就可以建立起测试机与生产服务器的信任通道，测试机就可以安全地操作生产服务器完成自动部署。配置现在我以scp方式部署nodejs应用为例，来说明travis-ci做自动部署的配置。首先，建立起开发机与生产服务器的信任关系：ssh-copy-id username@host然后，加密你的私钥，私钥文件通常在~/.ssh/id_rsa。加密私钥文件需要使用travis这个命令行工具，它是一个ruby包，使用gem安装：gem install travistravis login输入账号密码登录成功后，使用travis encrypt-file加密：travis encrypt-file ~/.ssh/id_rsa --add上面命令执行完后，会生成一段解密命令并添加到.travis.yml中：before_install: - openssl aes-256-cbc -K $encrypted_830d3b21a25d_key -iv $encrypted_830d3b21a25d_iv -in ~/.ssh/id_rsa.enc -out ~/.ssh/id_rsa -d接下来，把加密后的私钥文件（id_rsa.enc）复制到代码库中，千万要注意不要错把未加密的私钥文件（id_rsa）复制到你的代码库中。然后把上面的解密命令的-in ~/.ssh/id_rsa.enc改为-in id_rsa.enc。通过上面的过程就基本建立测试机与生产服务器的信任关系，但还有一些小细节要处理。例如，降低id_rsa文件的权限，否则ssh处于安全方面的原因会拒绝读取秘钥；将生产服务器地址加入到测试机的信任列表中，否则连接时会询问是否信任服务器。更改后的配置如下:before_install: - openssl aes-256-cbc -K $encrypted_830d3b21a25d_key -iv $encrypted_830d3b21a25d_iv -in id_rsa.enc -out ~/.ssh/id_rsa -d - chmod 600 ~/.ssh/id_rsa - echo -e "Host 102.201.64.94 StrictHostKeyChecking no " >> ~/.ssh/config最后，测试机就可以愉快地操作生产服务器了，例如下面是一个nodejs应用的.travis.yml文件配置：language: node_jsnode_js: - "4.4.4"before_install: - openssl aes-256-cbc -K $encrypted_830d3b21a25d_key -iv $encrypted_830d3b21a25d_iv -in id_rsa.enc -out ~/.ssh/id_rsa -d - chmod 600 ~/.ssh/id_rsa - echo -e "Host 102.201.64.94 StrictHostKeyChecking no " >> ~/.ssh/configscript: - npm run testafter_success: - npm prune --production # 删除devDependencies - tar -jcf indoor-server.tar.bz2 * # 打包并压缩代码 - scp indoor-server.tar.bz2 jingsam@102.201.64.94:~/ # 复制到生产服务器上 - ssh jingsam@102.201.64.94 "mkdir -p indoor-server && tar -jxf indoor-server.tar.bz2 -C indoor-server" # 解压 - ssh jingsam@102.201.64.94 "cd indoor-server && pm2 startOrReload pm2.json" # 重启pm2总结本篇文章讲的自动部署其实与nodejs关系不大，完全适用于各种语言的自动部署，其原理都是相通的。好了，

GN-0000/7S 七剑型00高达（00 Gundam Seven Sword） 官方外传《机动战士高达00V》中登场。为搭载「七剑」装备的00高达。 在双重动力系统之性能被完全开发之前，假想刹那·F·塞耶必须驾驶00高达时的接近战斗用装备。此装备是曾被能天使高达采用的「七剑（Seven Sword）」的进化型，同样拥有七把剑，但是每把剑均大幅度进化了。本装备是新生的天上人在与刹那会合之前设计而成，在拉格朗日点L3的工厂内研发。但是随著后来双炉系统之成功运作而失去作用，因而没有投入实战。 名称由来 型号中的「7S」即为「七剑（Seven Sword）」 原名：00 Gundam Seven Sword ダブルオーガンダム セブンソード 设计者：海老川兼武 型号：GN-0000/7S 制造者：天上人 所属：天上人 类型：机动战士 新世代高达 接近战斗用装备型 高度：18.3公尺 重量：65.1公吨 动力源：GN-Drive X2 主要涂装颜色：蓝、白 驾驶员：刹那·F·塞耶 武装： GN长剑Ⅱ GN短剑Ⅱ GN破坏巨剑Ⅱ GN粒子束军刀×2 GN拳刃×2 GN力场 特殊装置 大型GN电容器×2 Trans-AM系统

从版本 8.5.0 开始，Node.js 开始支持原生 ES 模块，可以通过命令行选项打开该功能。新功能很大程度上得归功于 Bradley Farias。本文主要和大家介绍在 Node.js 中使用原生 ES 模块方法解析，还有部分内容的链接，下面我们就来一起看看吧，需要的朋友可以参考下，希望能帮助到大家。1.演示这个示例的代码目录结构如下：lib.mjs：main.mjs：运行演示：2.清单：需要注意的事情ES 模块：·不能动态导入模块。但是 动态import() 的相关工作正在进行中，应该很快就能提供支持。·没有元变量，如 __dirname 和 __filename。但是，有一个的类似功能的提案：“import.meta”。看起来可能是这样：·现在所有模块标识符都是 URL（这部分在 Node.js 是新增的）：·文件 - 带文件扩展名的相对路径： ../util/tools.mjs·库 - 没有文件扩展名，也没有路径 lodash·如何更好地使 npm 库在浏览器中也可用（不使用 bundler）仍有待观察。一种可能性是引入 RequireJS 风格的配置数据，将路径映射到实际路径。目前，在浏览器中使用 bare path 的模块标识符是非法的。与 CJS 模块的互操作性你可以导入 CJS 模块，但它们总是只有默认的导出 - 即 module.exports 的值。让 CJS 模块支持命名导出已经在做了，但可能需要一段时间。如果你能帮忙，可以来做。 · 不能在 ES 模块中使用 require()。主要原因是： · 路径解析工作稍有不同：ESM 不支持 NODE_PATH 和 require.extensions。而且，它的标识符始终是 URL 也会导致一些细微差异。 · ES 模块始终以异步方式加载，这确保了与 Web 的最大兼容性。这种加载风格并不能通过 require() 混合使用同步加载 CJS 模块。 · 禁止同步模块加载也可以为 Top-level await 导入 ES 模块保留后路（一个当前正在考虑的功能）。3.早期版本的 Node.js 上的 ES 模块如果要在 8.5.0 之前的 Node.js 版本上使用 ES 模块，请参阅 John-David Dalton 的 @std/esm。提示：如果不启用任何可解锁的额外功能，将在 Node.js 保持 100％ 兼容原生 ES 模块.FAQ什么时候可以不带命令行选项使用ES 模块？目前的计划是在 Node.js 10 LTS 中默认可使用 ES 模块。进一步阅读有关 Node.js 和浏览器中 ES 模块的更多信息： · “Making transpiled ES modules more spec-compliant” [using ES modules natively vs. transpiling them via Babel] · “Module specifiers: what"s new with ES modules?” [Why .mjs? How are module specifiers resolved? Etc.] · “Modules” [in-depth chapter on ES modules in “Exploring ES6”]即将到来的 ECMAScript 提案： · 博客: “ES proposal: import() _ dynamically importing ES modules” · 提案: “import.meta”

1、浏览器问题：尽量使用IE浏览器并关闭阻止窗口弹出功能。打开浏览器，点击浏览器上方工具栏“工具”，选择“Internet选项”，依次点击“连接”--“局域网设置”，“代理服务器”下的内容若打上勾的话，表示设置了网络代理，将两个勾都去掉则表示取消网络代理。正常使用WLAN需要将“代理服务器”处的两个勾都去掉，确保浏览器未使用代理。2、IP问题：建议自动获取IP地址。检查IP的方法，依次点击：开始--控制面板--网络和共享中心--无线网络连接--详细信息--ipv4地址，或者点击右下角无线网络连接图标，选择CMCC点击右键，选择状态查看ipv4地址。

名为 ibdata*（*＝0,1,2...）的文件就是Innodb表类型的数据文件

- 恢复策略前面说到未提交的事务和回滚了的事务也会记录Redo Log，因此在进行恢复时,这些事务要进行特殊的的处理.有2中不同的恢复策略： A. 进行恢复时，只重做已经提交了的事务。B. 进行恢复时，重做所有事务包括未提交的事务和回滚了的事务。然后通过Undo Log回滚那些未提交的事务。- InnoDB存储引擎的恢复机制MySQL数据库InnoDB存储引擎使用了B策略, InnoDB存储引擎中的恢复机制有几个特点： A. 在重做Redo Log时，并不关心事务性。 恢复时，没有BEGIN，也没有COMMIT,ROLLBACK的行为。也不关心每个日志是哪个事务的。尽管事务ID等事务相关的内容会记入Redo Log，这些内容只是被当作要操作的数据的一部分。B. 使用B策略就必须要将Undo Log持久化，而且必须要在写Redo Log之前将对应的Undo Log写入磁盘。Undo和Redo Log的这种关联，使得持久化变得复杂起来。为了降低复杂度，InnoDB将Undo Log看作数据，因此记录Undo Log的操作也会记录到redo log中。这样undo log就可以像数据一样缓存起来，而不用再redo log之前写入磁盘了。包含Undo Log操作的Redo Log，看起来是这样的：记录1: <trx1, Undo log insert <undo_insert …>>记录2: <trx1, insert …>记录3: <trx2, Undo log insert <undo_update …>>记录4: <trx2, update …>记录5: <trx3, Undo log insert <undo_delete …>>记录6: <trx3, delete …>C. 到这里，还有一个问题没有弄清楚。既然Redo没有事务性，那岂不是会重新执行被回滚了的事务？确实是这样。同时Innodb也会将事务回滚时的操作也记录到redo log中。回滚操作本质上也是对数据进行修改，因此回滚时对数据的操作也会记录到Redo Log中。一个回滚了的事务的Redo Log，看起来是这样的：记录1: <trx1, Undo log insert <undo_insert …>>记录2: <trx1, insert A…>记录3: <trx1, Undo log insert <undo_update …>>记录4: <trx1, update B…>记录5: <trx1, Undo log insert <undo_delete …>>记录6: <trx1, delete C…>记录7: <trx1, insert C>记录8: <trx1, update B to old value>记录9: <trx1, delete A>一个被回滚了的事务在恢复时的操作就是先redo再undo，因此不会破坏数据的一致性.- InnoDB存储引擎中相关的函数Redo: recv_recovery_from_checkpoint_start()Undo: recv_recovery_rollback_active()Undo Log的Redo Log: trx_undof_page_add_undo_rec_log()

- 恢复策略前面说到未提交的事务和回滚了的事务也会记录Redo Log，因此在进行恢复时,这些事务要进行特殊的的处理.有2中不同的恢复策略： A. 进行恢复时，只重做已经提交了的事务。B. 进行恢复时，重做所有事务包括未提交的事务和回滚了的事务。然后通过Undo Log回滚那些未提交的事务。- InnoDB存储引擎的恢复机制MySQL数据库InnoDB存储引擎使用了B策略, InnoDB存储引擎中的恢复机制有几个特点： A. 在重做Redo Log时，并不关心事务性。 恢复时，没有BEGIN，也没有COMMIT,ROLLBACK的行为。也不关心每个日志是哪个事务的。尽管事务ID等事务相关的内容会记入Redo Log，这些内容只是被当作要操作的数据的一部分。B. 使用B策略就必须要将Undo Log持久化，而且必须要在写Redo Log之前将对应的Undo Log写入磁盘。Undo和Redo Log的这种关联，使得持久化变得复杂起来。为了降低复杂度，InnoDB将Undo Log看作数据，因此记录Undo Log的操作也会记录到redo log中。这样undo log就可以像数据一样缓存起来，而不用再redo log之前写入磁盘了。包含Undo Log操作的Redo Log，看起来是这样的：记录1: <trx1, Undo log insert <undo_insert …>>记录2: <trx1, insert …>记录3: <trx2, Undo log insert <undo_update …>>记录4: <trx2, update …>记录5: <trx3, Undo log insert <undo_delete …>>记录6: <trx3, delete …>C. 到这里，还有一个问题没有弄清楚。既然Redo没有事务性，那岂不是会重新执行被回滚了的事务？确实是这样。同时Innodb也会将事务回滚时的操作也记录到redo log中。回滚操作本质上也是对数据进行修改，因此回滚时对数据的操作也会记录到Redo Log中。一个回滚了的事务的Redo Log，看起来是这样的：记录1: <trx1, Undo log insert <undo_insert …>>记录2: <trx1, insert A…>记录3: <trx1, Undo log insert <undo_update …>>记录4: <trx1, update B…>记录5: <trx1, Undo log insert <undo_delete …>>记录6: <trx1, delete C…>记录7: <trx1, insert C>记录8: <trx1, update B to old value>记录9: <trx1, delete A>一个被回滚了的事务在恢复时的操作就是先redo再undo，因此不会破坏数据的一致性.- InnoDB存储引擎中相关的函数Redo: recv_recovery_from_checkpoint_start()Undo: recv_recovery_rollback_active()Undo Log的Redo Log: trx_undof_page_add_undo_rec_log()

发到你百度消息了！

magento的数据连接是需要InnoDB的数据类型支持的，你现在的VPS是不支持的这个数据连接类型。你是VPS联系客服帮你改下吧，装magento之前可以到官网下载一个测试脚本文件检查下，看是不是支持magento的。有问题，可以继续追问。

前言 ：在Hadoop 1.x版本，HDFS集群的NameNode一直存在单点故障问题：集群只存在一个NameNode节点，它维护了HDFS所有的元数据信息，当该节点所在服务器宕机或者服务不可用，整个HDFS集群都将处于不可用状态，极大限制了HDFS在生产环境的应用场景。直到Hadoop 2.0版本才提出了高可用 (High Availability, HA) 解决方案，并且经过多个版本的迭代更新，已经广泛应用于生产环境。 解决方案 ：在同一个HDFS集群，运行两个互为主备的NameNode节点。一台为主Namenode节点，处于Active状态，一台为备NameNode节点，处于Standby状态。其中只有Active NameNode对外提供读写服务，Standby NameNode会根据Active NameNode的状态变化，在必要时切换成Active状态。 【NameNode HA架构图】 HealthMonitor 定时调用NameNode的HAServiceProtocol RPC接口(monitorHealth和getServiceStatus)，监控NameNode的健康状态并向ZKFC反馈； ActiveStandbyElector 接收ZKFC的选举请求，通过Zookeeper自动完成主备选举，选举完成后回调ZKFC的主备切换方法对NameNode进行Active和Standby状态的切换； JouranlNode集群 共享存储系统，负责存储HDFS的元数据，Active NameNode(写入)和Standby NameNode(读取)通过共享存储系统实现元数据同步，在主备切换过程中，新的Active NameNode必须确保元数据同步完成才能对外提供服务; ZKFailoverController在启动时同时会初始化HealthMonitor和ActiveStandbyElector服务，同时也会向HealthMonitor和ActiveStandbyElector注册相应的回调方法： HealthMonitor检测NameNode的两类状态，HealthMonitor.State和HealthMonitor.HAServiceStatus。在程序上启动一个线程循环调用NameNode的HAServiceProtocol RPC接口的方法来检测NameNode 的状态，并将状态的变化通过回调的方式来通知ZKFailoverController。 当HealthMonitor检测到NameNode的健康状态或角色状态发生变化时，ZKFC会根据状态的变化决定是否需要进行主备选举。 HealthMonitor.State状态变化导致的不同后续措施： HAServiceStatus在状态检测之中仅起辅助的作用，当HAServiceStatus发生变化时，ZKFC会判断NameNode返回的HAServiceStatus与ZKFC所期望的是否相同，如果不相同，ZKFC会调用ActiveStandbyElector的quitElection方法删除当前已经在ZK上建立的临时节点退出主备选举。 ZKFC通过ActiveStandbyElector的joinElection方法发起NameNode的主备选举，这个过程通过Zookeeper的写一致性和临时节点机制实现: a. 当发起一次主备选举时，Zookeeper会尝试创建临时节点 /hadoop-ha/${dfs.nameservices}/ActiveStandbyElectorLock ，Zookeeper的写一致性保证最终只会有一个ActiveStandbyElector创建成功，创建成功的 ActiveStandbyElector对应的NameNode就会成为主NameNode，ActiveStandbyElector回调ZKFC的方法将对应的NameNode切换为Active状态。而创建失败的ActiveStandbyElector对应的NameNode成为备NameNode，ActiveStandbyElector回调ZKFC的方法将对应的NameNode切换为Standby状态; b. 不管是否选举成功，所有ActiveStandbyElector都会向Zookeeper注册一个Watcher来监听这个节点的状态变化事件; c. 如果Active NameNode对应的HealthMonitor检测到NameNode状态异常时，ZKFC会删除在Zookeeper上创建的临时节点ActiveStandbyElectorLock，这样处于Standby NameNode的ActiveStandbyElector注册的Watcher就会收到这个节点的 NodeDeleted事件。收到这个事件后，会马上再次创建ActiveStandbyElectorLock，如果创建成功，则Standby NameNode被选举为Active NameNode。 【防止脑裂】 在分布式系统中脑裂又称为双主现象，由于Zookeeper的“假死”，长时间的垃圾回收或其它原因都可能导致双Active NameNode现象，此时两个NameNode都可以对外提供服务，无法保证数据一致性。对于生产环境，这种情况的出现是毁灭性的，必须通过自带的隔离（Fencing）机制预防这种现象的出现。 ActiveStandbyElector为了实现fencing隔离机制，在成功创建 hadoop-ha/dfs.nameservices/ActiveStandbyElectorLock 临时节点 后，会创建另外一个 /hadoopu2212ha/{dfs.nameservices}/ActiveBreadCrumb 持久节点 ，这个持久节点保存了Active NameNode的地址信息。当Active NameNode在正常的状态下断开Zookeeper Session (注意由于 /hadoop-ha/dfs.nameservices/ActiveStandbyElectorLock 是临时节点，也会随之删除)，会一起删除持久节点 /hadoopu2212ha/{dfs.nameservices}/ActiveBreadCrumb 。但是如果ActiveStandbyElector在异常的状态下关闭Zookeeper Session，那么由于 /hadoop-ha/${dfs.nameservices}/ActiveBreadCrumb 是持久节点，会一直保留下来。当另一个NameNode （standy => active） 选主成功之后，会注意到上一个Active NameNode遗留下来的ActiveBreadCrumb节点，从而会回调ZKFailoverController的方法对旧的Active NameNode进行fencing。 ① 首先ZKFC会尝试调用旧Active NameNode的HAServiceProtocol RPC接口的transitionToStandby方法，看能否将状态切换为Standby； ② 如果调用transitionToStandby方法切换状态失败，那么就需要执行Hadoop自带的隔离措施，Hadoop目前主要提供两种隔离措施： sshfence：SSH to the Active NameNode and kill the process； shellfence：run an arbitrary shell command to fence the Active NameNode； 只有在成功地执行完成fencing之后，选主成功的ActiveStandbyElector才会回调ZKFC的becomeActive方法将对应的NameNode切换为Active，开始对外提供服务。 博客主页： https://www.jianshu.com/u/e97bb429f278

一般用的都是keypoint,创建关键点；而point起划分作用。

WG？ WG都加强壳你这个WG 加的壳是 VMProtect 就是这个意思不是木马

Meteor基于Node.js，但是却有自己的包管理系统(atmosphere)以及代码加载机制，且meteor是非异步的，这些都意味着，node.js包(npm package)和代码通常不能直接用于meteor程序。这里分享三种方法以在meteor中复用node.js包和代码。meteorhacks:npm + meteorhacks:asyncnpm+async是复用npm包最便捷的方式。meteor程序添加npm包之后，便可以在packages.json中声明包依赖，在程序中通过Meteor.npmRequire来加载包。值得一提的是，由于大部分npm包都是异步调用的，而meteor是同步运行的，所以需要某种方法将异步调用转为同步调用。async就是这样一个meteor包，添加之后，通过Async.runSync方法便可以同步地调用异步方法。具体安装、使用方法以及更多介绍，请参考文档。适配node.js代码如果需要复用的代码仅仅是个别文件、函数、片段等，可以手工修改代码以适配meteor程序。需要注意到，node.js的每一个文件都是一个模块，通过module.exports和require进行组织，但是在meteor中，每一个文件都是会被自动加载的(具体顺序参考meteor文档)，通过全局变量进行跨文件调用；meteor中不能直接加载npm包；meteor框架是同步运行的（非异步）。综上，适配代码的工作包括：使用meteorhacks:npm来加载npm包修改跨文件调用方式，将原来的module.exports=xxx改为暴露全局变量，而调用方，将require(xxx)改为直接引用全局变量直接被meteor框架调用的方法，使用meteorhacks:async包，将其从异步调用改为同步调用形式创建meteor包这种方法更复杂，但是也更进阶，不仅可以封装npm包，也能封装任意node.js代码（当然需要修改、适配），更能创建新的meteor包。创建meteor包的具体方法不再赘述，参考如下:Writing Meteor Packagespackage.js docMeteor Packages Tutorial学会创建meteor包之后，只需要按照上述方法适配代码，并封装成meteor包，便可以方便地使用和分享了。参考项目meteor-submail该项目规模很小，便于分析。原始代码在submail-sdk文件夹中，其余代码为对原始代码的适配和封装。

打包成模块

　　无线接入网络（RAN）包含一个或者多个无线网络子系统（RNS），每一个RNS又是由一个无线网络控制器（RNC）和一个或者多个NodeB组成的。 无线网络控制器（RNC）用于控制UTRAN的无线资源。RNC一般与一个MSC和一个SGSN或者广播域（BC Domain）通过Iu.　　ENodeB 简称 ENB，可以理解为基站。负责UE（可理解为手机）的电话调度等。MME（移动性管理实体）负责UE移动性管理，比如漫游、切换。PGW（PND-GW（网关））负责UE网络用户面的管理，SGW（serving-GW）负责UE网络控制面管理。看看lte方面资料会了解多些。　　首先你弄明白什么是网络，就是一堆设备连接在一块，可以相互通信的结构。我们把其中每个设备抽象出来当成一个节点，可称为逻辑节点。逻辑节点还有一层意思是，它只有单一的一种主要作用。比如接入网是由单一的ENB组成，一个ENB就是接入网的一个逻辑节点。而核心网有MME，SGW，pgw，hss。。。这都是逻辑节点，但正式做设备时会将其中几个逻辑节点的功能做成一个设备。

ENodeB简称ENB，可以理解为基站。负责UE（可理解为手机）的电话调度等。MME（移动性管理实体）负责UE移动性管理，比如漫游、切换。PGW（PND-GW（网关））负责UE网络用户面的管理，SGW（serving-GW）负责UE网络控制面管理。EvolvedNodeB，即演进型NodeB简称eNB，LTE中基站的名称，相比现有3G中的NodeB，集成了部分RNC的功能，减少了通信时协议的层次。NodeB：就是在和一个或者多个小区中和UE在无线传输中一个逻辑的接点。简单点理解就是小区。在4G中，ENodeB在功能实际上包含了NodeB的功能和部分RNC的功能。EPC=EvolvedPacketCore字面意思：进化型的分组核心。SGW提供用户面的控制功能，负责数据包的路由和转发，并支持终端移动性切换用户数据功能。PGW主要负责终端和外部分组数据网络的数据传输，在VoLTE网络中，PGW分配终端IP地址并提供EPC部分到IMS部分的接入。

本文主要给大家介绍了关于在Windows系统下安装Node.js报错:2503、2502的解决方法，文中将解决的方法一步步介绍的非常详细，需要的朋友可以参考借鉴，下面随着小编来一起学习学习吧，希望能帮助到大家。前言Windows真的是太恶心了！！！不仅会出现大量的垃圾文件，而且有时莫名的安装不上一些软件（正常软件）。前久因为想学学Koa2,打算升级下nodejs的版本以体验下ES6、ES7的aync，await等新特性，却死活安装不上nodejs同时也卸载不了老版的nodejs，不知所措，放了一段时间，今晚想看看D3准备学学，并借助Koa做个展示性的学习练手项目，决心查查资料解决下nodejs安装报错问题。功夫不负有心人，终于得以解决，故以此文记录下。目录权限问题？首先我想是不是权限问题，于是我把要安装的目录和Windos下的Temp目录权限都设为完全控制，还是不行，绝望！设置文件目录权限绝望之际，看到网上的一篇文章完美解决，握草还是权限问题！以管理员身份用msiexec安装1、以管理员身份运行cmd命令 （Win + X, A）以管理员身份运行cmd2、用msiexec安装用msiexec安装nodejsmsiexec /package node-v8.7.0-64.msi至此，安装完成！查看nodejs版本

参考资料： YOLO之外的另一选择，手机端97FPS的Anchor-Free目标检测模型NanoDet现已开源~ 1、什么是 Nanodet Nanodet 是一个速度超快和轻量级的移动端 Anchor-free 目标检测模型，是基于 FCOS 模型进行轻量化改进而来的2、Nanodet 跟其他模型的性能对比华为 P30 上用 NCNN 移植跑 benchmark，一张图片仅需 10.23 毫秒，比 YoloV4-Tiny 快 3 倍，参数量小 6 倍，COCO mAP(05:0.95) 能够达到 20.6。而且模型权重文件仅有 1.8m 由此可见，Nanodet 能够在有较低参数量和较小的模型权重文件情况下，能够拥有跟 YoloV4-Tiny 一样的 mAP3、Nanodet 的网络结构图backbone 是 ShuffNetV2 1.0x，去掉最后一层的卷积层，并且抽取 8/16/32倍下采样率的特征输入到 PAN 中做多尺度的特征融合4、Nanodet 相对于 FCOS 的改进① 检测头 FCOS：共享检测头权重 Nanodet：不共享检测头，因为在移动端是使用 CPU 来进行计算的，共享检测头权重并不会对推理过程加速；共享检测头会使得其检测能力进一步下降 ② 归一化方式 FCOS：使用 Group Normalization Nanodet：使用 Batch Normalization 来取代 Group Normalization，因为后者虽然比前者有很多优点，但却有一个缺点：Batch Normalization 可以在推理时将其参数融入到卷积核中，节省这一步计算可以节省时间 ③ 检测头大小 FCOS：检测头大小为 4 个 256 通道数的卷积核组为一个分支，因此边框回归和分类两个分支，则总共需要 8 个 256 通道数的卷积 Nanodet：将 4 个卷积核组减少为 2 个卷积核组。在通道数上将 256 维降低为 96 维。将边框回归和分类共享检测头，然后再切割成两份，分别去预测边框回归和分类。 ④ FPN 层 FCOS：没有该模块 Nanodet：基于 FPN 改进为 PAN，原版的 FPN 在对高层特征图使用线性插值后，再使用 3*3 卷积。但是 Nanodet 去掉了 FPN 中线性插值后再使用的 3*3 卷积，只保留从骨干网络特征提取后的 1*1 卷积来进行特征通道维度的对齐。同时 FPN 只是在多层特征融合端使用了自上而下的特征融合，而 PAN 则不仅使用了自上而下的特征融合，而且还使用了自底向上的特征融合，使用的方法也是线性插值。5、Nanodet 的算法步骤6、Nanodet 的损失函数7、Nanodet 的优点 ① 速度快 ② 模型参数权重文件小8、Nanodet 的缺点 ① mAP 不高

短信接入文档 在网易云信管理中心->应用管理->自己的应用里查看appkey和appsecret 需要三样东西来生成签名 如法炮制,把请求头改成符合他条件的就好 文档 融云文档真是比网易的强太多

Node.js 是建立在谷歌的 V8 JavaScript 引擎服务器端的软件平台上。在构建高性能的服务器端应用程序上，Node.js 在 JavaScript 中已是首选方案。是什么让使用 Node.js 库和应用程序的庞大生态系统来开发服务器后台变得如此流行。Node.js 自带一个被称为 npm 的命令行工具可以让你轻松地安装它，进行版本控制并使用 npm 的在线仓库来管理 Node.js 库和应用程序的依赖关系。在本教程中，我将介绍 如何在主流 Linux 发行版上安装 Node.js，包括 Debian，Ubuntu，Fedora 和 CentOS 。Node.js 在一些发行版上有预构建的程序包（如，Fedora 或 Ubuntu），而在其他发行版上你需要通过源码安装。由于 Node.js 发展比较快，建议从源码安装最新版而不是安装一个过时的预构建的程序包。最新的 Node.js 自带 npm（Node.js 的包管理器），让你可以轻松的安装 Node.js 的外部模块。在 Debian 上安装 Node.js on从 Debian 8 (Jessie)开始，Node.js 已被纳入官方软件仓库。因此，你可以使用如下方式安装它：$ sudo apt-get install npm在 Debian 7 (Wheezy) 以前的版本中,你需要使用下面的方式来源码安装：$ sudo apt-get install python g++ make$ wget http://nodejs.org/dist/node-latest.tar.gz$ tar xvfvz node-latest.tar.gz$ cd node-v0.10.21 (replace a version with your own)$ ./configure$ make$ sudo make install在 Ubuntu 或 Linux Mint 中安装 Node.jsNode.js 被包含在 Ubuntu（13.04 及更高版本）。因此，安装非常简单。以下方式将安装 Node.js 和 npm。$ sudo apt-get install npm$ sudo ln -s /usr/bin/nodejs /usr/bin/node而 Ubuntu 中的 Node.js 可能版本比较老，你可以从 其 PPA 中安装最新的版本。$ sudo apt-get install python-software-properties python g++ make$ sudo add-apt-repository -y ppa:chris-lea/node.js$ sudo apt-get update$ sudo apt-get install npm在 Fedora 中安装 Node.jsNode.js 被包含在 Fedora 的 base 仓库中。因此，你可以在 Fedora 中用 yum 安装 Node.js。$ sudo yum install npm如果你想安装 Node.js 的最新版本，可以按照以下步骤使用源码来安装。$ sudo yum groupinstall "Development Tools"$ wget http://nodejs.org/dist/node-latest.tar.gz$ tar xvfvz node-latest.tar.gz$ cd node-v0.10.21 (replace a version with your own)$ ./configure$ make$ sudo make install在 CentOS 或 RHEL 中安装 Node.js在 CentOS 使用 yum 包管理器来安装 Node.js，首先启用 EPEL 软件库，然后运行：$ sudo yum install npm如果你想在 CentOS 中安装最新版的 Node.js，其安装步骤和在 Fedora 中的相同。在 Arch Linux 上安装 Node.jsNode.js 在 Arch Linux 的社区库中可以找到。所以安装很简单，只要运行：$ sudo pacman -S nodejs npm检查 Node.js 的版本一旦你已经安装了 Node.js，你可以使用如下所示的方法检查 Node.js 的版本。$ node --version

本篇文章主要介绍了详解如何在NodeJS项目中优雅的使用ES6，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。NodeJs最近的版本都开始支持ES6（ES2015）的新特性了，设置已经支持了async／await这样的更高级的特性。只是在使用的时候需要在node后面加上参数：--harmony。但是，即使如此node也还是没有支持全部的ES6特性。所以这个时候就需要用到Babel了。项目地址：https://github.com/future-challenger/petshop现在开始Babel在开始使用Babel之前，假设1.你已经安装了nodejs，并且已经熟悉了Js。2.你也可以使用npm安装各种依赖包。3.而且你也对ES6（后来改为ES2015）有一定程度的熟悉。同时假设你已经安装了yarn，并且也熟悉了yarn。Yarn最大的优点就是它比npm要快很多，因为yarn只把需要的库下载一次，之后用到的时候直接使用本地缓存的版本。npm每次都会下载这些库。这简直就是浪费生命。如果你还没有安装yarn，也没有关系，下面也会有npm的使用方法。接下来开始安装配置Babel。安装babel-cliyarn add babel-cli --dev // npm install --save-dev babel-cli安装babel的presets。yarn add babel-preset-es2015 --dev // npm install --save-dev babel-preset-es2015这个时候你就可以使用ES2015的特性了。但是，这还不够，比如我不想用Promise我想用更加方便的async/await语法。只有es2015这个preset是不够的。Babel的plugin和presetBabel本身不处理语言特性的转码。这些功能都是由plugin和preset实现的（preset也是一个plugin的集合）。如上文所述，要使用es2015的内容就需要安装babel-preset-es2015这个preset。要使用async/await那么就需要安装对应的preset或者插件。为了简单我们安装preset：babel-preset-stage-0。preset stage-0包含了async/await相关的插件: babel-plugin-syntax-async-functions、babel-plugin-transform-regenerator。yarn add babel-preset-stage-0 --dev // npm install --save-dev babel-preset-stage-0这样还是不能在项目中使用es7的async/await了。还需要更多的配置，有两种方法可以达到目的：1.使用babel-polyfill。有一个不好地地方，babel-polyfill会污染global对象，所以不适合于library之类的使用。仅适合于web app使用。2.使用babel运行时转码工具，transform-runtime插件。使用这个方法正好弥补了上面的方法的不足之处。它是尤其适合于library一类的项目使用。分别介绍这两种方法。 安装babel-polyfill:yarn add babel-polyfill --dev // npm install --save-dev babel-polyfill之后，在你的项目的入口文件的最上方引入babel-polyfill。比如我现在有一个Express的Web App，那么的入口文件就是开启这个app的index.js文件。在这个文件的最上方引入polyfill，require("babel-polyfill")。或者你的入口文件已经是ES2015的写法了，那么就直接import，import "babel-polyfill"。使用transform-runtime也非常简单。安装：yarn add babel-plugin-transform-runtime --dev // npm install --save-dev babel-plugin-transform-runtime另外还需要安装babel-runtime:yarn add babel-runtime // npm install --save babel-runtime之后在.babelrc文件中添加如下的配置，两个二选其一即可：// without options{ "plugins": ["transform-runtime"]}// with options{ "plugins": [ ["transform-runtime", { "helpers": false, // defaults to true "polyfill": false, // defaults to true "regenerator": true, // defaults to true "moduleName": "babel-runtime" // defaults to "babel-runtime" }] ]}剩下的就是欢畅的使用async/await了。另外如果要使用Object.assing这样的方法的话，也可以使用插件：babel-plugin-transform-object-assign，如果要使用解构赋值可以使用插件：babel-plugin-transform-object-rest-spread。当然这些都包含在了stage-0这个preset中。现在就开始写ES2015的代码吧。在项目中安装ExpressJs，创建一个index.js文件。我们来试着创建一个小小的web app作为练习：import Express from "express"let app = Express()app.get("/", (req, res) => { res.send("hello world")})app.listen(8080, () => console.log("server is running at http://localhost:8080"))运行命令：./node_modules/.bin/babel-node index.js --preset es2015, stage-0使用命令*babel-node**就可以让代码运行起来，后面的参数指定了在转义js代码的时候使用的preset和plugin。Babel官方推荐的方法是时候用.babelrc文件，这一方式可以更加灵活。在项目的更目录上创建.babelrc文件，在里面添加你安装的preset和plugin的描述：{ "presets": ["es2015", "stage-0"]}这样可以直接使用babel-node来执行代码，或者使用命令babel来转义代码。如：babel -w code/ -d build/babel命令会从配置文件中读取配置，来变异code/目录下的文件，并把转义之后的JavaScript文件导出到build/目录下。还有命令行里的参数-w，这个命令参数指定的是watch，每次code目录的文件修改后都会触发babel命令的再次执行。在文件中使用Source Maps上面看起来很不错了。但是还有一个问题，在你调试代码的时候，你调试的实际是babel命令转码之后的js，不是原来你编写的源代码所在的文件。调试的不是源文件，多少会有些不便。比如下面的文件会抛出一个异常：async function errorAsyncFunc() { try{ throw new Error("Async function error") } catch(e) { throw e }}errorAsyncFunc()在转码命令中加一个--source-maps可以解决这个问题：babel code/ -d build/ --source-maps最后在package.json里添加scripts节点："scripts": { "build": "babel src -d build --source-maps", "start": "node build/index.js"},接下来：npm run buildGulp出场上文讲述了如何使用Babel实现ES201x的开发。但是在正式的开发中，上面的这些配置还略显不足，尤其是你的项目包括web端、server端，尤其web端不仅处理ES201x的代码还需要处理。所以需要Gulp出场。这玩意儿看起来很复杂，你定义了编译的过程。其实掌握了以后很好用，尤其是可以自动处理很多东西，节约大把时间。要使用Gulp，必须先安装NodeJS。这个基本是标配。然后你会用到它的命令行工具。安装Gulp在最新发布的Gulp里有一点调整。gulp-cli从gulp分离出来作为单独的一部分使用。所以，如果你已经安装过gulp之前的版本需要先删除：npm rm --global gulp安装gulp-cliyarn global add gulp-cli // npm install --global gulp-cli在--dev模式下安装gulpyarn add gulp --dev // npm install --save-dev gulp创建gulp配置文件就像Babel要用.babelrc作为配置文件一样，gulp也需要一个配置文件。这个配置文件就是gulpfile.js, 但是和babel同用的情况下把gulpfile.js重命名为gulp.babel.js：mv "gulpfile.js" "gulpfile.babel.js"gulp的使用还是很简单的，主要就是在gulpfile.babel.js文件中添加各种task。在这些task中一定要添加一个叫做default的task，gulp命令的执行起点就是从这里开始。假设有这么一个场景：1.使用eslint检查代码，发现代码风格和潜在的错误。2.自动实现ES201x -> ES5的代码转码，并把转码后的代码放在指定目录下。3.在转码的时候添加sourcemaps。以上这些“任务”都是用gulp自动实现。该如何配置呢？gulp和eslint要在gulp中使用各种请他的类似于eslint这样的功能的时候需要使用在gulp上的对应的插件。没错，gulp的设计思路和gulp基本一样：插件机制。那么我们就需要首先下载eslint的插件：yarn add --dev gulp-eslint // npm install --save-dev gulp-eslint在开始编写我们的第一个task之前, 做最后的准备工作。首先需要配置.eslintrc文件。eslint会根据这个文件定义的规则检查代码的风格。我们不准备大批的配置规则，这样非常耗时间而且也照顾不到很多我们项目已经保留下来的编码风格。所以，airbnb的一套规则拿来使用时最好的办法。安装eslintyarn add --dev eslint // npm install --save-dev eslint然后你可以运行命令来初始化配置：./node_modules/.bin/eslint --init。你也可以忽略这个命令，直接创建一个.eslintrc的文件。安装eslint的airbnb扩展要使用airbnb的一套规则就需要安装他们的eslint扩展：yarn add eslint-config-airbnb --dev // npm install --save-dev eslint-config-airbnb命令执行之后会提示有些依赖项没有安装，分别是eslint-plugin-import@^2.2.0、eslint-plugin-import@^2.2.0、eslint-plugin-jsx-a11y@^3.0.2。依次安装这些依赖项就好。.eslintrc{ "env": { "es6": true }, "rules": { "semi": "off", "import/no-extraneous-dependencies": ["error", { "devDependencies": true, "optionalDependencies": false, "peerDependencies": false }] ,"quotes": ["error", "single", {"allowTemplateLiterals": true}] }, "extends": "airbnb"}env指定环境是支持es6的，rules指定的是一些补充内容，比如字符串使用单引号还是双引号等。这个是根据个人喜好配置的，你可以选择添加你需要的规则。最后是extends，这里配置airbnb就用上了airbnb的一套eslint编码检查规则。gulp-eslint插件用起来import gulp from "gulp"import eslint from "gulp-eslint// 配置需要处理的文件目录和转码之后文件的存放目录const paramConfig = { source: "src/**/*.js", dest: "build",}引入相关模块之后开始写任务：gulp.task("lint", () => { // eslint配置，使用配置的文件目录。排除node_modules下的全部文件。 return gulp.src([paramConfig.source, "!node_modules/**"]) .pipe(eslint()) .pipe(eslint.result(result => { console.log(`ESLint result: ${result.filePath}`); console.log(`# Messages: ${result.messages.length}`); console.log(`# Warnings: ${result.warningCount}`); console.log(`# Errors: ${result.errorCount}`); })) .pipe(eslint.format()) .pipe(eslint.failOnError())})如前文所述，default任务是必须：gulp.task("default", ["lint"], function () { // lint任务成功执行之后执行这个方法});跳转到项目的目录下，运行gulp命令。会得到如下的输出：$ gulp[21:43:01] Requiring external module babel-register[21:43:01] Using gulpfile ~/Documents/test-polyfill/gulpfile.babel.js[21:43:01] Starting "lint"...[21:43:02] Starting "babel-sourcemaps"...ESLint result: ~/Documents/test-polyfill/src/index.js# Messages: 0# Warnings: 0# Errors: 0ESLint result: ~/Documents/test-polyfill/src/test.js# Messages: 0# Warnings: 0# Errors: 0[21:43:02] Finished "lint" after 605 ms[21:43:02] Finished "babel-sourcemaps" after 653 ms[21:43:02] Starting "default"...gulp default task![21:43:02] Finished "default" after 98 μsgulp和babel这次同时处理babel和sourcemaps的问题。首先安装插件：yarn add --dev gulp-babel // npm install --save-dev gulp-babelimport gulp-babel插件：import babel from "gulp-babel"import sourcemaps from "gulp-sourcemaps"添加任务：gulp.task("babel-sourcemaps", () => { return gulp.src(paramConfig.source) .pipe(sourcemaps.init()) .pipe(babel()) .pipe(sourcemaps.write(".")) .pipe(gulp.dest(paramConfig.dest))})修改default任务：javascript gulp.task("default", ["lint", "babel-sourcemaps"], () => { console.log("gulp default task!") })如果你不想用sourcemaps的话，可以这么写：javascript gulp.task("babel", () => { return gulp.src(paramConfig.source) .pipe(babel()) .pipe(gulp.dest(paramConfig.dest)) })把gulp放在npm命令体系下babel老早就配置好了，现在和配置好了gulp。gulp每次输入命令基本上就是手动执行。现在应该让这个命令半自动执行了。修改package.json文件，在其中添加scripts节点： "scripts": { "build": "gulp", "start": "node build/index.js" },如此一来，很多的命令都可以像gulp一样放在npm的scripts里执行。比如，现在可以在命令行李输入如下命令来实现lint和babel转码：npm run build开始执行：npm start总结使用bebel可以提前使用最新的JavaScript语言特性，这样编写很多代码的时候会变得简洁高效。并且babel转码之后生成的代码也是非常规范的ES5写法，同时是在严格模式下的。所以，我们在写ES201x代码的时候不需要再添加"use strict";标识。使用gulp又可以使很多不大不小但是很费时间的事自动处理。把这两者结合在一起会让你的项目开发效率提升很多。所以，看到这里你不觉得你应该赶快在项目里使用这些技术，让开发进入快车道吗！！！？？？

以正常目前的业务场景来说(非nodejs),一个进程平均是用1.5-3G内存不等.缓存是根据某些特定条件组合生成的key(key的数量稍微有点儿多),需要从MongoDB/Redis读取数据.1MB的数据是业务数据传输量最大的那种,不是只有这种业务.场景可以假设为,获取用户的一些浏览记录,包含图片,描述,评测等(描述与评价都算是比较大的传输量的数据),每次获取30条左右.然后再乘以一定的用户在线数量,这个缓存数据是比较庞大的.先不考虑这个架构是否可以优化.发这个主题的原因只是想了解到nodejs有没有什么成熟方案可以共享进程间的数据比如用户X,访问站点时,被调度系统分配给A进程获取了luby的浏览历史,A进程从mongodb获取到luby的记录列表进行呈现.这时候用户Y也想看看luby的浏览历史,这调度系统分配给了B进程.这个时候B进程又要再去mongodb获取一次.我期望是B进程可以共享A进程的luby记录列表1)降低mongogdb的访问频率2)提高响应速度,因为减少了mongodb查询,减少了网络传输.

以正常目前的业务场景来说(非nodejs),一个进程平均是用1.5-3G内存不等.缓存是根据某些特定条件组合生成的key(key的数量稍微有点儿多),需要从MongoDB/Redis读取

本篇文章将介绍关于使用node.js读取JSON文件内容，使用的是JSonfile模块的readfile和readfilesync函数。要求：要在系统上安装node.js和npm。对于本篇文章，我们使用的是JSonfile NPM模块。因此，首先需要在系统上安装JSonfile模块$ npm install jsonfile --save现在，正在创建一个虚拟的json文件employee.json。也可以使用自己的JSON文件。文件名：employee.json[ { "emp_id" : "101", "emp_name" : "Mike", "emp_addr" : "123 California, USA", "designation" : "Editor" }, { "emp_id" : "102", "emp_name" : "Jacob", "emp_addr" : "456 Log Angelis, USA", "designation" : "Chief Editor" }]1、用nodejs读取json文件在上面的步骤中，创建了一个JSON文件示例。现在创建ReadJsonFile.js并添加以下内容。需要使用JSON文件名更改employee.json。文件名：ReadJsonFile.jsvar jsonFile = require("jsonfile")var fileName = "employee.json"jsonFile.readFile(fileName, function(err, jsonData) { if (err) throw err; for (var i = 0; i < jsonData.length; ++i) { console.log("Emp ID: "+jsonData[i].emp_id); console.log("Emp Name: "+jsonData[i].emp_name); console.log("Emp Address: "+jsonData[i].emp_addr); console.log("Designation: "+jsonData[i].designation); console.log("----------------------------------"); }});现在使用以下命令运行nodejs脚本。$ node ReadJsonFile.js Emp ID: 101Emp Name: MikeEmp Address: 123 California, USADesignation: Editor----------------------------------Emp ID: 102Emp Name: JacobEmp Address: 456 Log Angelis, USADesignation: Chief Editor----------------------------------2、用nodejs读取json文件或者，可以使用readfilesync函数读取JSON文件内容。创建一个包含以下内容的readjsonfilesync.js文件文件名：readjsonfilesync.jsvar jsonFile = require("jsonfile")var fileName = "employee.json"var jsonData = jsonFile.readFileSync(fileName);for (var i = 0; i < jsonData.length; ++i) { console.log("Emp ID : "+jsonData[i].emp_id); console.log("Emp Name : "+jsonData[i].emp_name); console.log("Emp Address : "+jsonData[i].emp_addr); console.log("Designation : "+jsonData[i].designation); console.log("----------------------------------");}现在使用以下命令运行nodejs脚本。$ node ReadJsonFileSync.js Emp ID: 101Emp Name: MikeEmp Address: 123 California, USADesignation: Editor----------------------------------Emp ID: 102Emp Name: JacobEmp Address: 456 Log Angelis, USADesignation: Chief Editor----------------------------------本篇文章到这里就已经全部结束了，更多其他精彩内容可以关注PHP中文网的node.js视频教程栏目！！！

flowchart流程图没有startnode是没有运行/开始的指令或代码的意思。【定义元素】tag：标签type：标签类型content：流程语句中放置的内容(type与content有一个空格)url：链接，与流程语句绑定【连接元素】->连接元素时，在标签后面可以加上(right)或者(left)来指定连线方向需要注意，condition类型标签似乎不可以标（left）

在上方菜单栏找到Preference-Meshing Options打开后在下方即可调整node tol

A．NO是有毒气体，是氨氧化法制硝酸中的尾气中造成环境污染的主要物质，在氨氧化法制硝酸中的尾气中没有硝酸，故A错误；B．在氨氧化法制硝酸中的过程中无硫元素参与，无有毒气体硫化氢产生，故B错误；C．在氨氧化法制硝酸中的过程中无氢气生成，所以硝酸中的尾气中无氢气，故C错误；D．NO与NO2都为有毒气体，是造成环境污染的主要物质，且都在氨氧化法制硝酸中的过程中生成，故D正确；故选D．

StreamBuffer 的工作原理 Data 是一块大数据 他被分为很多个小数据 每块小数据都被存储在内存中的 Buffer 中 接着 Buffer 不断接收小数据 同时一旦 Buffer 接收的小数据填满了就会被消费 填满的 Buffer 也被称为一个 Chunk 所有 Chunk 组合而成的才是那块 Data 大数据Stream 的分类 Read Stream Write Stream Duplex TransformDuplex 实际上就是有两个 Buffer 一个处理 ReadStream 另一个是处理 WriteStream；典型的例子就是 Network SocketTransform 实际上有三个 Buffer 串联一起，中间的 Buffer 实际上就是类似中转的运输作用，也可以从中修改数据；典型的例子就是 encoding/decoding, Compressing/Decompressing, Filtering data, JS to JSONpipepipe 的概念就相当于一个“水管”，将 readable 连接至 writable总结

网络构架中的节点node(结点):网络连接的端点,或两条(或多条)线路的连接点.结点可以是处理器、控制器或工作站.结点随其功能不同而各不相同,他们可以通过链路互联在一起,在网络中用作控制点.节点是指一台电脑或其他设备与一个有独立地址和具有传送或接收数据功能的网络相连。（A computer or other device connected to a network, which has a unique address and is capable of sending or receiving data.)Node节点，结点，网点 节点可以是工作站、客户、网络用户或个人计算机，还可以是服务器、打印机和其他网络连接的设备。

我曾听别人抱怨说，stylus语法太灵活，容易导致混乱。不过我倒是最喜欢stylus的说。还有一个原因是，stylus的相关工具不能和less以及scss相比。举个例子：bootstrap-stylus 281 starbootstrap-sass 7387 starbootstrap 72019 star你们感受下……因为没靠山嘛，Less 的发展有 Bootstrap，Sass 的发展有 Compass ，Stylus 有啥……所以即使我觉得 Stylus 完爆 Less 几条街，至少能和 Sass 分庭抗礼，Stylus 还是不温不火

在定义Service的时候可以指定一个自己需要的类型的Service，如果不指定的话默认是ClusterIP类型。 可以使用的服务类型如下： 通过集群的内部 IP 暴露服务，选择该值，服务只能够在集群内部可以访问，这也是默认的Service类型。ClusterIP类型的service创建时，k8s会通过etcd从可分配的IP池中分配一个IP，该IP全局唯一，且不可修改。所有访问该IP的请求，都会被iptables转发到后端的endpoints中。 通过每个 Node 节点上的 IP 和静态端口（NodePort）暴露服务。NodePort 服务会路由到 ClusterIP 服务，这个 ClusterIP 服务会自动创建。通过请求 :，可以从集群的外部访问一个 NodePort 服务。 需要外部支持（GCP and Azure），用户访问service.spec.external-ip,该IP对应到一个外部负载均衡的vip，外部服务对这个vip的请求，会被loadbalancer通过健康检查和转发，发送到一个运行着该服务pod的node上，并同样通过nodePort里的端口映射，发送给容器。 用户可以指定一个任意的名字，作为该service被解析的CNAME,这种类型的servcie不用指定clusterIP，因此kube-proxy不会管理这类service，这类service需要使用1.7版本以上的kubedns。 (1)创建whoami-deployment.yaml文件 (2)运行yaml文件并查看pod以及service (3)在集群内正常访问 (4)创建whoami的service 注意：该地址只能在集群内部访问 **可以发现有一个Cluster IP类型的service，名称为whoami-deployment，IP地址为10.97.233.149 (5)通过Service的Cluster IP访问 (6)具体查看一下whoami-deployment的详情信息，发现有一个Endpoints连接了具体3个Pod (7)下面通过deployment对whoami扩容成5个 (8)再次访问：curl 10.97.233.149:8000 (9)再次查看service具体信息：kubectl describe svc whoami-deployment (10)其实对于Service的创建，不仅仅可以使用kubectl expose，也可以定义一个yaml文件 总结：其实Service存在的意义就是为了Pod的不稳定性，而上述探讨的就是关于Service的一种类型Cluster IP，只能供集群内访问。 因为外部能够访问到集群的物理机器IP，所以就是在集群中每台物理机器上暴露一个相同的IP，从给定的配置范围内（默认：30000-32767）分配端口 (1)根据whoami-deployment.yaml创建pod (2)创建NodePort类型的service，名称为whoami-deployment (3)注意上述的端口31999，实际上就是暴露在集群中物理机器上的端口 (4)浏览器通过物理机器的IP访问 使用浏览器访问： 总结：NodePort虽然能够实现外部访问Pod的需求，但这种方法有许多缺点： 1.每个端口只能是一种服务 2.端口范围只能是 30000-32767 3.如果节点/VM 的 IP 地址发生变化，你需要能处理这种情况 基于以上原因，我不建议在生产环境上用这种方式暴露服务。如果你运行的服务不要求一直可用，或者对成本比较敏感，你可以使用这种方法。这样的应用的最佳例子是 demo 应用，或者某些临时应用。 因篇幅太长分为两章来写。

1、MySQL InnoDB事务隔离级别脏读、可重复读、幻读MySQL InnoDB事务的隔离级别有四级，默认是“可重复读”（REPEATABLE READ）。· 1）.未提交读（READUNCOMMITTED）。另一个事务修改了数据，但尚未提交，而本事务中的SELECT会读到这些未被提交的数据（脏读）( 隔离级别最低，并发性能高 )。· 2）.提交读（READCOMMITTED）。本事务读取到的是最新的数据（其他事务提交后的）。问题是，在同一个事务里，前后两次相同的SELECT会读到不同的结果（不重复读）。会出现不可重复读、幻读问题（锁定正在读取的行）· 3）.可重复读（REPEATABLEREAD）。在同一个事务里，SELECT的结果是事务开始时时间点的状态，因此，同样的SELECT操作读到的结果会是一致的。但是，会有幻读现象（稍后解释）。会出幻读（锁定所读取的所有行）。· 4）.串行化（SERIALIZABLE）。读操作会隐式获取共享锁，可以保证不同事务间的互斥（锁表）。‘四个级别逐渐增强，每个级别解决一个问题。· 1）.脏读。另一个事务修改了数据，但尚未提交，而本事务中的SELECT会读到这些未被提交的数据。· 2）.不重复读。解决了脏读后，会遇到，同一个事务执行过程中，另外一个事务提交了新数据，因此本事务先后两次读到的数据结果会不一致。· 3）.幻读。解决了不重复读，保证了同一个事务里，查询的结果都是事务开始时的状态（一致性）。但是，如果另一个事务同时提交了新数据，本事务再更新时，就会“惊奇的”发现了这些新数据，貌似之前读到的数据是“鬼影”一样的幻觉。 具体地： 1). 脏读 首先区分脏页和脏数据 脏页是内存的缓冲池中已经修改的page，未及时flush到硬盘，但已经写到redo log中。读取和修改缓冲池的page很正常，可以提高效率，flush即可同步。脏数据是指事务对缓冲池中的行记录record进行了修改，但是还没提交！！！，如果这时读取缓冲池中未提交的行数据就叫脏读，违反了事务的隔离性。脏读就是指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。 2). 不可重复读 是指在一个事务内，多次读同一数据。在这个事务还没有结束时，另外一个事务也访问该同一数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改，第二个事务已经提交。那么第一个事务两次读到的的数据可能是不一样的。这样就发生了在一个事务内两次读到的数据是不一样的，因此称为是不可重复读。例如，一个编辑人员两次读取同一文档，但在两次读取之间，作者重写了该文档。当编辑人员第二次读取文档时，文档已更改。原始读取不可重复。如果只有在作者全部完成编写后编辑人员才可以读取文档，则可以避免该问题 3). 幻读 : 是指当事务不是独立执行时发生的一种现象，例如第一个事务对一个表中的数据进行了修改，这种修改涉及到表中的全部数据行。同时，第二个事务也修改这个表中的数据，这种修改是向表中插入一行新数据。那么，以后就会发生操作第一个事务的用户发现表中还有没有修改的数据行，就好象发生了幻觉一样。例如，一个编辑人员更改作者提交的文档，但当生产部门将其更改内容合并到该文档的主复本时，发现作者已将未编辑的新材料添加到该文档中。如果在编辑人员和生产部门完成对原始文档的处理之前，任何人都不能将新材料添加到文档中，则可以避免该问题。2、隔离级别实验 以下实验基于博主MySQL Server 5.6 首先创建一个表，如下：USE test; CREATE TABLE `t` ( `a` int(11) NOT NULL PRIMARY KEY ) ENGINE=InnoDB DEFAULT CHARSET=utf8;2.1、实验一：解释脏读、可重复读问题 事务A READ-UNCOMMITTED事务B READ-COMMITTED,事务C-1 REPEATABLE-READ事务C-2 REPEATABLE-READ事务D SERIALIZABLEset autocommit =0;start transaction ;start transaction; insert into t(a)values(4);select * from t;1,2,3,4(脏读：读取到了未提交的事务中的数据)select * from t;1,2,3（解决脏读）select * from t;1,2,3select * from t;1,2,3select * from t;1,2,3commit;select * from t:1,2,3,4select * from t:1,2,3,4select * from t:1,2,3,4 (与上面的不在一个事务中，所以读到为事务提交后最新的，所以可读到4)select * from t:1,2,3（重复读：由于与上面的在一个事务中，所以只读到事务开始事务的数据，也就是重复读）select * from t:1,2,3,4 commit（提交事务，下面的就是一个新的事务，所以可以读到事务提交以后的最新数据）select * from t:1,2,3,4 READ-UNCOMMITTED 会产生脏读，基本很少适用于实际场景，所以基本不使用。2.2、实验二：测试READ-COMMITTED与REPEATABLE-READ事务A事务B READ-COMMITTED事务C REPEATABLE-READset autocommit =0;start transaction ;start transaction;start transaction;insert into t(a)values(4);select * from t;1,2,3select * from t;1,2,3commit;select * from t:1,2,3,4select * from t:1,2,3（重复读：由于与上面的在一个事务中，所以只读到事务开始事务的数据，也就是重复读）commit（提交事务，下面的就是一个新的事务，所以可以读到事务提交以后的最新数据）select * from t:1,2,3,4REPEATABLE-READ可以确保一个事务中读取的数据是可重复的，也就是相同的读取（第一次读取以后，即使其他事务已经提交新的数据，同一个事务中再次select也并不会被读取）。READ-COMMITTED只是确保读取最新事务已经提交的数据。当然数据的可见性都是对不同事务来说的，同一个事务，都是可以读到此事务中最新数据的。如下，start transaction; insert into t(a)values(4); select *from t; 1,2,3,4; insert into t(a)values(5); select *from t; 1,2,3,4,5;2.3、实验三：测试SERIALIZABLE事务对其他的影响事务A SERIALIZABLE事务B READ-UNCOMMITTED事务C READ-COMMITTED,事务D REPEATABLE-READ事务E SERIALIZABLEset autocommit =0; start transaction ;start transaction; select a from t union all select sleep(1000) from dual;insert into t(a)values(5);insert into t(a)values(5);insert into t(a)values(5);insert into t(a)values(5); ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transactionERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transactionERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transactionERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction SERIALIZABLE 串行化执行，导致所有其他事务不得不等待事务A结束才行可以执行，这里特意使用了sleep函数，直接导致事务B,C,D,E等待事务A持有释放的锁。由于我sleep了1000秒，而innodb_lock_wait_timeout为120s。所以120s到了就报错HY000错误。SERIALIZABLE是相当严格的串行化执行模式，不管是读还是写，都会影响其他读取相同的表的事务。是严格的表级读写排他锁。也就失去了innodb引擎的优点。实际应用很少。2.4、实验四：幻读一些文章写到InnoDB的可重复读避免了“幻读”（phantom read），这个说法并不准确。做个实验：(以下所有试验要注意存储引擎和隔离级别)CREATE TABLE `t_bitfly` ( `id` bigint(20) NOT NULL default "0", `value` varchar(32) default NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8; select @@global.tx_isolation, @@tx_isolation; +-----------------------+-----------------+ | @@global.tx_isolation | @@tx_isolation | +-----------------------+-----------------+ | REPEATABLE-READ | REPEATABLE-READ | +-----------------------+-----------------+ 实验4-1：Session ASession Bstart transaction ;start transaction ;SELECT * FROM t_bitfly;empty setINSERT INTO t_bitfly VALUES (1, "a");COMMIT;SELECT * FROM t_bitfly;| empty setINSERT INTO t_bitfly VALUES (1, "a");|ERROR 1062 (23000):|Duplicate entry "1" for key 1(刚刚明明告诉我没有这条记录的)I如此就出现了幻读，以为表里没有数据，其实数据已经存在了，提交后，才发现数据冲突了。实验4-2：Session ASession Bstart transaction ;start transaction ;SELECT * FROM t_bitfly;| +------+-------+| | id | value || +------+-------+| | 1 |a || +------+-------+INSERT INTO t_bitfly VALUES (2, "b");SELECT * FROM t_bitfly;| +------+-------+| | id | value || +------+-------+| | 1 |a || +------+-------+COMMIT;SELECT * FROM t_bitfly;| +------+-------+| | id | value || +------+-------+| | 1 |a || +------+-------+ UPDATE t_bitfly SET value="z";| Rows matched: 2 Changed:2 Warnings: 0(怎么多出来一行)SELECT * FROM t_bitfly;| +------+-------+| | id | value || +------+-------+| | 1 |z || | 2 |z || +------+-------+本事务中第一次读取出一行，做了一次更新后，另一个事务里提交的数据就出现了。也可以看做是一种幻读。附说明那么，InnoDB指出的可以避免幻读是怎么回事呢？http://dev.mysql.com/doc/refman/5.0/en/innodb-record-level-locks.htmlBy default, InnoDB operatesin REPEATABLE READ transaction isolation level and with the innodb_locks_unsafe_for_binlog system variable disabled. In this case, InnoDB uses next-key locks for searches and index scans, which prevents phantom rows (see Section 13.6.8.5, “Avoidingthe Phantom Problem Using Next-Key Locking”).准备的理解是，当隔离级别是可重复读，且禁用innodb_locks_unsafe_for_binlog的情况下，在搜索和扫描index的时候使用的next-keylocks可以避免幻读。关键点在于，是InnoDB默认对一个普通的查询也会加next-key locks，还是说需要应用自己来加锁呢？如果单看这一句，可能会以为InnoDB对普通的查询也加了锁，如果是，那和序列化（SERIALIZABLE）的区别又在哪里呢？MySQL manual里还有一段：13.2.8.5. Avoiding the PhantomProblem Using Next-Key Locking (http://dev.mysql.com/doc/refman/5.0/en/innodb-next-key-locking.html)Toprevent phantoms, InnoDB usesan algorithm called next-key locking that combinesindex-row locking with gap locking.Youcan use next-key locking to implement a uniqueness check in your application:If you read your data in share mode and do not see a duplicate for a row you are going to insert, then you can safely insert your row and know that the next-key lock set on the success or of your row during the read prevents anyone mean while inserting a duplicate for your row. Thus, the next-key locking enables you to “lock” the nonexistence of something in your table.我的理解是说，InnoDB提供了next-key locks，但需要应用程序自己去加锁。manual里提供一个例子：SELECT * FROM child WHERE id> 100 FOR UPDATE;这样，InnoDB会给id大于100的行（假如child表里有一行id为102），以及100-102，102+的gap都加上锁。可以使用show engine innodb status来查看是否给表加上了锁。再看一个实验，要注意，表t_bitfly里的id为主键字段。实验4-3：Session ASession Bstart transaction ;start transaction ;SELECT * FROM t_bitfly WHERE id<=1 FOR UPDATE;| +------+-------+| | id | value || +------+-------+| | 1 |a || +------+-------+INSERT INTO t_bitfly VALUES (2, "b");| Query OK, 1 row affectedSELECT * FROM t_bitfly;| +------+-------+| | id | value || +------+-------+| | 1 |a || +------+-------+INSERT INTO t_bitfly VALUES (0, "0");| (waiting for lock ...| then timeout) ERROR 1205 (HY000):Lock wait timeout exceeded;|try restarting transactionSELECT * FROM t_bitfly;| +------+-------+| | id | value || +------+-------+| | 1 |a || +------+-------+COMMIT;SELECT * FROM t_bitfly;| +------+-------+| | id | value || +------+-------+| | 1 |a || +------+-------+可以看到，用id<=1加的锁，只锁住了id<=1的范围，可以成功添加id为2的记录，添加id为0的记录时就会等待锁的释放。附说明：MySQL manual里对可重复读里的锁的详细解释：http://dev.mysql.com/doc/refman/5.0/en/set-transaction.html#isolevel_repeatable-readFor locking reads (SELECT with FOR UPDATE or LOCK IN SHARE MODE),UPDATE, and DELETE statements, locking depends on whether the statement uses a unique index with a unique search condition, or a range-type search condition. For a unique index with a unique search condition, InnoDB locks only the index record found, not the gap before it. For other search conditions, InnoDB locks the index range scanned, using gap locks or next-key (gap plus index-record)locks to block insertions by other sessions into the gaps covered by the range.一致性读和提交读，先看实验，实验4-4：Session ASession Bstart transaction ;start transaction ;SELECT * FROM t_bitfly;| +------+-------+| | id | value || +------+-------+| | 1 |a || +------+-------+INSERT INTO t_bitfly VALUES (2, "b"); COMMIT;SELECT * FROM t_bitfly;| +------+-------+| | id | value || +------+-------+| | 1 |a || +------+-------+SELECT * FROM t_bitfly LOCK IN SHARE MODE;| +----+-------+| | id | value || +----+-------+| | 1 |a || | 2 |b || +----+----

nodejs的几种模块加载方式一.直接在exports对象中添加方法1. 首先创建一个模块(module.js)module.jsexports.One = function(){console.log("first module");};2.load.jsvar module =require("./module");module.One();这样我们就可以在引入了该模块后,返回一个exports对象,这里是指module对象,其实都只是两个引用或者句柄,只是都指向了同一个资源,在load.js里,module的名字可以是任意取的,因为它仅仅是指向require("./module");返回后的一个实例对象的引用,在load.js文件里的module和在module.js里的exports对象是同一个东西.因此上述两个文件可以用一个文件来表示:exports.One = function(){console.log("first module");};exports.One();其运行结果是一致的,这里我们可以很清晰的看到,我们在使用require("./xxxx")后其实返回的总是在 xxxx.js文件中的exports对象的引用,这个引用的名字我们可以任意取,但是为了规范我们还是最好取符号某些非标准规定(后面说道),但是这样会有不妥的地方,因为它是始终指向exports的实例对象,也就是说,我们虽然有了这个模块,但是这个模块我们只能使用一次,这取决于rquire("./module")只会加在一次该模块.比如我们修改上述代码,module.jsvar name ;exports.setName = function(oName){name = oName;};exports.getName = function(){console.log(name);};load.jsvar module1 = require("./module");module1.setName("felayman1");module1.getName();var module2 = require("./module");module2.setName("felayman2");module2.getName();module1.getName();我们可以看到,虽然我们使用了两次require("./module");,但是当我们修改module2后,module1的内容也被修改,这恰恰说明了,module1和module2是指向的同一个对象.有时候这并不影响我们的程序,但是如果我们的module是Person呢?我们希望我们require("./person")后返回的是不同的对象.因此,这种方式是有缺陷的,尽管很方便,这种方式在大部分nodejs的模块中都是很常见,比如fs模块,http模块等.二.将模块中的函数挂载到exports对象的属性上person.js<span style="font-family:Courier New;font-size:18px;">function Person{<span style="white-space: pre; "> </span>var name;<span style="white-space: pre; "> </span>this.setName = function(theName){<span style="white-space: pre; "> </span>name = theName;<span style="white-space: pre; "> </span>};<span style="white-space: pre; "> </span>this.sayHello = function(){<span style="white-space: pre; "> </span>console.log("Hello",name);<span style="white-space: pre; "> </span>};}exports.Person = Person;</span><span style="font-size:24px;font-family: "Microsoft YaHei"; "></span>load.js var Person = require("./person").Person;var person1 = new Person();person1.setName("felayman1");person1.sayHello();var person2 = new Person();person2.setName("felayman2");person2.sayHello();person1.sayHello();这样我们可以看到,我们就可以引入一个函数了,我们把在person.js文件中的Person函数设置为eports对象的一个属性,我们只需要在load.js文件中引入该属性,就可以获取到多个该函数的实例,在nodejs中的EventEmitter就是基于这种方式,但是这样我们总是在使用 require("./person").Person;这样的写法有点太复杂,因此nodejs允许我们使用其他更简洁的方式,利用全局变量--module,这样我们在其他文件中引入其他模块的时候,就更方便了.三.利用全局变量module person.js<span style="font-family:Courier New;">function Person(){var name;this.setName = function(theName){name = theName;};this.sayHello = function(){console.log("Hello",name);};}// exports.Person = Person;module.exports = Person;</span>load.jsvar Person = require("./person");var person1 = new Person();person1.setName("felayman1");person1.sayHello();var person2 = new Person();person2.setName("felayman2");person2.sayHello();person1.sayHello();这样一修改,我们就在使用require函数的时候就方便了,如果觉得这里难以理解,我们可以把两个文件里语法放到一起:var Person = require("./person");module.exports = Person;这样,我们就可以看出,其实就是这样var Person = Person.因为上述我们都已经说过,require("./person")其实就是module.exports 对象的,这里的module我们不用太在意,就跟javascript中的window一样,是一个全局变量,即 module.exports =exports就类似于window.alert() =alert()差不多的效果,这样我们就能看出,我们再次使用require("./person")的时候其实就是导入了我们所需要的exports对象的属性函数模板了,这样我们也可以多次实例化我们所需要的对象了.这种方式是综合了前两种的方法,因此也是官方推荐的使用方法.

事情的起因是这样的， 因为某些原因， 最近在写 Nodejs 的 c++ module， 然后在js这边调用。 网络通信自然离不开ssl， 于是需要链接到Openssl的库。我们本来的期望是，需要用户安装有Openssl的运行库， 然后我们的c++ module 动态链接到Openssl的so库上来运行。起初一切看起来还不错，直到我们发现这个openssl的函数不能工作：PKCS7_sign()PKCS7_sign ( )我们发现：如果我们的 c++ 模块与Openssl库动态链接的话, 编译都没问题. 但是运行会出现: PKCS7_sign 符号无法找到的错误.如果我们的 c++ 模块与Openssl库静态链接的话, 编译也没问题, 但是运行时,调用这个函数的地方没有效果, 这个函数返回值是 0. 按照文档表示出现错误, 但是用 Openssl的函数 ERR_get_error 获取错误码也是0. 表示没有错误码.在linux上是这样, 那在Mac上呢? 用Mac试了一下, 发现Mac没有问题. 于是,想到这可能是Nodejs的一个bug. 然后就去 Nodejs 给它报了一个bug: [https://github.com/joyent/node/issues/8026][1]同时, google上搜索了 nodejs linking to openssl 类似的关键字.找到这样几篇文章:https://github.com/TooTallNate/node-gyp/wiki/Linking-to-OpenSSLhttps://github.com/joyent/node/issues/3915http://serverfault.com/questions/338092/how-can-i-build-node-js-using-static-libssl-and-crypto-librarieshttps://github.com/robhawkes/node-extension/issues/1通过搜索, 我们发现, 原来Nodejs自己也使用了Openssl 库, 推测nodejs自己的crypto模块也是使用Openssl lib实现的. 这点从Nodejs的源码中就能发现, 它包含了最新的Openssl的全部源码.其中写上面第一篇文章: https://github.com/TooTallNate/node-gyp/wiki/Linking-to-OpenSSL 的那个帅哥是Nodejs的开发人员.基本结论:Nodejs 自己使用了Openssl在Nodejs 0.6之前, Nodejs是动态链接到 Openssl 库的. 而之后的版本都是静态链接的.这时发现 Node 那边已经回复我的bug了: https://github.com/joyent/node/issues/8026Node 解释的原因:Node 自己编译之后, 把自己没用到的符号清除, 所以我们在运行时就找不到符号了. 于是他们把这bug 修掉了. 保留了全部符号. 这导致 Node 的体积大了 400k.

我使用的是金山卫士+金山毒霸+avg

了解http.js模块：我们都只有要创建一个http服务，必须引用http模块,http模块最终会调用net.js实现网络服务// lib/net.js"use strict"; ...Server.prototype.listen = function(...args) { ... if (options instanceof TCP) { this._handle = options; this[async_id_symbol] = this._handle.getAsyncId(); listenInCluster(this, null, -1, -1, backlogFromArgs); // 注意这个方法调用了cluster模式下的处理办法 return this; } ...};function listenInCluster(server, address, port, addressType,backlog, fd, exclusive) {// 如果是master 进程或者没有开启cluster模式直接启动listenif (cluster.isMaster || exclusive) { //_listen2,细心的人一定会发现为什么是listen2而不直接使用listen // _listen2 包裹了listen方法，如果是Worker进程，会调用被hack后的listen方法，从而避免出错端口被占用的错误 server._listen2(address, port, addressType, backlog, fd); return; } const serverQuery = { address: address, port: port, addressType: addressType, fd: fd, flags: 0 };// 是fork 出来的进程，获取master上的handel,并且监听，// 现在是不是很好奇_getServer方法做了什么 cluster._getServer(server, serverQuery, listenOnMasterHandle);} ...答案很快就可以通过cluster._getServer 这个函数找到代理了server._listen2 这个方法在work进程的执行操作向master发送queryServer消息，向master注册一个内部TCP服务器// lib/internal/cluster/child.jscluster._getServer = function(obj, options, cb) { // ... const message = util._extend({ act: "queryServer", // 关键点：构建一个queryServer的消息 index: indexes[indexesKey], data: null }, options); message.address = address;// 发送queryServer消息给master进程，master 在收到这个消息后，会创建一个开始一个server，并且listen send(message, (reply, handle) => { rr(reply, indexesKey, cb); // Round-robin. }); obj.once("listening", () => { cluster.worker.state = "listening"; const address = obj.address(); message.act = "listening"; message.port = address && address.port || options.port; send(message); });}; //... // Round-robin. Master distributes handles across workers.function rr(message, indexesKey, cb) { if (message.errno) return cb(message.errno, null); var key = message.key; // 这里hack 了listen方法 // 子进程调用的listen方法，就是这个，直接返回0，所以不会报端口被占用的错误 function listen(backlog) { return 0; } // ... const handle = { close, listen, ref: noop, unref: noop }; handles[key] = handle; // 这个cb 函数是net.js 中的listenOnMasterHandle 方法 cb(0, handle);}// lib/net.js/*function listenOnMasterHandle(err, handle) { err = checkBindError(err, port, handle); server._handle = handle; // _listen2 函数中,调用的handle.listen方法，也就是上面被hack的listen server._listen2(address, port, addressType, backlog, fd); }*/master进程收到queryServer消息后进行启动服务如果地址没被监听过，通过RoundRobinHandle监听开启服务如果地址已经被监听，直接绑定handel到已经监听到服务上，去消费请求// lib/internal/cluster/master.jsfunction queryServer(worker, message) { const args = [ message.address, message.port, message.addressType, message.fd, message.index ]; const key = args.join(":"); var handle = handles[key]; // 如果地址没被监听过，通过RoundRobinHandle监听开启服务 if (handle === undefined) { var constructor = RoundRobinHandle; if (schedulingPolicy !== SCHED_RR || message.addressType === "udp4" || message.addressType === "udp6") { constructor = SharedHandle; } handles[key] = handle = new constructor(key, address, message.port, message.addressType, message.fd, message.flags); } // 如果地址已经被监听，直接绑定handel到已经监听到服务上，去消费请求 // Set custom server data handle.add(worker, (errno, reply, handle) => { reply = util._extend({ errno: errno, key: key, ack: message.seq, data: handles[key].data }, reply); if (errno) delete handles[key]; // Gives other workers a chance to retry. send(worker, reply, handle); });}看到这一步，已经很明显，我们知道了多进行端口共享的实现原理其实端口仅由master进程中的内部TCP服务器监听了一次因为net.js 模块中会判断当前的进程是master还是Worker进程如果是Worker进程调用cluster._getServer 去hack原生的listen 方法所以在child调用的listen方法，是一个return 0 的空方法，所以不会报端口占用错误那现在问题来了，既然Worker进程是如何获取到master进程监听服务接收到的connect呢？监听master进程启动的TCP服务器的connection事件通过轮询挑选出一个worker向其发送newconn内部消息，消息体中包含了客户端句柄有了句柄，谁都知道要怎么处理了哈哈// lib/internal/cluster/round_robin_handle.jsfunction RoundRobinHandle(key, address, port, addressType, fd) { this.server = net.createServer(assert.fail); if (fd >= 0) this.server.listen({ fd }); else if (port >= 0) this.server.listen(port, address); else this.server.listen(address); // UNIX socket path. this.server.once("listening", () => { this.handle = this.server._handle; // 监听onconnection方法 this.handle.onconnection = (err, handle) => this.distribute(err, handle); this.server._handle = null; this.server = null; });}RoundRobinHandle.prototype.add = function (worker, send) { // ...};RoundRobinHandle.prototype.remove = function (worker) { // ...};RoundRobinHandle.prototype.distribute = function (err, handle) { // 负载均衡地挑选出一个worker this.handles.push(handle); const worker = this.free.shift(); if (worker) this.handoff(worker);};RoundRobinHandle.prototype.handoff = function (worker) { const handle = this.handles.shift(); const message = { act: "newconn", key: this.key }; // 向work进程其发送newconn内部消息和客户端的句柄handle sendHelper(worker.process, message, handle, (reply) => { // ... this.handoff(worker); });};下面让我们看看Worker进程接收到newconn消息后进行了哪些操作// lib/child.jsfunction onmessage(message, handle) { if (message.act === "newconn") onconnection(message, handle); else if (message.act === "disconnect") _disconnect.call(worker, true); }// Round-robin connection.// 接收连接，并且处理function onconnection(message, handle) { const key = message.key; const server = handles[key]; const accepted = server !== undefined; send({ ack: message.seq, accepted }); if (accepted) server.onconnection(0, handle);}总结net模块会对进程进行判断，是worker 还是master, 是worker的话进行hack net.Server实例的listen方法worker 调用的listen 方法是hack掉的，直接return 0,不过会向master注册一个connection接手的事件master 收到客户端connection事件后，会轮询向worker发送connection上来的客户端句柄worker收到master发送过来客户端的句柄，这时候就可以处理客户端请求了相信看了本文案例你已经掌握了方法，更多精彩请关注Gxl网其它相关文章！推荐阅读：Vue.js双向绑定项目实战分析jquery如何判断元素内容为空

这篇文章主要介绍了nodejs结合socket.io实现websocket通信功能的方法,结合实例形式分析了nodejs结合socket.io实现websocket通信的具体步骤与相关操作技巧,需要的朋友可以参考下本文实例讲述了nodejs结合socket.io实现websocket通信功能的方法。分享给大家供大家参考，具体如下：因为项目中有需要实时获取后台数据的场景，之前一直是使用http心跳请求的方法。因为websocket与此模式相比有很大的性能提升，而且可以提高实时性，所以对websocket作了一些研究。这里是使用nodejs+socket.io来实现的。达成目标将原来心跳请求后台数据的方式，修改为通过socket连接后台统一推送的方式。后台的数据由别的进程写入文件或写入redis，这里实现的是读取文件的方式。前期准备安装nodejs(略)服务器端新建一个项目目录，这里是sockettest进入sockettest目录，安装express模块和socketio模块npm install --save express@4.10.2npm install --save socket.io新建package.json文件，在其中写入如下内容：{ "name": "socket-test", "version": "0.0.1", "description": "my first socket.io app", "dependencies": { "express": "^4.10.2", "socket.io": "^1.7.2" }}新建index.html，用于作为默认的访问显示页面，因为这里不会用到它，内容随意；新建trends.js文件，在其中写入内容：var app = require("express")();var http = require("http").Server(app);var io = require("socket.io")(http);var fs = require("fs");#默认打开文件app.get("/", function(req, res){ res.sendfile("index.html");});#用于存储所有socket以广播数据var iolist = [];#定义socket on connection（连入）事件行为io.on("connection", function(socket){ #将连入socket加入列表 iolist.push(socket); #记录index，在disconnect（断开连接）发生时将对应的socket删除 var sockex = iolist.indexOf(socket); #定义on disconnect事件行为 socket.on("disconnect", function(){ #将断开连接的socket从广播列表里删除 iolist.splice(sockex, 1); });});# 数据广播进程:每1秒钟广播一次setInterval(function() { # 如果没有正在连接的socket，直接返回； if (iolist.length <= 0) return; var trends = fs.readFileSync("./data/trends.json","utf-8");#trends数据 var coins = fs.readFileSync("./data/coins.json","utf-8");#coins数据 #向所有socket连接发送数据 for (i in iolist) { # 向客户端发送trends数据 iolist[i].emit("trends", trends); # 向客户端发送coins数据 iolist[i].emit("coins", coins); }}, 1000);# 服务器侦听在sockettest.com的3000端口上http.listen(3000, function(){ # 输出到标准输出 console.log("listening on sockettest.com:3000");});新建data目录，并在下面新建两个文件trends与coins，用于存放socket服务器将要读取的数据。新建public目录，在其中新建一个文件index.html，文件内容如下：<!--引入必要的js文件--><script type="text/javascript" src="http://sockettest:3000/socket.io/socket.io.js"></script><script type="text/javascript"> //新建socket var socket = io("http://sockettest.com:3000"); socketdata(socket); function socketdata() { #定义接收到coins类型数据时的行为 socket.on("coins", function(msg){ console.log(msg); } #定义接收到trends类型数据时的行为 socket.on("trends", function(msg){ console.log(msg); } }</script>代码部署刚才之所以要建两个index.html文件，是为了能够方便地在既有的web项目中使用nodejs提供的socket服务。这样我们把public/index.html可以部署在别的服务器中，比如nginx或tomcat之类，然后在根目下启动socket的服务器，为其提供socket服务。 首先在刚才的项目根目录下执行node ./trends.js并保持终端运行，然后再把项目部署在nginx里，通过chrome下访问nginx提供的web服务：http://hostname/public/index.html打开开发者模式，就能在console里看到每隔一秒便会收到来自node服务器的socket推送消息了。通过修改data目录下的两个文件，可以看到写入到文件的数据也会实时地推送到客户端这里来。上面是我整理给大家的，希望今后会对大家有帮助。相关文章：在vue中使用cli如何实现重构多页面脚手架在JS中实现点击下拉菜单内容同步输入框实现输入框与下拉框联动使用parcel.js打包出错的问题详细解读vue重构技术

环境是一个master主节点(192.168.31.130)和两个slave节点(192.168.31.131/132)执行stop-all.sh命令时,终端提示如下Bash/shell code?12345678910111213141516hadoop@hadoopmaster pids]$ cd $HADOOP_HOME/sbin[hadoop@hadoopmaster pids]$ stop-all.shThis script is Deprecated. Instead use stop-dfs.sh and stop-yarn.shStopping namenodes on [hadoopmaster]hadoopmaster: stopping namenode192.168.31.132: stopping datanode192.168.31.131: stopping datanodeStopping secondary namenodes [hadoopmaster]hadoopmaster: stopping secondarynamenodestopping yarn daemonsstopping resourcemanager192.168.31.132: stopping nodemanager192.168.31.131: stopping nodemanager192.168.31.132: nodemanager did not stop gracefully after 5 seconds: killing with kill -9192.168.31.131: nodemanager did not stop gracefully after 5 seconds: killing with kill -9no proxyserver to stopslave节点记录yarn-hadoop-nodemanager-hadoopslaver01.log如下Bash/shell code?1234567891011121314151617181920212223242526272829303132333435362017-06-03 07:03:19,137 INFO org.apache.hadoop.io.retry.RetryInvocationHandler: Exception while invoking ResourceTrackerPBClientImpl.nodeHeartbeat over null. Retrying after sleeping for 30000ms.java.io.EOFException: End of File Exception between local host is: "hadoopslaver01/192.168.31.131"; destination host is: "hadoopmaster":8031; : java.io.EOFException; For more details see: htp/EOFException at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method) at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62) at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45) at java.lang.reflect.Constructor.newInstance(Constructor.java:423) at org.apache.hadoop.net.NetUtils.wrapWithMessage(NetUtils.java:801) at org.apache.hadoop.net.NetUtils.wrapException(NetUtils.java:765) at org.apache.hadoop.ipc.Client.getRpcResponse(Client.java:1485) at org.apache.hadoop.ipc.Client.call(Client.java:1427) at org.apache.hadoop.ipc.Client.call(Client.java:1337) at org.apache.hadoop.ipc.ProtobufRpcEngine$Invoker.invoke(ProtobufRpcEngine.java:227) at org.apache.hadoop.ipc.ProtobufRpcEngine$Invoker.invoke(ProtobufRpcEngine.java:116) at com.sun.proxy.$Proxy73.nodeHeartbeat(Unknown Source) at org.apache.hadoop.yarn.server.api.impl.pb.client.ResourceTrackerPBClientImpl.nodeHeartbeat(ResourceTrackerPBClientImpl.java:85) at sun.reflect.GeneratedMethodAccessor11.invoke(Unknown Source) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:498) at org.apache.hadoop.io.retry.RetryInvocationHandler.invokeMethod(RetryInvocationHandler.java:398) at org.apache.hadoop.io.retry.RetryInvocationHandler$Call.invokeMethod(RetryInvocationHandler.java:163) at org.apache.hadoop.io.retry.RetryInvocationHandler$Call.invoke(RetryInvocationHandler.java:155) at org.apache.hadoop.io.retry.RetryInvocationHandler$Call.invokeOnce(RetryInvocationHandler.java:95) at org.apache.hadoop.io.retry.RetryInvocationHandler.invoke(RetryInvocationHandler.java:335) at com.sun.proxy.$Proxy74.nodeHeartbeat(Unknown Source) at org.apache.hadoop.yarn.server.nodemanager.NodeStatusUpdaterImpl$1.run(NodeStatusUpdaterImpl.java:766) at java.lang.Thread.run(Thread.java:748)Caused by: java.io.EOFException at java.io.DataInputStream.readInt(DataInputStream.java:392) at org.apache.hadoop.ipc.Client$IpcStreams.readResponse(Client.java:1786) at org.apache.hadoop.ipc.Client$Connection.receiveRpcResponse(Client.java:1155) at org.apache.hadoop.ipc.Client$Connection.run(Client.java:1052)2017-06-03 07:03:23,452 ERROR org.apache.hadoop.yarn.server.nodemanager.NodeManager: RECEIVED SIGNAL 15: SIGTERM2017-06-03 07:03:24,458 INFO org.apache.hadoop.ipc.Client: Retrying connect to server: hadoopmaster/192.168.31.130:8031. Already tried 0 time(s); retry policy is RetryUpToMaximumCountWithFixedSleep(maxRetries=10, sleepTime=1000 MILLISECONDS)2017-06-03 07:03:25,460 INFO org.apache.hadoop.ipc.Client: Retrying connect to server: hadoopmaster/192.168.31.130:8031. Already tried 1 time(s); retry policy is RetryUpToMaximumCountWithFixedSleep(maxRetries=10, sleepTime=1000 MILLISECONDS)2017-06-03 07:03:26,461 INFO org.apache.hadoop.ipc.Client: Retrying connect to server: hadoopmaster/192.168.31.130:8031. Already tried 2 time(s); retry policy is RetryUpToMaximumCountWithFixedSleep(maxRetries=10, sleepTime=1000 MILLISECONDS)2017-06-03 07:03:27,462 INFO org.apache.hadoop.ipc.Client: Retrying connect to server: hadoopmaster/192.168.31.130:8031. Already tried 3 time(s); retry policy is RetryUpToMaximumCountWithFixedSleep(maxRetries=10, sleepTime=1000 MILLISECONDS)更多0hadoop 是用的什么版本？ 注意：只有 hadoop 3.0 才支持“一主多从”架构。而且 hadoop 3.0 现在还只是 alpha 4版本，还不建议用于生产环境。

这篇文章主要介绍了关于如何使用NodeJS + Lighthouse + Gulp搭建自动化网站性能测试的工具，有着一定的参考价值，现在分享给大家，有需要的朋友可以参考一下假设你还不知道Lighthouse是什么Lighthouse 是Google公司旗下一个开源的、可自动化检测网站质量的工具，界面友好、操作简单、使用方式多样、视角全面，可以用它来测试任意网页，普通用户、QA、开发都可以快速上手。启动姿势难度系数 +1使用Lighthouse的方式有很多种，最简单的，可以使用 Chrome 的开发者工具，步骤如下：打开 Chrome 浏览器按F12在弹出来的窗口中打开 audits 标签点击 Perform an audit...勾选全部Run audit难度系数+2也可以使用命令行。安装Node安装Lighthouse npm install -g lighthouse在命令行中run lighthouse <url>以上两种使用方式都不是本文的重点，如果想深入了解，可参照 Run Lighthouse in DevTools难度系数+3由于最近在学习 NodeJS， 因此笔者决定使用 Node 8 + Gulp 来跑 lighthouse，为了提高结果的准确性，每次task都跑10次 lighthouse， 并且只关心结果指标中的 first-meaningful-paint 毫秒数，最终取10次的平均值，为了可视化与可读性，最终的结果以网页的形式展示，用户可在网页上看到每次执行 Lighthouse 之后 first-meaningful-paint 的毫秒数，也可以看到平均值，如果用户对某次执行的细节感兴趣，可以点击链接察看。最终的结果长这个样子：环境搭建安装 Node 8安装依赖包npm i lighthouse --save-devnpm i chrome-launcher --save-devnpm i fs-extra --save-devnpm i gulp --save-dev配置在项目根目录下创建Lighthouse的配置文件 lighthouse-config.js, 这里我们全部使用默认配置，使用默认配置需在配置文件中声明 extends: "lighthouse:default"。module.exports = { extends: "lighthouse:default"}如果读者需要了解更详细的配置选项，可参考：Lighthouse 这篇大部分内容是关于命令行的，命令行参数同样可用于Nodethrottling这篇是关于网络模拟的Default Config 具体的默认配置参数Web Page Test 模拟不同的网速Emulation 模拟不同的设备Coding在项目根目录下创建 gulpfile.js，首先引入所有依赖的工具：const gulp = require("gulp");const lighthouse = require("lighthouse");const chromeLauncher = require("chrome-launcher");const printer = require("lighthouse/lighthouse-cli/printer");const Reporter = require("lighthouse/lighthouse-core/report/report-generator");const fs = require("fs-extra");const config = require(".lighthouse-config.js");在开始使用 lighthouse 之前，首先创建一个写入文件的方法， 用于最后生成自定义的 report 文件:async function write(file, report) { try { await fs.outputFile(file, report); } catch (Error e) { console.log("error while writing report ", e); }}调用 Lighthouse 之前，我们需要首先启动一个 Chrome 的 instance ，并将端口号提供给 Lighthouse 。--headless表示不打开 browser 窗口。async function launchChrome() { let chrome; try { chrome = await chromeLauncher.launch({ chromeFlags: [ "--disable-gpu", "--no-sandbox", "--headless" ], enableExtensions: true, logLevel: "error" }); console.log(chrome.port) return { port: chrome.port, chromeFlags: [ "--headless" ], logLevel: "error" } } catch (e) { console.log("Error while launching Chrome ", e); }}Chrome 实例启动之后，我们就可以调用 Lighthouse ， 调用时，须提供需要进行性能测试的网站，参数，以及前文创建好的配置，参数包含了 Chrome 启动端口，启动方式（是否 headless 等信息）。async function lighthouseRunner(opt) { try { return await lighthouse("https://www.baidu.com", opt, config); } catch (e) { console.log("Error while running lighthouse"); }}Lighthouse 的返回结果是一个包含性能测试结果， 最终版的配置参数， 指标分组等信息的 json 对象，读者可以参考 Understanding Results 获得更深入的理解。由于这里我们需要使用 Lighthouse 官方的模板生成报告，因此调用官方提供的方法，注意第一个参数传入 result.lhr， 第二个参数声明生成 html 报告（还可以生成 csv 等格式的报告）。function genReport(result) { return Reporter.generateReport(result.lhr, "html");}下面我们写一个将上面几个方法串起来的函数，首先启动一个 Chrome 实例， 然后将 Chrome 实例的某些参数传递给 Lighthouse，使用 lighthouse 跑出来的结果生成报告，并写入 html 文件， html文件应带有时间戳和执行顺序作为唯一标识。start 方法返回结果中的first-meaningful-paint（这是我们最关心的指标，读者可根据自身需要替换，具体指标可参考 Lighthouse)。async function run(timestamp, num) { let chromeOpt = await launchChrome(); let result = await lighthouseRunner(chromeOpt); let report = genReport(result); await printer.write(report, "html", `./cases/lighthouse-report@${timestamp}-${num}.html`); return result.lhr.audits["first-meaningful-paint"].rawValue; await chrome.kill();}下面， 我们可以正式开始写一个 gulp task 啦，首先获得当前时间戳，用于最终生成的报告命名，然后声明一个数组，用于记录每次跑 Lighthouse 生成的 first-meaningful-paint 毫秒数，然后跑10次 Lighthouse， 使用提前创建的模板文件，根据这10的结果，生成一个汇总报告，这里，笔者使用了Lighthouse对外暴露的工具函数进行字符串的替换。gulp.task("start", async function() { let timestamp = Date.now(); let spent = []; for(let i=0; i<5; i++) { spent.push(await run(timestamp, i)); } let template = await fs.readFileSync("./summary/template/template.html", "utf-8"); let summary = Reporter.replaceStrings(template, [{ search: "%%TIME_SPENT%%", replacement: JSON.stringify(spent) }, { search: "%%TIMESTAMP%%", replacement: timestamp }]); write(`./summary/report/summary@${timestamp}.html`, summary)})最后的最后， 执行：gulp start万事大吉。附上汇总界面的模板源码：<!doctype html><html lang="en"><head> <meta charset="utf-8"> <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1"> <title>Lighthouse Summary Report</title> <style> body { font-family: sans-serif; } table { margin: auto; } tr { border: 1px solid grey; } h1 { text-align: center; margin: 30px auto 50px auto } </style></head><body><table> <h1>Performance Summary Report</h1> <tr> <th> Case No. </th> <th> First Meaningful Paint </th> <th> Link To Details </th> </tr> <tbody id="tableBody"> </tbody></table><script>let timespent = %%TIME_SPENT%%;let timestamp = %%TIMESTAMP%%;let tableBody = document.getElementById("tableBody");let content = "";for(let i=0; i < timespent.length; i++) { content += `<tr style="border: 1px solid grey"> <td> ${i+1} </td> <td> ${timespent[i]} </td> <td> <a href="../../cases/lighthouse-report@${timestamp}-${i}.html">View Details</a> </td> </tr>`}let total = timespent.reduce((i, j) => { return i + j;})let count = timespent.filter(function(i) { return i}).lengthcontent += `<tr><td> AVG</td><td>${total / count}</td></tr>`tableBody.innerHTML = content;</script></body></html>

groupNode.Value是一个网址形式Uri uri = new Uri( )就是把这个字符型定义为一个Uri对象GetLeftPart( )的作用是获取url中的一部分，例如：..fdska.aspx?fff=fjl&jkl=sjlk 获取到的是...fdska.aspx....index.html#main 获取到的是 ....index.html

Element一定是Node，但Node却不一定是Element。在org.w3c.dom.Node的最前面定义了一堆public static final short类型的整数，就是各种Node类型，其中只有ELEMENT_NODE才是Element类型的，其它类型有比如ATTRIBUTE_NODE，TEXT_NODE，CDATA_SECTIO.

import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import org.w3c.dom.Document; import org.w3c.dom.Node; import org.w3c.dom.NodeList; public class DomTest_02 { /** * @param args */ public...

是一个英语谚语，对牛弹琴的意思。

QQ音乐。歌曲《Up and Down》是有歌手inod演唱，在QQ音乐独家上架，QQ音乐享有独家播放权，所以到QQ音乐搜索下载即可。

ESET的安全套装为ESETSmartSecurity——ESSMcAfee的是MIS首先，2楼的说法有些过激我算是ESET的死忠～但我不喜欢用恶劣的言辞去诋毁其他的杀毒软件ESETNOD32和McAfee都是世界一线的顶级杀毒软件。各有长短！简单的对您可能关心的几个问题对比一下，具体的自己选择就好：查杀率：ESS高于MIS启发机制（即应对新型未知病毒能力）：ESS优于MIS设置复杂度：ESS比MIS简单资源占用：ESS小于MIS自我保护能力：MIS强于ESS防火墙能力防护与反泄漏能力：MIS优于ESS除杀毒与防火墙之外的其他辅助功能：MIS更加全面一些------------------------p.s.--------------------------说明几个问题：1.目前而言：敢和ESET拼启发的估计只有小红伞了～但总体评价来讲，ESET的启发还是世界级领跑的。所以McAfee的启发有所不及并不说明McAfee的启发就不强，其实McAfee的启发也是不错的。2.ESET的资源占用之小一直被不断的神话，其实ESETNOD32的资源占用方面早已没有当年傲视群雄的优势了。确实小，但绝不是最小！并且在硬件容量不断增大的今天，一般来讲，不必为了追求资源占用小而选择杀毒软件

三年多前，在 2017 年的时候， Yarn1.0 在 Facebook 的工程师的博客中被正式宣布。在首次发布仅 11 个月后，已有超过 175,000 个存储库开始使用新的包管理器。 Yarn 从那时起一直在稳步发展，成为 npm 包管理工具的替代品，但是还是会有包管理工具共有的毛病，比如速度缓慢、复杂性增加和数据占用。 相较于初始的版本，Yarn2 进行了一些根本性的更改，不仅解决了这些问题，还改进了整体工作流程。 当时流行的一个 搞笑 图在 Yarn2 中将不复存在！新的版本其实在去年一月份就（2020年）发布了，但是花了更多的时间去适配大型项目和库。 一些大公司仍在努力实现兼容性（适配Angular、React Native 和 Flow），但现在已经可以在你的代码中使用 Yarn2 了！（可惜笔者的技术栈是Vue，Yarn2 并没有适配） 即用支持并不是 Yarn 2 带来的唯一重大变化（这个概念本身不是全新的，可以追溯到 2018 年 9 月），该更新实际上提供了许多很棒的功能，让编程变得更加美好简单。 Yarn 的维护者在这些改进上投入了整整一年的时间，你绝对可以感觉到 Yarn 2 是一款经过深思熟虑的产品。 以前的 Yarn CLI 输出就像老太婆的裹脚布一样，又臭又长。而 Yarn2 从更加结构化的 CLI 输出开始，格式和颜色大大提高可读性，最重要的是，每一行都有自己的错误代码，因此变得更容易调试。 新版本显著减少了文件 I/O 数量，从而在安装过程中节省了大量的时间。 Yarn 现在包含一个单地图文件 pnp.js ，用来跟踪包引用并确保节点在运行代码后熟悉正确位置。 .yarn 文件夹会包含下载的软件包，保存在硬盘的某个位置上，那个位置是你的那些依赖项被缓存的地方。 总而言之，惹人烦的 node_modules 没有了！ 更重要的是，Yarn2 提供了详细的旧项目迁移文档，在迁移后不会丢失node_modules文件夹 ，还等什么？赶紧上 yarn 官网查看迁移文档完善你的项目吧！

如果你对 npm、yarn 全局安装路径存疑，很混乱分不清，那么这篇文章应该能帮到你。本文以 macOS 为例，不同操作系统可能略有差异。 其实在安装完 Node 之后，便有类似提示： 可以得知 Node 和 NPM 的默认安装路径是 /usr/local/bin 。如果 /usr/local/bin 路径并不存在于环境变量 PATH 中，需在配置文件中写入。比如： 具体配置文件是 ~/.bash_profile 还是 ~/.zshrc ，取决于你当前使用哪一种 Shell 解析器。 使用 which 命令可查看「可执行文件」的路径，比如： 其中 /usr/local/bin 目录下的可执行文件多是软链接，并非文件真正所在路径。 说明一下，本文将以这种方式安装的 Node 称为系统版本的 Node，用于区别使用 nvm 安装的 Node。 从 npm Docs 官方文档中，对「全局安装」如何存放文件都有比较清晰的描述（ 详看 ），翻译过来就是： 其中 prefix 是 npm 的一个配置项（ 详见 ），它的默认值与 Node 的安装位置有关。在 Unix/Linux/Mac 操作系统中，通常是 /usr/local 。在 Windows 操作系统上通常是 %AppData% pm 。其中「可执行文件」是指 package.json 中 bin 字段的配置项。 使用 npm config 命令可对 prefix 配置进行操作： 也可在配置文件 ~/.npmrc 直接进行修改（ 详见 ）。 因此， 可通过以下命令查看： 可通过 npm ls 命令查看全局安装的依赖包，个人更喜欢使用其别名 npm list ，原因是它跟 yarn list 一致。 其打印结果为树状形式，可配合 --depth=n 参数使用以查看包的依赖信息，其中 n 表示树状深度。上面的 npm list -g 相当于 npm list -g --depth=0 。 插个话，在 v2 版本有着较大的差异，比如在 v2 版本将 yarn global 移除，其替代者是 yarn dlx ，更多 请看 ，这里不展开赘述了。 yarn 全局安装路径与 npm 不同，默认情况下： 可通过以下命令查看： 若要修改以上配置，可通过 yarn config 命令处理： 需要注意的是，修改全局安装路径的配置 key 是 global-folder ，可执行文件的 key 为 prefix 。别跟 npm 混淆了。 也可以在配置文件 ~/.yarnrc 直接修改： 需要注意的是，其中 npm 配置文件使用的是 ini-formatted 格式，也就是 key=value 形式，而 yarn 则是 key "value" 形式。 我们知道 npm（Node Package Manager）是 Node 包管理工具，而 nvm（Node Version Manager）则是 Node 版本管理工具。它可以通过命令行快速安装、使用不同版本的 Node。 假设有多个项目使用了不同版本的 Node，或者需要在不同版本的 Node 下测试我们开发的 npm 包，那么使用 nvm 将会很高效。其安装不展开细说，请看 官方文档 。 第一节已经介绍了，使用「传统」的方法安装其路径如下： 但如果使用 nvm 来管理 Node，这些都将会发生变化。当使用官方指引来安装 nvm，相关内容将会默认存放至 ~/.nvm 目录。 当使用 nvm install 来安装 Node，比如： 它将会存放于 ~/.nvm/versions/node/v16.14.0 目录下。 切换 system Node 与 nvm Node，只要通过以下方式即可： 我们观察一下 prefix 的变化就知道其安装路径了： 因此，在使用 nvm 管理的情况下： 前面提到过， prefix 的默认位置与 Node 的安装路径有关。比如，在 Unix/Linux/Mac 操作系统中， prefix 通常是 Node 安装路径的上一级，也就是 ~/.nvm/versions/node/vX.X.X 目录。因此，当我们在切换 Node 版本中，它总能正确地安装到 /usr/local/lib/node_modules 或 ~/.nvm/versions/node/vX.X.X/lib/node_modules/ 目录。 但是，如果在 ~/.npmrc 中配置了 prefix ，无论你如何切换 Node 版本，它总是被安装至所配置的路径下。 这样就违背了用 nvm 的初心，自定义 prefix 配置与 nvm 不兼容。nvm 在其官方文档中用指出（ 详见 ）： 如果你此刻用着 nvm，同时没有意识到这个问题，建议立刻去检查并将其移除。 目前，我同时使用着 nvm、npm、yarn（v1）三个工具，那么平常是这样管理它们的： 基于这种原则下，全局安装的依赖包将有这些路径： 使用以下命令，可查看全局依赖包所在路径： 使用以下命令，可查看已安装的全局依赖包： 到此，本文结束。以上希望可以帮你厘清个中混淆之处。 The end.

node 项目中最臭名昭著的莫过于 node_modules 文件夹，这个糟糕的结构动辄使你的文件数目增加几万甚至几十万，无论是安装还是删除，都要消耗大量时间，并且占据大量 inode 结点，我们随便进入一个 react 项目文件夹，看一下由于有 node_modules 会使你的项目中的文件个数变成多少： 仅仅一个项目下面就有多达22万个文件。 现在我们来看一下目前的 yarn 版本号是多少： 嗯，目前 yarn 的版本号是 1.22.11 ，那我们如何安装 yarn 2 呢？答案是不需要安装，只需要设置就可以了。 设置完了之后，我们再来看一下 yarn 的版本号： 不是说好的升级到 yarn 2 吗？怎么变成 3.0 了？不用恐慌，越高越好。 然后我们来看一下项目文件夹下多了这么几个文件，首先就是根目录下多了一个 .yarnrc.yml ，里面只有一句话： 相应的，还多了一个文件夹 .yarn ，里面有一个子文件夹 releases ，里面有一个文件 yarn-berry.cjs ，这几个文件就是全部 yarn 2 增加的内容了，这些内容不要在 .gitignore 里忽略，其它的内容是需要忽略的，现在我们来在 .gitignore 里增加一些需要忽略的内容： 接下来，我们准备利用新版的 yarn 安装我们的依赖文件，在此之前，我们需要先设置一下 yarn 库的镜像服务器以加快整个下载过程： 这时候，你再打开项目根目录下的 .yarnrc.yml 文件，会发现里面多了一行： 所以我们知道其实这个 yarn config 命令也没有什么特别的地方，只是通过它来修改 .yarnrc.yml 文件而已，你也可以通过直接修改 .yarnrc.yml 文件来达到同样的效果。 现在，我们开始删除旧的 node_modules 文件夹和 yarn.lock 文件，并重建整个项目： 整个下载过程应该还是比较顺利的，我们来看一下项目文件夹中多了哪些文件： 没有了 node_modules 文件夹，我们来看一下 .yarn/cache 文件夹下有什么内容，里面有我们之前依赖的 node_modules 文件夹下的所有依赖包，但不再是以目录的形式存在，而是变成了一个个 zip 文件， yarn 2 就是利用项目根目录下的 .pnp.cjs 文件定位到这些 zip 文件以达到取代 node_modules 的作用，这样极大程度地减少了项目中的文件个数。 下面我们开始启动项目： 十有八九你的项目这时候是启动不起来的，不要慌，这篇文章告诉你所有的解决方法。 首先，你遇到错误可能是这样： 具体内容可能不一样，但你要注意这个关键词 Your application ，这说明是你的代码当中的某个位置引用了后面的插件，但你没有在 package.json 文件中显式声明它，那为什么之前用 yarn 1 或者 npm 的时候没有这个问题呢？因为以前是有 node_modules 文件夹的，所有依赖包都被平摊在这个文件夹中，即使是被其它依赖的依赖引入的，它也会被释放在 node_modules 根目录下，所以 node 可以很轻松地找到它，而现在这个文件夹没有了，我们必须显式地在 package.json 文件中引用它，才能引导 yarn 找到这个依赖项。因此，解决这种 Your application 缺乏某个依赖项的方法很简单，我们只需要用 yarn 安装它就可以了： 哦，又出错误了： 这是因为我们在安装的时候没有指定版本，导致安装的插件版本过高，我们在 package.json 里把版本降低一些： 然后重新执行 yarn 进行安装，运行 yarn start 再次启动，终于启动起来了！不过，不要高兴得太早，又遇到了这样的问题： 不要慌，既然还是 Your application 缺乏某个依赖包，那就还是我们的问题，停下来再安装它，然后再启动，直到解决完所有 Your application 引起的问题。 这时候，产生了新的错误： 虽然同样是找不到依赖项，但这次的错误不是由于我们自己的应用导致的，而是由于依赖项自身导致的，这种问题该如何解决呢？不要急，我们打开 .yarnrc.yml 文件，按照错误提示增加以下设置： 缺什么咱们就增加什么，有时候还要注意版本号。同样，这个问题不是由于 yarn 2 导致，而是因为我们的依赖项该增加的依赖没有增加而已，我们这里只是给它补全依赖，使它得以正常运行。 别忘了，每次修改完 .yarnrc.yml 之后，都需要重新执行 yarn ，然后再执行 yarn start 。 至此为止，我们的项目终于能够成功运行了！我们来看一下目前项目文件夹中的文件个数： 现在只有 17000 个文件了，比我们最开始的 22 万个文件减少了 20 多万，运行速度也成倍提升。 怎么样，是不是很值得一试呢？ 文章来源于@ 张京老师， https://segmentfault.com/a/1190000040520326

正负极是在原电池中的概念，这里的正负指的是电位的正负：电位正的为正极，发生还原反应，得电子；电位负的为负极，发生氧化反应，失电子。而阴阳极是在电解池中的概念，这里的阴阳指的是发生氧化或还原反应：发生氧化反应的为阳极，发生还原反应的为阴极。词典里anode翻译为负极，阳极，cathode翻译为正极，阴极。分别对应的是原电池和电解池。而锂离子电池体系，既是原电池（放电时）又是电解池（充电时）。通常正极（cathode）是钴酸锂，负极（anode）是石墨。这样讲在放电时一点问题都没有，可是充电时怎么描述呢？充电时石墨电极就变成阴极（cathode，发生还原反应），钴酸锂电极变成阳极（anode，发生氧化反应）。这样一来充电和放电两个过程就很难描述。所以无论是充电过程还是放电过程，为了描述的方便，我们都称为钴酸锂电极为正极（cathode），石墨电极为负极（anode）。至少我个人在描述的时候，就避免使用阴阳极。

这种小鼠具有NOD品系的遗传背景，在Prkdc基因上有点突变，造成小鼠重度联合免疫缺陷（SCID，T、B淋巴细胞都缺陷），而且具有重要免疫调节功能的IL2受体的gamma 链基因被敲除，NK细胞也失去功能，是现在被认为最好的免疫缺陷小鼠，源自Jax的称为NSG小鼠，源自日本的称为NOG小鼠

数据库内核引擎

mysql 数据库存储引擎概念知道吧？可设置的引擎有6、7种，有能力甚至可以自己开发一个出来。设置表或库的数据库引擎为 InnoDB

mysql中engine=innodb和engine=myisam的区别总结如下：1.InnoDB不支持FULLTEXT类型的索引。2.InnoDB 中不保存表的具体行数，也就是说，执行select count(*) from table时，InnoDB要扫描一遍整个表来计算有多少行，但是MyISAM只要简单的读出保存好的行数即可。注意的是，当count(*)语句包含 where条件时，两种表的操作是一样的。3.对于AUTO_INCREMENT类型的字段，InnoDB中必须包含只有该字段的索引，但是在MyISAM表中，可以和其他字段一起建立联合索引。4.DELETE FROM table时，InnoDB不会重新建立表，而是一行一行的删除。5.LOAD TABLE FROM MASTER操作对InnoDB是不起作用的，解决方法是首先把InnoDB表改成MyISAM表，导入数据后再改成InnoDB表，但是对于使用的额外的InnoDB特性（例如外键）的表不适用。另外，InnoDB表的行锁也不是绝对的，如果在执行一个SQL语句时MySQL不能确定要扫描的范围，InnoDB表同样会锁全表，例如update table set num=1 where name like “%aaa%”

使用方法是createtablexxx()engine=innodb;如果想所有建立的表格都用innodb引擎，可以把“default-storage-engine=INNODB”加到/etc/mysql/my.cnf（位置可能不同）。不过据说该设置在5.0.22下可能无效

这篇文章主要介绍了深入理解node.js http模块,现在分享给大家，也给大家做个参考。http模块主要用于搭建HTTP服务端和客户端，使用HTTP服务器或客户端功能都必须调用http模块。创建服务器var http = require(“http”);var url = require(“url”);//创建服务器//http继承自tcpvar server = http.createServer(function (req,res) { var urlstr = req.url;//获取请求的路径 var urlMethod = req.method;//获取请求的方法 var urlObj = url.parse(urlstr,true); console.log(urlObj); console.log(urlMethod); res.end(“hello”);});server.listen(8080);对请求进行处理请求分为两种：get和post，get请求url地址带参数，req.url便能获取参数，而post请求便复杂一些。使用req.on()处理post请求。post请求方式：使用req.on("data"function(){})方式读取，使用str字符串拼接，在req.on("end",function(){})读取结束后输出str便是我们想得到的post请求发送的参数；get请求方式：在请求地址上使用url.parse(req.url,true).query得到参数。var http = require("http");var fs = require("fs");var url = require("url");var querystring = require("querystring");var server = http.createServer(function (req,res) { console.log(req.method); var pathname = url.parse(req.url,true).pathname; if(pathname=="/"){ // 加载注册页面 var rs = fs.createReadStream("post.html"); rs.pipe(res); }else if(pathname=="/post"){ // 处理post请求 var str = ""; req.on("data",function (chunk) { // console.log(chunk.toString()); str += chunk; }); req.on("end",function(){ var postObj = querystring.parse(str); console.log(postObj); }) }else if(pathname=="/get"){ // get请求 var getObj = url.parse(req.url,true).query; res.write(JSON.stringify(getObj)); res.end(); }else if(pathname!="/favicon.ico"){ var rs = fs.createReadStream("."+pathname); rs.pipe(res); };});server.listen(8787);上传文件处理前端html代码如下：就不细说了。<form action=“/upimg” method=“post” enctype=“multipart/form-data”>用户名: <input type=“text” name=“user”><br> 密码: <input type=“password” name=“pass”><br>上传图片: <input type=“file” name=“file1”><br> <input type=“submit” value=“提交”></form>想要实现文件上传，要引入formidable模块var formidable = require("formidable");若是没有此模块，在终端输入 npm install formidable安装。form.parse(req,function(err,fields,fies){})方法回调函数的三个参数err:返回错误信息fields:post请求返回的字段以及对应的值fies:上传的文件对象，对象中包含文件的很多详细信息得到文件信息后，使用数据流的读和写复制文件var http = require("http");var fs = require("fs");var url = require("url");// 文件上传var formidable = require("formidable");var server = http.createServer(function(req,res){ var pathname = url.parse(req.url,true).pathname; if(pathname=="/"){ var rs = fs.createReadStream("uploads.html"); rs.pipe(res); }else if(pathname=="/uploads"){ // 实例化一个formidable类 var form = new formidable.IncomingForm(); // 调用parse方法 form.parse(req,function(err,fields,files){ if(err){ return console.log(err); }else{ // console.log("字段",fields); // 存储字段 var fieldStr = JSON.stringify(fields); fs.writeFileSync("1.txt",fieldStr); // 转存文件 if(!fs.existsSync("uploads")){ fs.mkdir("uploads"); } // 随机路径 var filePath = files.img.path; var rs = fs.createReadStream(filePath); var ws = fs.createWriteStream("./uploads/"+files.img.name); rs.pipe(ws); rs.on("data",function (chunk) { }) rs.on("end",function(){ console.log("复制成功"); res.write("上传成功"); res.end(); }) res.setHeader("Content-type","text/html;charset=utf8"); console.log("文件",files); } }) }else if(pathname!="/favicon.ico"){ var rs = fs.createReadStream("."+pathname); rs.pipe(res); }});server.listen(8880);http模拟客户端主要是options的配置，最基本的参数如下面的代码块。method:说明请求方式；host: 服务器ip，这里以本地localhost为例；port:服务器端口号；path:请求路径；此时不在使用http.createServer()创建服务器了，而是使用http.request()请求服务器，其余的都和服务器差不多了。// 通过nodejs模拟客户端var http = require("http");var options = { method:"post", host:"localhost", port:2121, path:"/"};var request = http.request(options,function (res) { var str = ""; res.on("data",function(chunk){ str += chunk; }); res.on("end",function () { console.log(str); })});var obj = { name:"李四", age:20}request.write(JSON.stringify(obj));request.end();上面是我整理给大家的，希望今后会对大家有帮助。相关文章：在vue-router中配合ElementUI如何实现导航详解解读在vue项目中引入elementUI组件在vue中实现刷新和tab切换在Vue-cli中如何实现为单独页面设置背景色有关Material在Angular2中的使用（详细教程）在 Angular中 使用Lodash方法具体该怎么做？使用原生js实现省市区三级联动

用一个表单<form method="post" enctype="multipart/form-data" action="/file-upload"> <input type="file" name="thumbnail"> <input type="submit"></form>这样就可以了

简单地说就是网络硬盘

1. 简介首先是Socket.IO的官方网站：http://socket.io官网非常简洁，甚至没有API文档，只有一个简单的“How to use”可以参考。因为Socket.IO就跟官网一样简洁好用易上手。那么Socket.IO到底是什么呢？Socket.IO是一个WebSocket库，包括了客户端的js和服务器端的nodejs，它的目标是构建可以在不同浏览器和移动设备上使用的实时应用。它会自动根据浏览器从WebSocket、AJAX长轮询、Iframe流等等各种方式中选择最佳的方式来实现网络实时应用，非常方便和人性化，而且支持的浏览器最低达IE5.5，应该可以满足绝大部分需求了。2. 安装部署2.1 安装首先安装非常简单，在node.js环境下只要一句：复制代码 代码如下:npm install socket.io2.2 结合express来构建服务器express是一个小巧的Node.js的Web应用框架，在构建HTTP服务器时经常使用到，所以直接以Socket.IO和express为例子来讲解。复制代码 代码如下:var express = require("express") , app = express() , server = require("http").createServer(app) , io = require("socket.io").listen(server);server.listen(3001);若不使用express，请参考socket.io/#how-to-use3. 基本使用方法主要分为服务器端和客户端两段代码，都非常简单。Server（app.js）：复制代码 代码如下://接上面的代码app.get("/", function (req, res) { res.sendfile(__dirname + "/index.html");});io.sockets.on("connection", function (socket) { socket.emit("news", { hello: "world" }); socket.on("other event", function (data) { console.log(data); });});首先io.sockets.on函数接受字符串"connection"作为客户端发起连接的事件，当连接成功后，调用带有socket参数的回调函数。我们在使用socket.IO的时候，基本上都在这个回调函数里面处理用户的请求。socket最关键的是emit和on两个函数，前者提交（发出）一个事件（事件名称用字符串表示），事件名称可以自定义，也有一些默认的事件名称，紧接着是一个对象，表示向该socket发送的内容；后者接收一个事件（事件名称用字符串表示），紧接着是收到事件调用的回调函数，其中data是收到的数据。在上面的例子中，我们发送了news事件和收到了other event事件，那么客户端应该会有对应的接收和发送事件。没错，客户端代码和服务器正好相反，而且非常相似。Client（client.js）复制代码 代码如下:<script src="/socket.io/socket.io.js"></script><script> var socket = io.connect("http://localhost"); socket.on("news", function (data) { console.log(data); socket.emit("other event", { my: "data" }); });</script>有两点要注意的：socket.io.js路径要写对，这个js文件实际放在了服务器端的node_modules文件夹中，在请求这个文件时会重定向，因此不要诧异服务器端不存在这个文件但为什么还能正常工作。当然，你可以把服务器端的socket.io.js这个文件拷贝到本地，使它成为客户端的js文件，这样就不用每次都向Node服务器请求这个js文件，增强稳定性。第二点是要用var socket = io.connect("网站地址或ip");来获取socket对象，接着就可以使用socket来收发事件。关于事件处理，上面的代码表示收到“news”事件后，打印收到的数据，并向服务器发送“other event”事件。注：内置默认的事件名例如“disconnect”表示客户端连接断开，“message”表示收到消息等等。自定义的事件名称，尽量不要跟Socket.IO中内置的默认事件名重名，以免造成不必要的麻烦。4. 其他常用API1).向所有客户端广播：socket.broadcast.emit("broadcast message");2).进入一个房间（非常好用！相当于一个命名空间，可以对一个特定的房间广播而不影响在其他房间或不在房间的客户端）：socket.join("your room name");3).向一个房间广播消息（发送者收不到消息）：socket.broadcast.to("your room name").emit("broadcast room message");4).向一个房间广播消息（包括发送者都能收到消息）（这个API属于io.sockets）：io.sockets.in("another room name").emit("broadcast room message");5).强制使用WebSocket通信：（客户端）socket.send("hi")，（服务器）用socket.on("message", function(data){})来接收。5. 使用Socket.IO构建一个聊天室最后，我们通过一个简单的实例来结束本篇。用Socket.IO构建一个聊天室就是50行左右的代码的事情，实时聊天效果也非常好。以下贴出关键代码：Server（socketChat.js）复制代码 代码如下://一个客户端连接的字典，当一个客户端连接到服务器时，//会产生一个唯一的socketId，该字典保存socketId到用户信息（昵称等）的映射var connectionList = {};exports.startChat = function (io) { io.sockets.on("connection", function (socket) { //客户端连接时，保存socketId和用户名 var socketId = socket.id; connectionList[socketId] = { socket: socket }; //用户进入聊天室事件，向其他在线用户广播其用户名 socket.on("join", function (data) { socket.broadcast.emit("broadcast_join", data); connectionList[socketId].username = data.username; }); //用户离开聊天室事件，向其他在线用户广播其离开 socket.on("disconnect", function () { if (connectionList[socketId].username) { socket.broadcast.emit("broadcast_quit", { username: connectionList[socketId].username }); } delete connectionList[socketId]; }); //用户发言事件，向其他在线用户广播其发言内容 socket.on("say", function (data) { socket.broadcast.emit("broadcast_say",{ username: connectionList[socketId].username, text: data.text }); }); })};Client(socketChatClient.js)复制代码 代码如下:var socket = io.connect("http://localhost");//连接服务器完毕后，马上提交一个“加入”事件，把自己的用户名告诉别人socket.emit("join", { username: "Username hehe"});//收到加入聊天室广播后，显示消息socket.on("broadcast_join", function (data) { console.log(data.username + "加入了聊天室");});//收到离开聊天室广播后，显示消息socket.on("broadcast_quit", function(data) { console.log(data.username + "离开了聊天室");});//收到别人发送的消息后，显示消息socket.on("broadcast_say", function(data) { console.log(data.username + "说: " + data.text);});//这里我们假设有一个文本框textarea和一个发送按钮.btn-send//使用jQuery绑定事件$(".btn-send").click(function(e) { //获取文本框的文本 var text = $("textarea").val(); //提交一个say事件，服务器收到就会广播 socket.emit("say", { username: "Username hehe" text: text });});

Import events modulevar events = require(;events.on(;例子创建一个名为具有以下代码main.js一个js文件; Create an eventEmitter objectvar eventEmitter = new events.emit(;eventName;eventName.js具有多个内置通过事件模块和用于将事件绑定和事件侦听; Fire the connection event eventEmitter; Fire an event eventEmitter：/.emit(：///：/.Program Ended;/, function(){console.log(;data received succesfully，如下EventEmitter类可用事件;).;);});/ Create an eventEmitter objectvar eventEmitter = new events;}。事件驱动编程Node.js大量使用事件.EventEmitter();/, connectHandler);/ Bind the connection event with the handlereventEmitter.on(;connection;, eventHandler).data received succesfully;data_received;/ Bind the data_received event with the anonymous functioneventEmitter.on(;data_received;.;);/.log(;connection succesful;connection;);console.log(Program Ended.);现在让我们试着运行上面的程序作为检查的输出：$ mnode main;);我们可以通过编程触发一个事件，如下所示;/Node JS是单线程应用程序，但它通过事件和回调概念，支持并发，这也是为何Node，声明的函数; Fire the data_received event eventEmitter;/ Create an event handler as followsvar connectHandler = function connected() {console.js是相当快相对于其他类似的技术。当Node启动其服务器，它可以简单地启动它的变量，然后简单地等待发生的事件。在事件驱动的应用中，通常主循环监听事件，然后触发回调函数时被检测到这些事件之一。尽管事件似乎类似于回调。不同之处在于如下事实; Import events modulevar events = require(;events.EventEmitter();以下为事件处理程序绑定使用事件的语法.emit(，当异步函数返回其结果的回调函数被调用的地方作为对观察者模式的事件处理。 监听事件的功能作为观察员。每当一个事件被触发，它的监听函数就开始执行。Node; Bind event and even handler as followseventEmitter：//)，每当任何任务得到完成，它触发这标志着该事件侦听器函数执行相应的事件。Node JS使用观察者模式。Node线程保持一个事件循环。 由于Node JS每一个API是异步的，作为一个单独的线程，它使用异步函数调用，以保持并发性;).js这将产生以下结果：connection succesful

最好不要删，否则不会脏成系统崩溃，但是会有一比分文件无法搜索

查看所有节点labels： 添加labels： 修改yaml配置文件： 添加nodeSelector配置，样式为[label.key]: [label.value] 修改后重启服务 参考文章： https://blog.csdn.net/lzy_zhi_yuan/article/details/106913428 nodeSelector配置相对简单，k8s提供了另外一个pod调度配置： nodeAffinity（节点亲和） ，相对于nodeSelector的简单匹配他拥有更多更加个性化的配置。 这段配置表示：该pod可以被调度到标签key为 "deploy.type" ，值为 "yztssjdxt-test" 或 "yztssjdxt" 的节点。 通过使用的语句不同，调度分成软策略(soft)和硬策略(hard) ，在软策略下，如果没有满足调度条件的节点，pod会忽略这条规则，继续完成调度。而硬策略下，pod必须部署到满足条件的节点上，如果没有满足条件的节点，就不停重试。 DuringScheduling和IgnoredDuringExecution组合生成目前主要的nodeaffinity策略 软硬策略可以组合使用 ，如下面这段配置中pod必须被调度到标签为 "deploy.type=yztssjdxt-test" 的节点。另外，在满足该条件的节点中，优先使用具有 "server=oms" 标签的节点。 nodeAffinity中nodeSelector字段下，节点满足任何一个条件即可；但更下一级matchExpressions，节点必须同时满足所有条件才能运行pod 。 如下面这段配置需要deploy.type=yztssjdxt-test、server=oms同时满足 而这段配置只需要deploy.type=yztssjdxt-test、deploy.type1=yztssjdxt满足一个即可 operator字段 ：pod与node的匹配逻辑，可选的操作符有：（我只测过in、notin） 如下方这段配置，pod将不会调度到deploy.type=yztssjdxt-test的node上

一个免费的http://nod32.xdphy.cn/

《Cyrano De Bergerac》（Rostand, Edmond）电子书网盘下载免费在线阅读资源链接：链接：https://pan.baidu.com/s/127hZ-1EwPEQqNIY5y_Nnkg 提取码：i625书名：Cyrano De Bergerac作者：Rostand, Edmond出版年份：2009-2页数：244内容简介：Tonight When I make my sweeping bow at heaven"s gate, One thing I shall still possess, at any rate, Unscathed, something outlasting mortal flesh, And that is ... My panache." The first English translation of Cyrano de Bergerac, in 1898, introduced the word panache into the English language. This single word summed up Rostand"s rejection of the social realism which dominated late nineteenth-century theatre. He wrote his heroic comedy", unfashionably, in verse, and set it in the reign of Louis XIII and the Three Musketeers. Based on the life of a little known writer, Rostand"s hero has become a figure of theatrical legend: Cyrano, with the nose of a clown and the soul of a poet, is by turns comic and sad, as reckless in love as in war, and never at a loss for words. Audiences immediately took him to their hearts, and since the triumphant opening night in December 1897 - at the height of the Dreyfus Affair - the play has never lost its appeal. The text is accompanied by notes and a full introduction which sets the play in its literary and historical context. Christopher Fry"s acclaimed translation into chiming couplets" represents the homage of one verse dramatist to another.

来个甲级院的设计师来解答，学习。

来个甲级院的设计师来解答，学习。

http://www.sygz.dqt.com.cn/yangxudong/syjc10002.htm 这里有曲目列表，你可以在百度MP3上面填写曲目就可以下载到，不过不是全全 1．阿玛丽莉(Amarilli) 卡奇尼(G．Caccini,1550-1618) 2．奥菲欧的祈祷(1nvocazione di Orfeo) 佩里(J．Peri,1561…1633) 3．让我去死亡(Lasciatemi morire) 蒙泰韦尔迪(C．Monteverdi,1567-1643) 4．嗳， 太过份(Ahi,troppo e duro) 蒙泰韦尔迪(C．Monteverdi,1567-1643)， 5．当温柔的微风(Se l"aura spira) 弗雷斯科巴迪(G．Frescobaldi,1583-1643) 6．姑娘们，快逃走(Donzelle,nlggite) 卡瓦利(P．Cavalli,1599-1676) 7．胜利啊，胜利啊(Vittoria,Vittoria!) 卡里西米(G．Carissimi,1604-1674) 8．不，不，不要期望(No,no,nonsisperi) 卡里西米(G．Carissimi,1604-1674) 9．森林啊，充满希望(Selve,voi che le speranze) 罗萨(S．Rosa,1615-1673) 10．你好久不来折磨我(Tu mancavi a tormentarmi) 切斯蒂(P．A．Cesti,1623-1669) 11．围绕着我崇拜的人儿(Intomo all"idol mio) 切斯蒂(P．A．Cesti,1623-1669) 12．残酷的爱神(Che fiero costume) 莱格伦齐(G．Legrenzi,1626-1690) 13．你别对我回避躲藏(Deh piu a me non V"ascondete) 焦·马·波龙奇尼(G．M．Bononcini,1642-1678) 14．仁慈的神明(Pieta,Signore!) 斯特拉德拉(A．Stradella,1644-1682) 15．你知道(Tu lo sai) 托雷利(G．Torelli,1650-1703) 16．啊，还给我这心灵(Ah! rendimi quel core) 罗西(F．Rossi,1650-1725) 17．安睡吧， 安眠吧(Posate,dormite) 巴萨尼(G．B．Bsssani,1657-1716) 18．恒河上升起太阳(Gia il sole dal Gange) 阿·斯卡拉蒂(A．Scarlatti,1660-1725) 19．你如果要我死亡(Se tu della mia morte) 阿·斯卡拉蒂(A．Scarlatti,1660-1725)， 20．如果弗洛林多忠诚(Se Florindo e fedele) 柯·斯卡拉蒂(A．Scarlatti,1660-1725) 21．我多么痛苦(Son tutta duolo) 阿·斯卡拉蒂(A．Scarlatti,1660-1725) 22．在我的心里(Sento nel core) 阿·斯卡拉蒂(A．Scarlatti,1660-1725)． 23．紫罗兰(Levioletta) 呵·斯卡拉蒂(A．Scarlatti,1660-1725)， 24．别再使我痛苦迷惘(O cessate di piagarmi) 阿·斯卡拉蒂(A．Scarlatti,1660-1725) 25．请告诉我(Pur dicesti》 洛蒂(A．Lotti,1667-1740) 26．可爱的圈套(Caro laccio,dolce nodo)加斯帕里尼(F．Gasparini,1668-1727) 27．不可能放弃爱情(Lasciar d"amarti) 加斯帕里尼(F．Gasparini,1668-1727) 28．虽然你冷酷无情(Sebben crudele) 卡尔达拉(A．Caldara,1670-1736) 29．爱慕你我多么容幸(Per la gloria) 焦·马，波龙奇尼(G．M．Bononcini,1642-1678) 30．圣洁的少女(Virgin, tutto amor) 杜兰泰(P．Durante,1684-1755) 31．跳吧，好姑娘(Danza,danza,fanciulla gentile) 杜兰泰(F．Durante,1684-1755) 32．找安慰，抱希望(Consolati e spera) 杜兰泰口．Durante,1684-1755) 33．让我痛哭吧(Lascia ch"io pianga) 亨德尔(G．F．Handel,1685-1759) 34．绿树成荫(Ombra mai fu) 亨德尔(G．F．Handel,1685-1759) 答案补充 你要的在这列26．可爱的圈套(Caro laccio,dolce nodo)加斯帕里尼(F．Gasparini,1668-1727) 答案补充 要的话我直接传给你 不完整的 只有30秒钟 要的话就加我QQ 答案补充 QQ190350367

很多windows10系统用户都会为卸载不了未正确安装的CorelPainter而苦恼，他们表示什么删除注册表、用360、用F8进入安全模式卸载等方式都根本解决不了问题。今天，小编就要为大家分享一个快速卸载CorelPainter的方法，希望能够帮助到所有有需要的朋友们！推荐：最新Windows10系统下载具体如下：1、先重装没有成功安装的CorelPainter2017软件，点“修复”，直到完成；2、然后双击打开UninstallTool软件，注意观察屏幕右下角向上弹出一个窗口，请移动鼠标到窗口里面，点击任意一项CorelPainter安装文件，然后就会在UT主界面中看到CP的9个文件，然后逐个右击鼠标卸载、关闭；3、完成第二步后，就可以重新安装CP了，当然如果不放心没卸载干净可以360扫描清理一下也行。4、此前之所以卸载CP2017是因为不小心关掉了注册机，其实是应该在CP安装过程中一直开着的（因为安装时最开始要算系列号，安装完成后，启动CP时要断网激活生成安装码，如果中途将注册机关掉会导致系列号无法一样而无法完成激活）。winodws10系统下快速卸载CorelPainter的方法就介绍完了。不懂得如何操作的朋友们，不妨也尝试一下！

UTRAN——U指的是UMTS（universal mobile telecommunication system）上面很详尽并且通俗易懂~