Node APIの紹介と簡単な使用

105175 ワード

Node

Node教程
何がNodeJSですか
JSはスクリプト言語であり、スクリプト言語は解像度が必要です.HTMLページに書かれているJSに対しては、ブラウザは解像度の役割を果たしています.独立運行が必要なJSに対して、NodeJSは解像度計です.
各解像器は運行環境であり、JSが各種データ構造を定義し、各種計算を行うだけでなく、JSが運行環境で提供する内蔵オブジェクトと方法を使用して、いくつかのことを行うことができます.例えば、ブラウザ内で動作するJSの用途はDOMを操作し、ブラウザはdocumentなどの内蔵オブジェクトを提供する.NodeJSで実行されるJSの用途は、ディスクファイルを操作したり、HTTPサーバを構築したりすることであり、NodeJSは、それぞれfs、httpなどの内蔵オブジェクトを提供している.
Node公式サイト
ウェブサイトAPI
中国語の翻訳
BufferTypedArrayを導入する前に、JavaScript言語は、バイナリデータストリームの読み取りまたは操作のための機構を持っていません.Bufferクラスは、Node.js APIの一部として導入され、TCPフロー、ファイルシステム動作、および他のコンテキストで8ビットのバイトストリームと相互作用するために使用される.
BufferオブジェクトはNodeがバイナリデータを処理するインターフェースです.Node原生が提供しているグローバルオブジェクトです.直接使ってもいいです.requireはいらないです.

実装

Buffer.from

Buffer.alloc

機能方法

Buffer.isEnccoding()は、この符号化

がサポートされているかどうかを判断する.

Buffer.isBuffer()がBuffer

であるかどうかを判断する.

Buffer.byteLength()は、符号化されたバイト長を指定し、デフォルトのutf 8

を返す.

Buffer.co ncat()は、Bufferのグループを一つのBufferオブジェクト

に統合する.

例の方法

write()コンテンツ

をブザーオブジェクトに書き込みます.

slice()新しいバfferオブジェクトを切り取る

toString()bufオブジェクトを文字列

に変換する.

toJson()は、bufオブジェクトをjson形式の文字列に変換します.
toJSONメソッドは、明示的な呼び出しが必要ではなく、JSON.strigifyメソッドが起動されると自動的にtoJSONメソッドを呼び出すことができます.

コアモジュールAPI
パス操作Pathpathモジュールは、ファイルパスとディレクトリパスを処理するためのユーティリティを提供する.以下の方法でアクセスできます.

const path = require('path');

Pathオブジェクト

const path = require('path');
console.log(path)
//   ：
// { resolve: [Function: resolve],
//   normalize: [Function: normalize],
//   isAbsolute: [Function: isAbsolute],
//   join: [Function: join],
//   relative: [Function: relative],
//   toNamespacedPath: [Function: toNamespacedPath],
//   dirname: [Function: dirname],
//   basename: [Function: basename],
//   extname: [Function: extname],
//   format: [Function: format],
//   parse: [Function: parse],
//   sep: '\\',
//   delimiter: ';',
//   win32: [Circular],
//   posix:
//    { resolve: [Function: resolve],
//      normalize: [Function: normalize],
//      isAbsolute: [Function: isAbsolute],
//      join: [Function: join],
//      relative: [Function: relative],
//      toNamespacedPath: [Function: toNamespacedPath],
//      dirname: [Function: dirname],
//      basename: [Function: basename],
//      extname: [Function: extname],
//      format: [Function: format],
//      parse: [Function: parse],
//      sep: '/',
//      delimiter: ':',
//      win32: [Circular],
//      posix: [Circular],
//      _makeLong: [Function: toNamespacedPath] },
//   _makeLong: [Function: toNamespacedPath] }

パスの最後の部分を取得します.

console.log(path.basename('/foo/bar/baz/asdf/quux.html'));
//   : 'quux.html'
console.log(path.basename('/foo/bar/baz/asdf/quux.html', '.html'));
//   : 'quux'

パスパスパスパスパスパスパスを取得します.

console.log(__dirname);
//               C:\Users\xiaox\Desktop\code
console.log(__filename)
//             C:\Users\xiaox\Desktop\code\1.js
console.log(path.dirname('/abc/qqq/www/abc'));
//    /abc/qqq/www
console.log(path.dirname('/abc/qqq/www/abc.txt'));
//    /abc/qqq/www

