Ⅰ nodejs如何实现定时任务
1.使用node-schele在指定时间执行方法
var schele = require('node-schele');
var date = new Date(2017, 11, 16, 16, 43, 0);
var j = schele.scheleJob(date, function(){
console.log('现在时间：',new Date());
});
2.指定时间间隔执行方法 (扩展-->每秒执行就是rule.second =[0,1,2,3......59])
var rule = new schele.RecurrenceRule();
rule.second = 10;
var j = schele.scheleJob(rule, function(){
console.log('现在时间：',new Date());
});
3.每小时的固定时间
(每小时的40分钟执行)
var rule = new schele.RecurrenceRule();
rule.minute = 40;
var j = schele.scheleJob(rule, function(){
console.log("执行任务");
});
Ⅱ 如何使用nodejs搭建开发环境
1.安装NodeJS
1.编译环境
源代码编译器，通常 Unix/Linux平台都自带了C++的编译器（GCC/G++）。如果没有，请通过当前发行版的软件包安装工具安装make，g++这些编译工具。
Debian/Ubuntu下的工具是apt-get
RedHat/centOS下通过yum命令
Mac OS X下你可能需要安装xcode来获得编译器
2.网络加密
其次，如果你计划在Node.js中启用网络加密，OpenSSL的加密库也是必须的。该加密库是libssl-dev，可以通过apt-get install libssl-dev等命令安装。
3.手动编译
wget http://nodejs.org/dist/v0.10.26/node-v0.10.26.tar.gz
tar zxvf node-v0.6.1.tar.gz
cd node-v0.10.26
./configure
上面几行命令是通过wget命令下载最新版本的代码，并解压之。./configure命令将会检查环境是否符合Nodejs的编译需要。
make
make install
2.安装NPM
1.NPM的全称是Node Package Manager, 是NodeJs的第三方安装库。
curl http://npmjs.org/install.sh | sh
curl http://npmjs.org/install.sh是通过curl命令获取这个安装shell脚本，按后通过管道符| 将获取的脚本交由sh命令来执行。
2.更改第三方库
npm install underscore
[email protected] ./node_moles/underscore
由于一些特殊的网络环境，直接通过npm install命令安装第三方库的时候，经常会出现卡死的状态。幸运的是国内CNode社区的@fire9 同学利用空余时间搭建了一个镜像的NPM资源库，服务器架设在日本，可以绕过某些不必要的网络问题。你可以通过以下这条命令来安装第三方库：
npm --registry "http://npm.hacknodejs.com/
如果你想将它设为默认的资源库，运行下面这条命令即可：
npm config set registry "http://npm.hacknodejs.com/ "
通过npm安装包。安装好之後会自动被安装到 /usr/local/bin 目录下，而相依的函式库也会自动安装到 /usr/local/lib/node 目录下，实在是非常方便。
3.安装NodeJS调试环境
1.用npm命令安装全局模式的 node-inspector组件
sudo npm install -g node-inspector
2.更改端口
修改 node-inspector/lib/config.js的端口
’web-port’: {
desc: ‘Port to host the inspector’,
convert: conversions.stringToInt,
defaultValue: 6868
},
3.使用
node-inspector启动一个调试工具
在chrome浏览器中输入http://127.0.0.1:6868/debug?port=5858打开chrome的调试模式
使用node debug调试nodeJS项目
node --debug-brk=5858 read.js
可以在chrome中查看到调试信息
4.使用Sublime构建NodeJS
设置Sublime的Builder->>
Tools ->> Build System ->> New Build System
将如下代码写入
{
“cmd”: ["/usr/local/bin/node", “$file”],
“file_regex”: “^[ ]File "(…?)”, line ([0-9]*)",
“selector”: “source.javascript”
}
保存为NodeJs.sublime-build文件
如此可以直接使用Com+B来使用nodejs运行程序
Ⅲ nodejs可以接受tcp服务器的数据吗
nodejs中我们使用net模块来创建tcp服务器，tcp客户端，实现服务器与客户端之前的数据通信
创建tcp服务器
var server=net.createServer([optations],[connectionListener])
optations:{allowHalfOpen:boolean}
allowHalfOpen：false 当服务器接受到客户端发送的一个FIN包时候，会回发一个FIN包，当为true时服务器不会回FIN包，使得tcp服务器可以继续发送数据到客户端，但是不会接受客户端发送的数据，开发者必须调动end方法来关闭socket，默认是false
connectionListener：当客户端与服务器连接上了，可以触发的回调函数。
function(socket){
//.......
}
我们也可以不用回调函数来写连接上做什么处理,连接上会触发connection事件
var server=net.createServer()返回创建的tcp服务器
我们可以server.on('connection',function(socket){
})
在创建完tcp服务器我们通知服务器要监听客户端连接
server.listen(port,[host],[backlog],[callback])
port：监听的端口，为0时候tcp服务器分配一个随机的端口
host：监听的ip和主机名，省略该参数，服务器监听任何ipv4地址的客户端连接
backlog：指定等待队列中最大的客户端连接最大数量 默认511
当指定端口、ip这个时候服务器开始监听这个ip这个端口的客户端了，这个时候触发listening事件，可以指定callback参数来处理触发listening具体要做什么
我们也可以
server.on('lisening',function(){
//.......
})
创建一个tcp服务器后可以用server.address（）查看tcp服务器监听的信息
var address=server.address()
addres是一个对象
prot ：监听的端口
address：监听的ip
family：ipv4还是ipv6
我们可以使用getConnections（）查看与服务器连接的客户端的数量
server.getConnections(callback)
callback:function(err,count){
}
err:错误信息
count：为连接服务器的数量
我们也可以设置最大的连接数，超过这个数字，服务器不允许连接
server.maxConnections=2
服务器关闭
server.close([callback])
这个 方法让tcp服务器拒绝新的客户端连接，原有已经连上的客户端是不关闭的，当所有的连接服务器的客户端关闭时候，服务器默认自动关闭，触发服务器的close事件
下面我们写一个tcp服务器
var net=require("net");
opations={allowHalfOpne:false}
var server=net.createServer(opations);
server.on('connection',function(socket){
server.maxConnections=2;
console.log("服务器最大连接数为%s",server.maxConnections)
server.getConnections(function(err,count){
console.log("已经有%s个客户端连接",count)
})
console.log("%s客户端与服务器建立连接",server.address().address)
})
server.on('error',function(err){
throw err;
})
server.on('listening',function(){
console.log("服务器开始监听%j",server.address())
console.log("服务器开始监听")
})
server.listen(9966,'192.168.0.3');
setTimeout(function(){
server.close(function(){
console.log("tcp服务器关闭11111")
})
console.log("tcp服务器关闭")
},20000)
注意连接成功的时候触发的connection事件，执行的方法，参数是一个socket端口对象，这个就是服务器所监听的端口对象，所以我们socket.address().address返回给我们的是监听ip
socket端口对象
port：端口
address：ip
family：ipv4 ipv6
socket端口对象，可以读取客户端发送的流数据，每次接收到客户端发送的数据触发data事件。
接受客户端发送的消息（在连接成功的触发函数中 让server监听data事件做相应的处理）
server.on('connection',function(socket){
socket.on('data',function(data){
socket.setEncoding("utf-8");
console.log(data)
//console.log(data.toString())
})
})
bytesRead为socket端口对象监听客户端发送的数据字节数
console.log(socket.bytesRead)
当客户端关闭时候，触发socket端口对象的end事件
我们把客户端连接发送的数据保存到一个文件下
var net=require("net");
var fs=require("fs");
var server =net.createServer();
var op={
flags:"a",
encoding:"utf-8"
}
var file=fs.createWriteStream('./socket.txt',op)
server.on('connection',function(socket){
socket.on('data',function(data){
file.write(data);
})
})
server.on('listening',function(){
console.log("监听开始")
})
server.listen('1111','192.168.0.3')
以管道形式发送数据到文件
var net=require("net");
var fs=require("fs");
var server =net.createServer();
var op={
flags:"a",
encoding:"utf-8"
}
var file=fs.createWriteStream('./socket.txt',op)
server.on('connection',function(socket){
//socket.on('data',function(data){
// file.write(data);
//})
socket.pipe(file,{end:false});
socket.on("end",function(){
file.end("wanbi")
})
})
server.on('listening',function(){
console.log("监听开始")
})
server.listen('1111','192.168.0.3')
tcp客户端
创建tcp客户端
var client =new net.socket([opations])
optation:fd 一个现有的socket端口对象文件描述
type ：ipv4 、ipv6
allowHalfOpne：true、false
连接服务器
client.connect(prot,[host],[callback])
host不指定默认为本地ip
回调函数表示连接上了做什么
若没有可以socket端口对象触发connect事件
client.on("connect",function(){
})
当我们连接成功后客户端服务器端的socket端口对象有下面的属性
remoteAddress、remotePort、localAddress、localPort
socket端口对象可以写入服务器、客户端流数据
socket.write(data,[encodeing],[callback])
写入数据少时候我们直接写入缓存区，数据很多时候，缓存区满了，我们要把数据写入缓存队列中，这个时候write（data） 返回false，触发drain
我们可以用bufferSize看缓存队列中有多少个字节
socket.on("error",function(err){
})
当遇到error时候这个socket端口对象应该销毁
socket.destory()
socket.end([data],[encoding])
这个方法表示我们要关闭socket端口对象，这个不是关闭服务器的close方法，后者是关闭服务器，实现的效果是不能让客户端连接了，前者是关闭连接（socket端口对象）
当我们使用服务器的socket端口对象（连接客户端得）的end（data，encoding）方法时候，会触发客户端socket端口对象end事件
服务器：
socket.end('88');
客户端会执行下面的代码：
client.on("end",function(){
//......
})
服务器端不会退出应用程序，即使所有的客户端都断开了，这个时候我们要server.unref(),退出程序，可以用server.ref()阻止程序退出.
当socket端口对象彻底关闭时候会触发close事件，我们可以指定当端口对象关闭时候做的处理
socket.on(''close',faction(had_error){
if(had_error){}
else{}
})
socket.writtenBytes表示写了多少个字节
我们tcp服务器与客户端连接了，但是突然间有一个断电了，来不及向另一端发送关闭连接的FIN包，这样另一边这个socket端口永远处于连接状态，我们用socket.setKeepAlive([enable],[inteval])定时向另一端发送监测包，
我们实现一个服务器读一个文件的信息，当有客户单连接上，吧这个信息传给客户端，输出在控制台
服务器代码
var net=require("net");
var fs=require("fs");
var server =net.createServer();
var op={
flags:"r",
encoding:"utf-8"
}
var file=fs.createReadStream('./socket.txt',op)
server.on('connection',function(socket){
file.on('data',function(data){
socket.write(data);
})
socket.on("end",function(){
file.end("wanbi")
})
})
server.on('listening',function(){
console.log("监听开始")
})
server.listen('1111','192.168.0.3')
客户端代码
var net=require("net");
var client=new net.Socket();
client.connect(1111,'192.168.0.3')
client.on('connect',function(){
console.log("ok")
})
client.on("data",function(data){
console.log(data.toString())
})
Ⅳ 怎么自己检查NodeJS的代码是否存在内存泄漏
首先，我们检查了代码，发现所有的代码都是用new来分配内存，用delete来释放内存。那么，我们能够用一个全程替换，来替换掉所有的new和delete操作符吗？不能。因为代码的规模太大了，那样做除了浪费时间没有别的任何好处。好在我们的源代码是用C++来写成的，所以，这意味着没有必要替换掉所有的new和delete,而只用重载这两个操作符。对了，值用重载这两个操作符，我们就能在分配和释放内存之前做点什么。这是一个绝对的好消息。我们也知道该如何去做。因为，MFC也是这么做的。我们需要做的是：跟踪所有的内存分配和交互引用以及内存释放。我们的源代码使用Visual C++写成，当然这种解决方法也可以很轻松的使用在别的C++代码里面。要做的第一件事情是重载new和delete操作符，它们将会在所有的代码中被使用到。我们在stdafx.h中，加入：
#ifdef _DEBUG
inline void * __cdecl operator new(unsigned int size,
const char *file, int line)
{
};
inline void __cdecl operator delete(void *p)
{
};
#endif
Ⅳ nodejs 项目如何发布
Eclipse开发环境搭建前提条件：1）Node.js已安装ok，环境变量已配置，可以使用node -v来校验是否安装和配置成功（打开cmd命令窗口，输入node -v，如果正确安装正确，则会输出安装的Node.js版本号）；成功了以后，在命令窗口下执行命令： npm -v ，若Node.js安装成功的话，npm也是安装成功的，因为Node.js已经自带npm。
2）Eclipse已安装ok。
搭建步骤：
1. Eclipse插件：
NodeJS的插件：http://www.nodeclipse.org/updates/
VJET编辑提示插件：http://download.eclipse.org/vjet/updates-0.10
Google开发插件：http://chromedevtools.googlecode.com/svn/update/dev/
采用Eclipse插件的通用安装方式即可（Eclipse》Help》install new software）
2. 安装supervisor
因为 Node.js 只有在第一次引用到某部份时才会去解析脚本文件，以后都会直接访问内存，避免重复载入，这种设计虽然有利于提高性能，却不利于开发调试，因为我们在开发过程中总是希望修改后立即看到效果，而不是每次都要终止进程并重启。 supervisor 可以帮助你实现这个功能，它会监视你对代码的改动，并自动重启 Node.js 。
安装方式：打开cmd命令窗口，输入npm install -g supervisor即可。
运行方式：supervisor XX.js。如下：
E:\tech\nodejs\microblog>supervisorapp.js
DEBUG: Runningnode-supervisor with
DEBUG: program 'app.js'
DEBUG: --watch '.'
DEBUG: --ignore 'undefined'
DEBUG: --extensions 'node|js'
DEBUG: --exec 'node'
DEBUG: Starting child process with 'node app.js'
DEBUG: Watching directory 'E:\tech\nodejs\microblog' for changes.
HTTP server islistening at port 3000.
3. 安装Express
Express是目前最稳定、使用最广泛，而且是Node.js官 方推荐的唯一一个 Web 开发框架。
安装方式：打开cmd命令窗口，输入npm install -g express 即可。
校验是否安装成功命令：express –V，会输出版本号。
4. 新建Node工程。
1) New》Node Project，命名为helloworld。
2) 打开 cmd 切换到helloworld 目录的上级目录，输入 express -e ejs helloworld（注意 express 3.* 中安装 ejs 不再是 -t 而是 -e）。
3) 切换到helloworld目录下，输入npm install 安装所需模块，
……
4) 刷新Eclipse中的工程，看到效果如下图所示：
5. 配置Eclipse的Nodeeclipse属性。
选择Windows》Preferences》Nodeeclipse，
NodePath：选择supervisor的路径，默认在npm下，注意，此处一定要选择supervisor的路径，如果选择Node.exe的路径，则修改代码后不会自动生效。
ExpressPath:选择Express的路径，默认在npm下。
6. 运行
选择启动的js，Run as》Node Application即可
7. 验证自动生效
在浏览器中输入http://localhost:3000，显示如下图。
Ⅵ nodejs new promise能保证顺序吗
Promise.reject的流程大概是这样的： 1. Let C be the this value. 2. Let promiseCapability be NewPromiseCapability(C). 3. ReturnIfAbrupt(promiseCapability). 4. Let rejectResult be the result of calling the [[Call]] internal method...
Ⅶ nodejs中如何查看Array有哪些方法
while (rs.next()) {
Bars bar = new Bars();
bar.setId(rs.getLong("id"));
bar.setName(rs.getString("name"));
bar.setType(rs.getInt("type"));
bar.setCreatorId(rs.getLong("creator_id"));
resultList.add(bar);
}
Ⅷ nodejs删除安卓手机指定文件
nodejs删除安卓手机指定文件
* 删除目录下 指定 文件方法
* 参数： dir 文件夹名称
* fs.stat => 判断是文件还是文件夹
* fs.unlink => 删除文件
* fs.readdir => 读取文件夹内容
*/
const fs = require('fs')
const path = require('path')
const deleteFiles = function (dir) {
fs.readdir(dir, function (err, files) {
files.forEach(function (filename) {
var src = path.join(dir, filename)
fs.stat(src, function (err, st) {
if (err) {
throw err
}
// 判断是否为文件
if (st.isFile()) {
// 这里可以使用正则，也可以使用其他方法，比如字符串处理等，/\.d\.ts$/
if (/\.we$/.test(filename)) {
fs.unlink(src, err => {
if (err) throw err
console.log('成功删除：' + src)
})
}
} else {
// 递归文件夹
deleteFiles(src)
}
})
})
})
}
deleteFiles('./')
复制代码
修改文件名称
复制代码
fs = require('fs') // 引用文件系统模块
const PATH = `./src/` // 当前文件夹
const readFileList = function (path, filesList) {
filesList = filesList || []
let files = fs.readdirSync(path)
files.forEach(function (filename, index) {
// const stat = fs.statSync(path + filename); //读取的文件信息
// isDirectory 判断是不是目录
if (fs.statSync(path + filename).isDirectory()) {
// 递归读取文件
readFileList(`${path}${filename}/`, filesList)
} else {
filesList.push({
path, // 路径
filename // 名字
})
}
})
return filesList
}
// 修改文件名称
const rename = function (oldPath, newPath, filename, newSuffixFile) {
fs.rename(oldPath, newPath, function (err) {
if (err) {
throw err
}
console.log(`${filename} 修改为 => ${newSuffixFile}`)
})
}
// 批量修改文件名称
const getChangeFiles = function (path, oldSuffix, newSuffix) {
if (!oldSuffix && !newSuffix) {
console.log(`后缀未设置`)
}
this.readFileList(path).forEach(item => {
if (item.filename.indexOf(oldSuffix) > -1) {
console.log(item.filename)
let oldPath = item.path + item.filename,
newSuffixFile = item.filename.split(oldSuffix)[0] + newSuffix,
newPath = item.path + newSuffixFile
rename(oldPath, newPath, item.filename, newSuffixFile)
}
})
}
getChangeFiles(PATH, `.we`, `.js`)
// 引入fs文件处理模块
const fs = require('fs')
// 现在我们要关心的是‘icons‘文件夹
// 我们不妨用变量表示这个文件夹名称，方便日后维护和管理
const src = 'dist'
// API文档中中找到遍历文件夹的API
// 找到了，是fs.readdir(path, callback)
// 文档中有叙述：
// 读取 path 路径所在目录的内容。 回调函数 (callback) 接受两个参数 (err, files) 其中 files 是一个存储目录中所包含的文件名称的数组
// 因此：
fs.readdir(src, function (err, files) {
// files是名称数组，因此
// 可以使用forEach遍历哈, 此处为ES5 JS一点知识
// 如果不清楚，也可以使用for循环哈
files.forEach(function (filename) {
// 下面就是文件名称重命名
// API文档中找到重命名的API，如下
// fs.rename(oldPath, newPath, callback)
// 下面，我们就可以依葫芦画瓢，确定新旧文件名称：
const oldPath = src + '/' + filename
// newPath = src + ‘/‘ + filename.replace(/_/g, ‘-‘);
const newPath = src + '/' + 'index.html'
if (filename === 'Homepad.html') {
// 重命名走起
fs.rename(oldPath, newPath, function (err) {
if (!err) {
console.log(filename + '重命名成功!')
}
})
}
})
})
复制代码
Ⅸ 什么是 nodejs 事件循环
Node JS是单线程应用程序，但它通过事件和回调概念，支持并发。 由于Node
JS每一个是异步的，作为一个单独的线程，它使用异步函数调用，以保持并发性。Node
JS使用观察者模式。Node线程保持一个事件循环，每当任何任务得到完成，它触发这标志着该事件侦听器函数执行相应的事件。
事件驱动编程
Node.js大量使用事件，这也是为何Node.js是相当快相对于其他类似的技术。当Node启动其服务器，它可以简单地启动它的变量，声明的函数，然后简单地等待发生的事件。
在事件驱动的应用中，通常主循环监听事件，然后触发回调函数时被检测到这些事件之一。
尽管事件似乎类似于回调。不同之处在于如下事实，当异步函数返回其结果的回调函数被调用的地方作为对观察者模式的事件处理。
监听事件的功能作为观察员。每当一个事件被触发，它的监听函数就开始执行。Node.js具有多个内置通过事件模块和用于将事件绑定和事件侦听，如下
EventEmitter类可用事件：
// Import events mole
var events = require('events');
// Create an eventEmitter object
var eventEmitter = new events.EventEmitter();
以下为事件处理程序绑定使用事件的语法：
// Bind event and even handler as follows
eventEmitter.on('eventName', eventHandler);
我们可以通过编程触发一个事件，如下所示：
// Fire an event
eventEmitter.emit('eventName');
例子
创建一个名为具有以下代码main.js一个js文件：
// Import events mole
var events = require('events');
// Create an eventEmitter object
var eventEmitter = new events.EventEmitter();
// Create an event handler as follows
var connectHandler = function connected() {
console.log('connection succesful.');
// Fire the data_received event
eventEmitter.emit('data_received');
}
// Bind the connection event with the handler
eventEmitter.on('connection', connectHandler);
// Bind the data_received event with the anonymous function
eventEmitter.on('data_received', function(){
console.log('data received succesfully.');
});
// Fire the connection event
eventEmitter.emit('connection');
console.log("Program Ended.");
现在让我们试着运行上面的程序作为检查的输出：
$ mnode main.js
这将产生以下结果：
connection succesful.
data received succesfully.
Program Ended.
Ⅹ nodejs 怎么下载远程文件并该名称
nodejs对文件的读写还是相当灵活的，可以根据不同的场景来选择不同的方法。
一.直接操作文件
最简单的两个fs.readFile和fs.writeFile
举例：这个程序的功能是将一个比较大json格式的文件转换成你想自己要格式的文件。
var fs = require('fs');
fs.readFile('./json.json',function(err,data){
if(err) throw err;
var jsonObj = JSON.parse(data);
var space = ' ';
var newLine = '\n';
var chunks = [];
var length = 0;
for(var i=0,size=jsonObj.length;i<size;i++){
var one = jsonObj[i];
//what value you want
var value1 = one['value1'];
var value2 = one['value2'];
....
var value = value1 +space+value2+space+.....+newLine;
var buffer = new Buffer(value);
chunks.push(buffer);
length += buffer.length;
}
var resultBuffer = new Buffer(length);
for(var i=0,size=chunks.length,pos=0;i<size;i++){
chunks[i].(resultBuffer,pos);
pos += chunks[i].length;
}
fs.writeFile('./resut.text',resultBuffer,function(err){
if(err) throw err;
console.log('has finished');
});
});
它的原理是将文件数据一次性全部读入内存，优点就是接下来都是在内存的操作，速度会很快。但缺点也很明显，就是当文件非常大时，会造成内存溢出。
二. 使用文件流
2.1 读取文件，api相见：fs.createReadSream 和 fs.createWriterStream
以下代码实现的功能就是通过文件流来实现图片的复制：
var fs = require('fs');
var rOption = {
flags : 'r',
encoding : null,
mode : 0666
}
var wOption = {
flags: 'a',
encoding: null,
mode: 0666
}
var fileReadStream = fs.createReadStream('./myjpg.jpg',rOption);
var fileWriteStream = fs.createWriteStream('./new_myjpg.jpg',wOption);
fileReadStream.on('data',function(data){
fileWriteStream.write(data);
});
fileReadStream.on('end',function(){
console.log('readStream end');
fileWriteStream.end();
});