API热搜榜单(2018.07.17-2018.08.17)
API 热度
#1 fs.readFile(path[, options], callback) 2082
#2 http.createServer([options][, requestListener]) 1585
#3 fs.writeFile(file, data[, options], callback) 1488
#4 fs.Stats 1398
#5 path.resolve([...paths]) 1383
#6 http.request(options[, callback]) 1351
#7 process.env 1217
#8 child_process.exec(command[, options][, callback]) 1194
#9 path.join([...paths]) 1172
#10 fs.readFileSync(path[, options]) 1156
#11 fs.stat(path[, options], callback) 1114
#12 http.Server 1104
#13 http.ClientRequest 1093
#14 child_process.spawn(command[, args][, options]) 1021
#15 fs.existsSync(path) 1013
#16 fs.ReadStream 923
#17 __dirname 896
#18 fs.createReadStream(path[, options]) 876
#19 http.get(options[, callback]) 836
#20 fs.readdir(path[, options], callback) 827
#21 fs.WriteStream 807
#22 http.IncomingMessage 798
#23 fs.writeFileSync(file, data[, options]) 777
#24 fs.createWriteStream(path[, options]) 763
#25 path.dirname(path) 751
#26 url.parse(urlString[, parseQueryString[, slashesDenoteHost]]) 750
#27 path.basename(path[, ext]) 748
#28 fs.readdirSync(path[, options]) 653
#29 stream.Readable 645
#30 EventEmitter 645
#31 Buffer.alloc(size[, fill[, encoding]]) 622
#32 http.Agent 556
#33 net.Socket 551
#34 new assert.AssertionError(options) 548
#35 require() 545
#36 process.argv 544
#37 fs.access(path[, mode], callback) 537
#38 http.ServerResponse 532
#39 Buffer 517
#40 fs.open(path, flags[, mode], callback) 511
#41 fs.mkdir(path[, mode], callback) 503
#42 stream.Writable 502
#43 Buffer.from(array) 499
#44 path.extname(path) 494
#45 server.listen() 492
#46 exports shortcut 483
#47 URL 479
#48 fs.exists(path, callback) 471
#49 net.Server 471
#50 server.listen() 469
#51 https.request(options[, callback]) 461
#52 exports 453
#53 fs.write(fd, buffer[, offset[, length[, position]]], callback) 443
#54 process.cwd() 437
#55 child_process.fork(modulePath[, args][, options]) 435
#56 module.exports 419
#57 net.createServer([options][, connectionListener]) 418
#58 new Agent([options]) 414
#59 child_process.execSync(command[, options]) 409
#60 fs.read(fd, buffer, offset, length, position, callback) 409
#61 path.parse(path) 405
#62 response.writeHead(statusCode[, statusMessage][, headers]) 404
#63 Buffer.from(string[, encoding]) 378
#64 fs.unlink(path, callback) 374
#65 new Buffer(array) 368
#66 stats.isDirectory() 364
#67 fs.mkdirSync(path[, mode]) 359
#68 readable.pipe(destination[, options]) 358
#69 fs.appendFile(path, data[, options], callback) 354
#70 buf.toString([encoding[, start[, end]]]) 354
#71 response.end([data][, encoding][, callback]) 352
#72 fs.statSync(path[, options]) 335
#73 process.stdout 334
#74 util.promisify(original) 328
#75 new Console(stdout[, stderr][, ignoreErrors]) 327
#76 Buffer.concat(list[, totalLength]) 312
#77 fs.FSWatcher 312
#78 util.inspect(object[, options]) 312
#79 child_process.execFile(file[, args][, options][, callback]) 306
#80 querystring.parse(str[, sep[, eq[, options]]]) 305
#81 fs.rename(oldPath, newPath, callback) 292
#82 path.relative(from, to) 286
#83 fs.watch(filename[, options][, listener]) 284
#84 https.get(options[, callback]) 279
#85 process.stdin 276
#86 stats.isFile() 275
#87 path.normalize(path) 261
#88 net.createConnection() 260
#89 request.end([data[, encoding]][, callback]) 260
#90 global 256
#91 path.posix 254
#92 setImmediate(callback[, ...args]) 246
#93 agent.requests 246
#94 fs.copyFile(src, dest[, flags], callback) 244
#95 response.write(chunk[, encoding][, callback]) 234
#96 response.setHeader(name, value) 231
#97 path.sep 228
#98 os.EOL 228
#99 process.exit([code]) 226
#100 fs.unlinkSync(path) 223
#101 util.format(format[, ...args]) 221
#102 request.abort() 215
#103 emitter.on(eventName, listener) 215
#104 child_process.spawnSync(command[, args][, options]) 212
#105 ChildProcess 211
#106 assert(value[, message]) 210
#107 fs.rmdir(path, callback) 209
#108 crypto.createHash(algorithm[, options]) 207
#109 fs.openSync(path, flags[, mode]) 199
#110 options.stdio 197
#111 util.inherits(constructor, superConstructor) 194
#112 https.createServer([options][, requestListener]) 192
#113 buf.slice([start[, end]]) 190
#114 message.headers 188
#115 console.log([data][, ...args]) 187
#116 Buffer.from(buffer) 184
#117 fs.write(fd, string[, position[, encoding]], callback) 181
#118 emitter.emit(eventName[, ...args]) 178
#119 request.setHeader(name, value) 178
#120 url.pathname 178
#121 __filename 177
#122 util.callbackify(original) 176
#123 fs.accessSync(path[, mode]) 175
#124 querystring.escape(str) 171
#125 path.format(pathObject) 170
#126 querystring.stringify(obj[, sep[, eq[, options]]]) 170
#127 process.nextTick(callback[, ...args]) 170
#128 setInterval(callback, delay[, ...args]) 165
#129 buf.write(string[, offset[, length]][, encoding]) 165
#130 new net.Socket([options]) 164
#131 https.Agent 162
#132 path.delimiter 161
#133 Hash 160
#134 fs.copyFileSync(src, dest[, flags]) 160
#135 buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]]) 160
#136 dns.Resolver 159
#137 fs.watchFile(filename[, options], listener) 156
#138 request.write(chunk[, encoding][, callback]) 155
#139 assert.strictEqual(actual, expected[, message]) 154
#140 Buffer.allocUnsafe(size) 153
#141 fs.readSync(fd, buffer, offset, length, position) 153
#142 fs.appendFileSync(path, data[, options]) 152
#143 URLSearchParams 151
#144 -r, --require module 149
#145 assert.deepEqual(actual, expected[, message]) 149
#146 setTimeout(callback, delay[, ...args]) 148
#147 Buffer.byteLength(string[, encoding]) 147
#148 new net.Server([options][, connectionListener]) 144
#149 socket.write(data[, encoding][, callback]) 142
#150 hash.digest([encoding]) 141
#151 url.hash 140
#152 writable.write(chunk[, encoding][, callback]) 140
#153 fs.fstatSync(fd[, options]) 139
#154 os.cpus() 136
#155 Console 136
#156 new Buffer(string[, encoding]) 133
#157 fs.fstat(fd[, options], callback) 133
#158 child_process.execFileSync(file[, args][, options]) 133
#159 buf.toJSON() 133
#160 crypto.createCipheriv(algorithm, key, iv[, options]) 131
#161 os.networkInterfaces() 129
#162 process.execPath 128
#163 emitter.addListener(eventName, listener) 127
#164 socket.connect() 124
#165 v8.cachedDataVersionTag() 124
#166 fs.rmdirSync(path) 121
#167 net.connect() 120
#168 fs.lstat(path[, options], callback) 120
#169 http.METHODS 119
#170 fs.renameSync(oldPath, newPath) 119
#171 response.statusCode 115
#172 fs.close(fd, callback) 115
#173 assert.equal(actual, expected[, message]) 114
#174 request.getHeader(name) 114
#175 subprocess.send(message[, sendHandle[, options]][, callback]) 113
#176 new URL(input[, base]) 110
#177 buf.length 110
#178 url.format(urlObject) 109
#179 net.createConnection(options[, connectListener]) 108
#180 new Error(message) 106
#181 fs.writeSync(fd, buffer[, offset[, length[, position]]]) 106
#182 request.connection 104
#183 stream.Duplex 103
#184 agent.createConnection(options[, callback]) 103
#185 buf.fill(value[, offset[, end]][, encoding]) 102
#186 subprocess.kill([signal]) 102
#187 path.isAbsolute(path) 101
#188 process.platform 101
#189 os.platform() 100
#190 crypto.createDecipheriv(algorithm, key, iv[, options]) 100
#191 urlObject.query 99
#192 Cipher 97
#193 assert.deepStrictEqual(actual, expected[, message]) 97
#194 NODE_PATH=path[:…] 97
#195 stats.size 96
#196 process.argv0 95
#197 promiseResolve(asyncId) 94
#198 Buffer.from(arrayBuffer[, byteOffset[, length]]) 94
#199 process.abort() 93
#200 https.Server 93
#201 console.clear() 92
#202 assert.ok(value[, message]) 92
#203 dgram.Socket 90
#204 socket.end([data][, encoding]) 90
#205 url.resolve(from, to) 89
#206 emitter.listenerCount(eventName) 88
#207 os.homedir() 87
#208 clearImmediate(immediate) 86
#209 process.send(message[, sendHandle[, options]][, callback]) 86
#210 message.url 86
#211 process.execArgv 85
#212 os.tmpdir() 84
#213 subprocess.stdout 84
#214 server.close([callback]) 82
#215 url.host 82
#216 zlib.Gzip 82
#217 readable.read([size]) 82
#218 Immediate 81
#219 dns.lookup(hostname[, options], callback) 81
#220 process.kill(pid[, signal]) 81
#221 emitter.once(eventName, listener) 81
#222 process.arch 81
#223 fs.lstatSync(path[, options]) 81
#224 url.search 80
#225 Worker 80
#226 stream.Transform 78
#227 hash.update(data[, inputEncoding]) 78
#228 readline.createInterface(options) 78
#229 request.setTimeout(timeout[, callback]) 78
#230 fs.writeSync(fd, string[, position[, encoding]]) 77
#231 path.win32 77
#232 error.code 76
#233 url.toJSON() 76
#234 process.pid 76
#235 process.chdir(directory) 75
#236 subprocess.stdin 75
#237 request.socket 75
#238 stream.pipeline(...streams[, callback]) 75
#239 socket.destroy([exception]) 74
#240 console.time([label]) 74
#241 emitter.setMaxListeners(n) 74
#242 Buffer.compare(buf1, buf2) 73
#243 fs.realpathSync(path[, options]) 73
#244 dns.getServers() 72
#245 response.sendDate 72
#246 url.format(URL[, options]) 72
#247 emitter.removeListener(eventName, listener) 71
#248 crypto.createCipher(algorithm, password[, options]) 71
#249 readStream.path 71
#250 console.error([data][, ...args]) 71
#251 net.createConnection(port[, host][, connectListener]) 70
#252 TypeError 70
#253 cipher.update(data[, inputEncoding][, outputEncoding]) 70
#254 buf.values() 69
#255 cluster.fork([env]) 69
#256 url.href 69
#257 Error 69
#258 readline.clearLine(stream, dir) 68
#259 Buffer.poolSize 67
#260 fs.link(existingPath, newPath, callback) 67
#261 socket.setTimeout(timeout[, callback]) 67
#262 buf.buffer 66
#263 cipher.final([outputEncoding]) 66
#264 server.listen(handle[, backlog][, callback]) 66
#265 assert.throws(block[, error][, message]) 66
#266 process.memoryUsage() 65
#267 url.searchParams 65
#268 request.url 64
#269 readStream.bytesRead 63
#270 buf[index] 63
#271 assert.doesNotReject(block[, error][, message]) 61
#272 fsPromises.readFile(path[, options]) 61
#273 os.arch() 61
#274 server.address() 61
#275 clearInterval(timeout) 61
#276 Buffer.isBuffer(obj) 61
#277 socket.address() 61
#278 new crypto.Certificate() 60
#279 querystring.unescape(str) 60
#280 buf.readInt8(offset) 60
#281 dns.resolve(hostname[, rrtype], callback) 60
#282 crypto.createHmac(algorithm, key[, options]) 59
#283 stats.isBlockDevice() 59
#284 ERR_HTTP_HEADERS_SENT 59
#285 Buffer.allocUnsafeSlow(size) 58
#286 Buffer.isEncoding(encoding) 58
#287 os.hostname() 58
#288 process.stderr 58
#289 server.getConnections(callback) 58
#290 zlib.createGzip([options]) 57
#291 buffer.constants.MAX_LENGTH 57
#292 url.toString() 57
#293 writable.end([chunk][, encoding][, callback]) 57
#294 fs.closeSync(fd) 57
#295 server.close([callback]) 57
#296 socket.setKeepAlive([enable][, initialDelay]) 56
#297 fs.chmod(path, mode, callback) 56
#298 require.cache 56
#299 assert.fail([message]) 55
#300 emitter.off(eventName, listener) 55
#301 socket.connect(options[, connectListener]) 55
#302 options.detached 55
#303 socket.send(msg, [offset, length,] port [, address] [, callback]) 55
#304 crypto.randomBytes(size[, callback]) 55
#305 util.debuglog(section) 55
#306 new Console(options) 54
#307 process.config 54
#308 EventEmitter.listenerCount(emitter, eventName) 54
#309 require.resolve(request[, options]) 53
#310 process.exitCode 53
#311 new Buffer(size) 52
#312 Buffer.from(object[, offsetOrEncoding[, length]]) 52
#313 server.listen() 52
#314 http.globalAgent 51
#315 zlib.Unzip 51
#316 fs.realpath(path[, options], callback) 50
#317 fs.readlink(path[, options], callback) 50
#318 Hmac 50
#319 clearTimeout(timeout) 50
#320 buf.indexOf(value[, byteOffset][, encoding]) 49
#321 immediate.ref() 49
#322 buf.readDoubleBE(offset) 49
#323 writable.cork() 48
#324 console.debug(data[, ...args]) 47
#325 EventEmitter.defaultMaxListeners 47
#326 readable.resume() 46
#327 socket.setEncoding([encoding]) 46
#328 socket.address() 46
#329 message.method 45
#330 console.assert(value[, ...message]) 45
#331 os.freemem() 45
#332 fsPromises.readdir(path[, options]) 45
#333 tls.createServer([options][, secureConnectionListener]) 44
#334 buf.readUInt8(offset) 44
#335 emitter.removeAllListeners([eventName]) 44
#336 Certificate 43
#337 new Buffer(arrayBuffer[, byteOffset[, length]]) 43
#338 buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]]) 43
#339 console.dir(obj[, options]) 43
#340 zlib.Gunzip 43
#341 Interface 43
#342 os.type() 43
#343 url.hostname 42
#344 socket.connect(port[, host][, connectListener]) 42
#345 writeStream.path 42
#346 server.connections 42
#347 fsPromises.writeFile(file, data[, options]) 42
#348 emitter.listeners(eventName) 41
#349 os.loadavg() 41
#350 response.socket 41
#351 buf.writeUInt8(value, offset) 41
#352 server.listening 41
#353 readable.push(chunk[, encoding]) 40
#354 process.version 40
#355 UV_THREADPOOL_SIZE=size 40
#356 error.stack 40
#357 Decipher 39
#358 resolver.cancel() 39
#359 worker.send(message[, sendHandle][, callback]) 39
#360 Sign 39
#361 rl.prompt([preserveCursor]) 39
#362 fs.constants 39
#363 socket.bind([port][, address][, callback]) 38
#364 dgram.createSocket(options[, callback]) 38
#365 response.getHeaders() 38
#366 require.main 38
#367 socket.remoteAddress 38
#368 stats.isFIFO() 38
#369 zlib.Deflate 38
#370 assert.doesNotThrow(block[, error][, message]) 38
#371 response.addTrailers(headers) 38
#372 rl.question(query, callback) 38
#373 Certificate.exportChallenge(spkac) 37
#374 rl.close() 37
#375 agent.destroy() 37
#376 server.setTimeout([msecs][, callback]) 37
#377 stream.PassThrough 37
#378 socket.resume() 36
#379 os.userInfo([options]) 36
#380 subprocess.channel 36
#381 decipher.update(data[, inputEncoding][, outputEncoding]) 36
#382 writeStream.bytesWritten 36
#383 assert.fail(actual, expected[, message[, operator[, stackStartFunction]]]) 35
#384 buf.entries() 35
#385 readable.setEncoding(encoding) 35
#386 fsPromises.access(path[, mode]) 35
#387 Timeout 35
#388 socket.addMembership(multicastAddress[, multicastInterface]) 34
#389 Error.captureStackTrace(targetObject[, constructorOpt]) 34
#390 url.origin 34
#391 buf.writeInt8(value, offset) 34
#392 writable._write(chunk, encoding, callback) 34
#393 subprocess.killed 34
#394 agent.sockets 34
#395 socket.destroyed 34
#396 async_hooks.createHook(callbacks) 34
#397 console.table(tabularData[, properties]) 33
#398 process.cpuUsage([previousValue]) 33
#399 console.info([data][, ...args]) 33
#400 http.STATUS_CODES 33
#401 buf.swap16() 32
#402 assert.ifError(value) 32
#403 timeout.ref() 32
#404 dns.lookupService(address, port, callback) 32
#405 emitter.eventNames() 32
#406 --experimental-repl-await 32
#407 socket.connecting 32
#408 cluster.setupMaster([settings]) 32
#409 watcher.close() 31
#410 buf.equals(otherBuffer) 31
#411 buf.readInt16BE(offset) 31
#412 socket.bufferSize 31
#413 process.title 31
#414 socket.pause() 31
#415 crypto.createSign(algorithm[, options]) 31
#416 decipher.final([outputEncoding]) 30
#417 NODE_DEBUG=module[,…] 30
#418 request.aborted 30
#419 dns.resolve4(hostname[, options], callback) 30
#420 net.connect(options[, connectListener]) 30
#421 console.trace([message][, ...args]) 30
#422 cluster.isMaster 30
#423 fsPromises.mkdir(path[, mode]) 29
#424 session.post(method[, params][, callback]) 29
#425 server.timeout 29
#426 error.message 29
#427 url.port 29
#428 buf.byteOffset 29
#429 console.count([label]) 28
#430 assert.rejects(block[, error][, message]) 28
#431 server.listen(options[, callback]) 28
#432 tls.connect(options[, callback]) 28
#433 buf.keys() 28
#434 subprocess.disconnect() 28
#435 os.constants 28
#436 fs.unwatchFile(filename[, listener]) 28
#437 socket.close([callback]) 28
#438 buf.writeInt16BE(value, offset) 28
#439 Domain 28
#440 response.getHeader(name) 28
#441 buf.readInt32BE(offset) 28
#442 server.close([callback]) 28
#443 os.totalmem() 28
#444 new stream.Transform([options]) 27
#445 fs.fsync(fd, callback) 27
#446 server.listen([port[, host[, backlog]]][, callback]) 27
#447 os.release() 27
#448 os.uptime() 27
#449 path.toNamespacedPath(path) 27
#450 readable.pause() 26
#451 tls.createSecureContext(options) 26
#452 error.path 26
#453 crypto.createDecipher(algorithm, password[, options]) 26
#454 cluster.workers 26
#455 response.connection 26
#456 util.isArray(object) 26
#457 stats.mtime 26
#458 process.hrtime([time]) 26
#459 subprocess.stdio 26
#460 new Buffer(buffer) 26
#461 fs.mkdtemp(prefix[, options], callback) 26
#462 stats.dev 25
#463 fs.fchmod(fd, mode, callback) 25
#464 util.inspect.custom 25
#465 subprocess.stderr 25
#466 fs.chown(path, uid, gid, callback) 25
#467 hmac.digest([encoding]) 25
#468 buf.writeInt32BE(value, offset) 25
#469 textEncoder.encode([input]) 25
#470 cluster.worker 25
#471 url.protocol 25
#472 filehandle.readFile(options) 25
#473 response.finished 24
#474 request.flushHeaders() 24
#475 Options 24
#476 subprocess.pid 24
#477 server.listen(path[, backlog][, callback]) 24
#478 crypto.constants 24
#479 worker.process 24
#480 assert.notDeepEqual(actual, expected[, message]) 24
#481 emitter.rawListeners(eventName) 24
#482 response.writeContinue() 24
#483 stats.mode 24
#484 process.channel 24
#485 sign.sign(privateKey[, outputFormat]) 24
#486 buf.readUInt16BE(offset) 23
#487 buf.includes(value[, byteOffset][, encoding]) 23
#488 module.require(id) 23
#489 emitter.prependListener(eventName, listener) 23
#490 fs.truncate(path[, len], callback) 23
#491 readable._read(size) 23
#492 process.uptime() 23
#493 net.connect(port[, host][, connectListener]) 23
#494 subprocess.connected 23
#495 fs.symlink(target, path[, type], callback) 22
#496 message.rawHeaders 22
#497 worker.kill([signal='SIGTERM']) 22
#498 fsPromises.unlink(path) 22
#499 Http2Session 22
#500 --abort-on-uncaught-exception 22