拡張子パス.extname(path)を取得します.

console.log(path.extname('index.html'));
//    .html

パスのフォーマット処理path.formatとpathObjectとparse(path)
path.format(pathObject)obj->string

let objpath = { 
  root: 'C:\\',
  dir:
   'C:\\Users\\xiaox\\Desktop\\code',
  base: '1.js',
  ext: '.js',
  name: '1' 
};
console.log(path.format(objpath));
//   C:\Users\xiaox\Desktop\code\1.js

属性がpathObjectに提供される場合、いくつかの属性は他の属性より優先されることに留意されたい.

がpathObject.dirを提供している場合は、pathObject.rootを無視する.

pathObject.baseが存在する場合は、pathObject.extおよびpathObject.nameを無視する.

path.parse(path)string->obj

console.log(path.parse(__filename));
/*
{ root: 'C:\\',
  dir:
   'C:\\Users\\xiaox\\Desktop\\code',
  base: '1.js',
  ext: '.js',
  name: '1' 
}
*/

絶対パスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパス

console.log(path.isAbsolute('/foo/bar'));
//   true
console.log(path.isAbsolute('C:/foo/..'));
//   true

パスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパス
(…は上位のパスを表します.現在のパスを表します.)接続先の場合は、パスをフォーマットします.

path.join('/foo', 'bar', 'baz/asdf', 'quux', '..');
//   : '/foo/bar/baz/asdf'

path.join('foo', {}, 'bar');
//    'TypeError: Path must be a string. Received {}'

正規化経路path.normalize(path)

console.log(path.normalize('/foo/bar//baz/asdf/quux/..'));
//   : '/foo/bar/baz/asdf'
console.log(path.normalize('C:\\temp\\\\foo\\bar\\..\\'));
//   : 'C:\\temp\\foo\\'

相対経路path.relative(from,to)を計算します.

console.log(path.relative('/data/orandea/test/aaa','/data/orandea/impl/bbb'));
//   : '../../impl/bbb'
console.log(path.relative('C:\\orandea\\test\\aaa','C:\\orandea\\impl\\bbb'));
//   : '..\\..\\impl\\bbb'

解析パスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパスパス
指定された経路シーケンスは、右から左へと処理され、各後続のpathは、絶対パスを構築するまで前にプリアンブルされる.

path.resolve('wwwroot', 'static_files/png/', '../gif/image.gif');
//           /home/myself/node，
//     '/home/myself/node/wwwroot/static_files/gif/image.gif'

二つの特殊属性path.sepとpath.delimiter

console.log(path.delimiter);//       （windows \ Linux /）
  POSIX  ：

console.log(process.env.PATH);
//   : '/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin'

process.env.PATH.split(path.delimiter);
//   : ['/usr/bin', '/bin', '/usr/sbin', '/sbin', '/usr/local/bin']
  Windows  ：

console.log(process.env.PATH);
//   : 'C:\Windows\system32;C:\Windows;C:\Program Files
ode\'

process.env.PATH.split(path.delimiter);
//   : ['C:\\Windows\\system32', 'C:\\Windows', 'C:\\Program Files\
ode\\']
------------------------------------------------------------------------------
console.log(path.sep);//       (windows   ; linux   :)

  POSIX  ：

'foo/bar/baz'.split(path.sep);
//   : ['foo', 'bar', 'baz']
  Windows  ：

'foo\\bar\\baz'.split(path.sep);
//   : ['foo', 'bar', 'baz']

  Windows  ，   （/）    （\）            。   ， path         （\）。

ファイル操作Fs

/*
      I/O input/output
    1、    
    2、    

                ：
    1、    
    2、    
    3、Ajax    

    js        
            

    Node.js                  
       +    

    Node.js        ：
    1、  I/O
    2、  I/O

               
*/

ファイルの状態と情報を確認してfs.Stts類とfs.stat/fs.statSyncを取得します.

