Ⅰ 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();
});