Stats {
  dev: 2114,//            
  ino: 48064969,//               
  mode: 33188,//             
  nlink: 1,//         
  uid: 85,//     （POSIX）            
  gid: 100,//     （POSIX）            
  rdev: 0,//           ，            
  size: 527,//     （      ）
  blksize: 4096,//   I/O            
  blocks: 8,//         
  atimeMs: 1318289051000.1,//             ，  POSIX           
  mtimeMs: 1318289051000.1,//             ，  POSIX           
  ctimeMs: 1318289051000.1,//              ，  POSIX           
  birthtimeMs: 1318289051000.1,//              ，  POSIX           
  atime: Mon, 10 Oct 2011 23:24:11 GMT,//                    
  mtime: Mon, 10 Oct 2011 23:24:11 GMT,//                         
  ctime: Mon, 10 Oct 2011 23:24:11 GMT,//                             （       ）
  birthtime: Mon, 10 Oct 2011 23:24:11 GMT //                      
}

通常は、通常のファイルstats.isfile()とファイルディレクトリstats.isDirectory()がブール値に戻るかどうかを判断します.
fs.stat(path[,options],calback)

// const fs = require('fs');

// const pathsToCheck = ['./txtDir', './txtDir/file.txt'];

//    
// for (let i = 0; i < pathsToCheck.length; i++) {
//   fs.stat(pathsToCheck[i], function(err, stats) {
//     if(stats.isFile()){
//         console.log(pathsToCheck[i]+'---  ');
//         console.log(stats)
//     }else if(stats.isDirectory()){
//         console.log(pathsToCheck[i]+'---  ');
//         console.log(stats)
//     }else{
//         console.log(err)
//     }
//   });
// }

//     Sync
// console.log(1);
// let ret = fs.statSync('./data.txt');
// console.log(ret);
// console.log(2);

ファイル操作fs.readFile/fs.readFileSyncを読みます.

/*
         
*/
const fs = require('fs');
const path = require('path');

let strpath = path.join(__dirname,'data.txt');
fs.readFile(strpath,(err,data)=>{
    if(err) return;
    console.log(data.toString());
});

             ，                 
         ，       Buffer    
fs.readFile(strpath,'utf8',(err,data)=>{
    if(err) return;
    // console.log(data.toString());
    console.log(data);
});

    
let ret = fs.readFileSync(strpath,'utf8');
console.log(ret);

ファイル操作fs.writeFile/fs.writeFileSyncを書き込みます.

/*
         
*/
const fs = require('fs');
const path = require('path');

//     
let strpath = path.join(__dirname,'data.txt');
fs.writeFile(strpath,'hello nihao','utf8',(err)=>{
    if(!err){
        console.log('      ');
    }
});

let buf = Buffer.from('hi');
fs.writeFile(strpath,buf,'utf8',(err)=>{
    if(!err){
        console.log('      ');
    }
});

//     
fs.writeFileSync(strpath,'tom and jerry');

大ファイル操作(フロー操作)fs.reate ReadStream/fs.create WriteStream

               
const path = require('path');
const fs = require('fs');

let spath = path.join(__dirname,'../03-source','file.zip');
let dpath = path.join('C:\\Users\\www\\Desktop','file.zip');

let readStream = fs.createReadStream(spath);
let writeStream = fs.createWriteStream(dpath);

//          
// $('input[type=button]').on('click',function(){
//     console.log('hello');
// });

   
// -----------------------------------
let num = 1;
readStream.on('data',(chunk)=>{
    num++;
    writeStream.write(chunk);
});

readStream.on('end',()=>{
    console.log('      '+num);
});

   
// -----------------------------------

// pipe             
readStream.pipe(writeStream);

   
// ----------------------------------
fs.createReadStream(spath).pipe(fs.createWriteStream(dpath));

ディレクトリ操作

作成ディレクトリfs.mkdir(path[,mode],calback)/fs.mkdirSync(path[,mode])

const path = require('path');
const fs = require('fs');
//     
fs.mkdir(path.join(__dirname,'abc'),(err)=>{
    console.log(err);
});
fs.mkdirSync(path.join(__dirname,'hello'));


//    /tmp/a/apple   ，       /tmp   /tmp/a   。
// recursive   （           ）   
fs.mkdir('/tmp/a/apple', { recursive: true }, (err) => {
  if (err) throw err;
});

ディレクトリfs.readdir(path[,options],calback)/fs.readdirSync(path[,options])

const path = require('path');
const fs = require('fs');
//     
fs.readdir(__dirname,(err,files)=>{
    files.forEach((item,index)=>{
        fs.stat(path.join(__dirname,item),(err,stat)=>{
            if(stat.isFile()){
                console.log(item,'  ');
            }else if(stat.isDirectory()){
                console.log(item,'  ');
            }
        });
    });
});

let files = fs.readdirSync(__dirname);
files.forEach((item,index)=>{
    fs.stat(path.join(__dirname,item),(err,stat)=>{
        if(stat.isFile()){
            console.log(item,'  ');
        }else if(stat.isDirectory()){
            console.log(item,'  ');
        }
    });
});

を読み出す.

ディレクトリfs.rmdir/fs.rmdirSync(path)

//     
fs.rmdir(path.join(__dirname,'abc'),(err)=>{
    console.log(err);
});

fs.rmdirSync(path.join(__dirname,'qqq'));

を削除します.
ファイル操作の実例

/*
          （       ）
*/
const path = require('path');
const fs = require('fs');

let root = 'C:\\Users\\www\\Desktop';
let fileContent = `



    
    Document


    welcome to this


`;

//      
let initData = {
    projectName : 'mydemo',
    data : [{
        name : 'img',
        type : 'dir'
    },{
        name : 'css',
        type : 'dir'
    },{
        name : 'js',
        type : 'dir'
    },{
        name : 'index.html',
        type : 'file'
    }]
}

//        
fs.mkdir(path.join(root,initData.projectName),(err)=>{
    if(err) return;
    //         
    initData.data.forEach((item)=>{
        if(item.type == 'dir'){
            //      
            fs.mkdirSync(path.join(root,initData.projectName,item.name));
        }else if(item.type == 'file'){
            //          
            fs.writeFileSync(path.join(root,initData.projectName,item.name),fileContent);
        }
    });
});

サーバー操作Http

               
PHP ： Apache + php  
java ：Tomcat 、Weblogic
Node.js  :        （      ）

/*
    Node.js Web       ：
    1、Node.js            （Apache），    api    
    2、         
    3、    
    4、    
    5、    
    6、get post       

    Web    ：express
*/

サーバ[http.creat Server]を作成します.

const http = require('http');
// //          
let server = http.createServer();
console.log(server)

Server {
  _events:
   [Object: null prototype] { connection: [Function: connectionListener] },
  _eventsCount: 1,
  _maxListeners: undefined,
  _connections: 0,
  _handle: null,
  _usingWorkers: false,
  _workers: [],
  _unref: false,
  allowHalfOpen: true,
  pauseOnConnect: false,
  httpAllowHalfOpen: false,
  timeout: 120000,//    （      ）。   : 120000（2   ）
  keepAliveTimeout: 5000,//    （      ）。   : 5000（5  ）               ，          
  maxHeadersCount: null,//          。       0，              : 2000
  headersTimeout: 40000,//            HTTP           : 40000
  [Symbol(IncomingMessage)]:
   { [Function: IncomingMessage]
     super_:
      { [Function: Readable]
        ReadableState: [Function: ReadableState],
        super_: [Function],
        _fromList: [Function: fromList] } },
  [Symbol(ServerResponse)]:
   { [Function: ServerResponse] super_: { [Function: OutgoingMessage] super_: [Function] } },
  [Symbol(asyncId)]: -1 }

http.createServer方法は、http.Serverオブジェクトの例を返し、requestListenerにオプションのパラメータが入力されると、http.Serverオブジェクト'request'イベントのモニターとして機能する.
http.serverクラスでのrequestイベントを送信します.

request

response

要求があるたびにトリガします.各接続は複数の要求(HTTP Keep-Alive接続の場合)があり得る.

/*
             
*/
const http = require('http');
// -----------------------------
   ：
//          
let server = http.createServer();
console.log(server)
//       
server.on('request',(req,res)=>{
    res.end('hello');
});
//     
server.listen(3000);
// -----------------------------
   ：
http.createServer((req,res)=>{
    res.end('ok');//response.end([data[, encoding]][, callback])
}).listen(3000,'192.168.0.106',()=>{
    console.log('running...');
});

res.end()は上記のようなreponse類の方法です.[reponse.end]

res.end('ok','utf-8',()=>{
	console.log('    ')
});

HTTPサーバを起動して、接続server.listenを傍受します()
この方法はnet.Serverのserver.listen()と同じである.

      ，      api
server.listen({
  host: 'localhost',
  port: 80,
  exclusive: true
});

要求経路はhttp.ServerResonse類を配布します.
1、reqオブジェクトはClass:http.IncompingMessageのインスタンスオブジェクト2、resオブジェクトはClass:http.ServerResonseのインスタンスオブジェクトです.

const http = require('http');
http.createServer((req,res)=>{
    // req.url    URL    （      ）
    // res.end(req.url);
    if(req.url.startsWith('/index')){
        // write        ,     
        res.write('hello');
        res.write('hi');
        res.write('nihao');
        // end        ，      
        res.end();
    }else if(req.url.startsWith('/about')){
        res.end('about');
    }else{
        res.end('no content');
    }
}).listen(3000,'192.168.0.106',()=>{
    console.log('running...');
});

res.write()は上述のようなreponse類の方法です.[レスポンス.write(chunk,encoding)[,calback]

/*
             
*/
const http = require('http');
const path = require('path');
const fs = require('fs');

//            ，         
let readFile = (url,res) => {
    fs.readFile(path.join(__dirname,'www',url),'utf8',(err,fileContent)=>{
        if(err){
            res.end('server error');
        }else{
            res.end(fileContent);
        }
    });
}

http.createServer((req,res)=>{
    //        
    if(req.url.startsWith('/index')){
        readFile('index.html',res);
    }else if(req.url.startsWith('/about')){
        readFile('about.html',res);
    }else if(req.url.startsWith('/list')){
        readFile('list.html',res);
    }else{
        //          
        res.writeHead(200,{
            'Content-Type':'text/plain; charset=utf8'
        });
        res.end('        ');
    }
}).listen(3000,'192.168.0.106',()=>{
    console.log('running...');
});

レスポンスヘッダ[reponse.writeHead(status Code,status Message][,headers]を設定します.)とreponse.set Header(name,value)を設定します.response.setHeader()を使用して応答ヘッダを設定すると、response.writeHead()に送信される任意の応答ヘッダとマージされ、response.writeHead()の応答ヘッダが優先される.

//    content-type = text/plain
const server = http.createServer((req, res) => {
  res.setHeader('Content-Type', 'text/html');
  res.setHeader('X-Foo', 'bar');
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('ok');
});

解析インターフェース操作URL
URLオブジェクト

const url = require('url');
console.log(url)

{ Url: [Function: Url],
  parse: [Function: urlParse],
  resolve: [Function: urlResolve],
  resolveObject: [Function: urlResolveObject],
  format: [Function: urlFormat],
  URL: [Function: URL],
  URLSearchParams: [Function: URLSearchParams],
  domainToASCII: [Function: domainToASCII],
  domainToUnicode: [Function: domainToUnicode],
  pathToFileURL: [Function: pathToFileURL],
  fileURLToPath: [Function: fileURLToPath] 
}

GETパラメータ処理[url.parse]
parseメソッドの役割はURL文字列をオブジェクトに変換することです.

const url = require('url');
let str = 'http://www.baidu.com/abc/qqq?flag=123&keyword=java';
let ret = url.parse(str)
console.log(ret)
//      urlObject
Url {
  protocol: 'http:',//  
  slashes: true,// url characters (/)  true，  false
  auth: null,//      
  host: 'www.baidu.com',//        +  
  port: null,//  
  hostname: 'www.baidu.com',//   
  hash: null,//characters (#)
  search: '?flag=123&keyword=java',//    
  query: 'flag=123&keyword=java',//  ？     
  pathname: '/abc/qqq',//   
  path: '/abc/qqq?flag=123&keyword=java',//  
  href: 'http://www.baidu.com/abc/qqq?flag=123&keyword=java' //  url
}

第二のパラメータparseQueryStringは、実はquery.parseを表しています.

const url = require('url');
let str = 'http://www.baidu.com/abc/qqq?flag=123&keyword=java';
let ret = url.parse(str,true)
console.log(ret)
Url {
  protocol: 'http:',
  slashes: true,
  auth: null,
  host: 'www.baidu.com',
  port: null,
  hostname: 'www.baidu.com',
  hash: null,
  search: '?flag=123&keyword=java',
  query: [Object: null prototype] { flag: '123', keyword: 'java' },
  pathname: '/abc/qqq',
  path: '/abc/qqq?flag=123&keyword=java',
  href: 'http://www.baidu.com/abc/qqq?flag=123&keyword=java' }

GETパラメータ処理url.format(URL[,options])
formatの役割は、オブジェクトを標準のURL文字列に変換することです.

url.format({
  protocol: 'https',
  hostname: 'example.com',
  pathname: '/some/path',
  query: {
    page: 1,
    format: 'json'
  }
});

// => 'https://example.com/some/path?page=1&format=json'

文字列Querystringを検索します.querystringモジュールは、URLクエリ文字列を解析してフォーマットするためのユーティリティを提供する.以下の方法でアクセスできます.

const querystring = require('querystring');

POSTパラメータ処理querystring.parse(str[,sep[,eq[,options]])
パースメソッドの役割は文字列をオブジェクトに変換することです.

str stringが解析するURLクエリ文字列.

sep stringは、照会文字列においてキーペアのサブ文字列を分離するために使用される.標準値:'&'.

eq stringは、照会文字列においてキーと値を分離するためのサブ文字列である.標準値:'='.

options object

decodeURIComponent Fncitonは、クエリ文字列のパーセンテージ符号化文字を復号する際に使用する関数です.標準値:querystring.unescape().

maxKeys numberは、解析するキーの最大数を指定します.0リムーバブルキーのカウント制限を指定します.標準値:1000.

querystring.parse()方法は、URLクエリ文字列strをキーパッドペアのセットとして解析する.
例えば、クエリー文字列'foo=bar&abc=xyz&abc=123'は、次のように解析される.

const querystring = require('querystring');
let param = 'foo=bar&abc=xyz&abc=123';
let obj = querystring.parse(param);
console.log(obj);
{
  foo: 'bar',
  abc: ['xyz', '123']
}

querystring.parse()方法で返されたオブジェクトは、プロトタイプではなく、JavaScript Objectから継承されている.これは、Object、obj.toString()などの典型的な方法が定義されておらず、機能しないことを意味する.
POSTパラメータ処理querystring.strigify(str[,sep[,eq[,options]])
strigifyの役割は、対象を文字列に変換することです.

obj.hasOwnProperty() objectは、URLクエリ文字列のオブジェクトとして順序付けされる.

obj stringは、照会文字列においてキーペアのサブ文字列を分離するために使用される.標準値:sep.

'&' stringは、照会文字列においてキーと値を分離するためのサブ文字列である.標準値:eq.

'='

options functionは、照会文字列において、URLがセキュリティでない文字をパーセンテージエンコードに変換する際に使用する関数です.標準値:encodeURIComponent.

querystring.escape()方法は、与えられたquerystring.stringify()から反復オブジェクトの自身の属性によってURLクエリ文字列を生成する.objに導入された以下のタイプの値が、順に並べられている.他の入力値は強制的に空の文字列に変換されます.

querystring.stringify({ foo: 'bar', baz: ['qux', 'quux'], corge: '' });
//    'foo=bar&baz=qux&baz=quux&corge='

querystring.stringify({ foo: 'bar', baz: 'qux' }, ';', ':');
//    'foo:bar;baz:qux'

let obj1 = {
    flag : '123',
    abc : ['hello','hi']
}
let str1 = querystring.stringify(obj1);
console.log(str1);

簡単POST依頼例

const querystring = require('querystring');
const http = require('http');

http.createServer((req,res)=>{
    if(req.url.startsWith('/login')){
        let pdata = '';
        req.on('data',(chunk)=>{
            //          
            pdata += chunk;
        });

        req.on('end',()=>{
            //            
            console.log(pdata);
            let obj = querystring.parse(pdata);
            res.end(obj.username+'-----'+obj.password);
        });
    }
}).listen(3000,()=>{
    console.log('running...');
})
//       postman

expressミドルウェアの理解