Node.js チートシート

// myModule.js
const myFunction = () => { console.log('Hello!'); };
module.exports = { myFunction };
// または
exports.myFunction = () => { console.log('Hello!'); };

// main.js
const myModule = require('./myModule');
myModule.myFunction(); // 'Hello!'

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

// myModule.mjs
export const myFunction = () => { console.log('Hello!'); };
export const myVariable = 123;

// myDefaultModule.mjs
const myClass = class { /* ... */ };
export default myClass;

// main.mjs
import { myFunction, myVariable } from './myModule.mjs';
myFunction(); // 'Hello!'
console.log(myVariable); // 123

// main.mjs
import MyClass from './myDefaultModule.mjs';
const instance = new MyClass();

// main.mjs
import * as Utils from './myModule.mjs';
Utils.myFunction();
console.log(Utils.myVariable);

// main.mjs
import fs from 'fs'; // コアモジュール
import _ from 'lodash'; // npm パッケージ (CommonJS)

// CommonJSファイルを動的にインポート (非推奨、可能なら避ける)
// const { someFunction } = await import('./commonjs-module.cjs');

import { promises as fs } from 'fs';

async function readFileContent(filePath) {
  try {
    const data = await fs.readFile(filePath, 'utf8');
    console.log('ファイル内容:', data);
  } catch (err) {
    console.error('読み込みエラー:', err);
  }
}

import { promises as fs } from 'fs';

async function writeFileContent(filePath, content) {
  try {
    await fs.writeFile(filePath, content, 'utf8');
    console.log('書き込み成功！');
  } catch (err) {
    console.error('書き込みエラー:', err);
  }
}

import { promises as fs } from 'fs';

async function appendFileContent(filePath, content) {
  try {
    await fs.appendFile(filePath, content, 'utf8');
    console.log('追記成功！');
  } catch (err) {
    console.error('追記エラー:', err);
  }
}

import { promises as fs } from 'fs';
import { constants } from 'fs'; //定数をインポート

async function checkExists(path) {
  try {
    await fs.access(path, constants.F_OK); // F_OK: 存在確認
    console.log(`${path} は存在します。`);
    // constants.R_OK (読み取り可能か), constants.W_OK (書き込み可能か) も使える
  } catch (err) {
    if (err.code === 'ENOENT') {
      console.log(`${path} は存在しません。`);
    } else {
      console.error('アクセスエラー:', err);
    }
  }
}

import { promises as fs } from 'fs';

async function getStats(path) {
  try {
    const stats = await fs.stat(path); // シンボリックリンクの場合は fs.lstat
    console.log('ファイル情報:', stats);
    console.log('ファイルですか？:', stats.isFile());
    console.log('ディレクトリですか？:', stats.isDirectory());
    console.log('サイズ:', stats.size);
  } catch (err) {
    console.error('情報取得エラー:', err);
  }
}

import { promises as fs } from 'fs';

async function deleteFile(filePath) {
  try {
    await fs.unlink(filePath);
    console.log('ファイル削除成功！');
  } catch (err) {
    console.error('削除エラー:', err);
  }
}

import { promises as fs } from 'fs';

async function createDirectory(dirPath) {
  try {
    // recursive: true で親ディレクトリもまとめて作成
    await fs.mkdir(dirPath, { recursive: true });
    console.log('ディレクトリ作成成功！');
  } catch (err) {
    console.error('作成エラー:', err);
  }
}

import { promises as fs } from 'fs';

async function readDirectory(dirPath) {
  try {
    const files = await fs.readdir(dirPath);
    console.log('ディレクトリ内容:', files); // ファイル名とディレクトリ名の配列
  } catch (err) {
    console.error('読み込みエラー:', err);
  }
}

import { promises as fs } from 'fs';

async function removeDirectory(dirPath) {
  try {
    // recursive: true で中身ごと削除 (Node.js v14.14.0以降)
    // それ以前は中のファイル/ディレクトリを再帰的に削除する必要あり
    await fs.rm(dirPath, { recursive: true, force: true }); // force: true はエラーを無視
    // または await fs.rmdir(dirPath, { recursive: true }); (古いAPI, 非推奨)
    console.log('ディレクトリ削除成功！');
  } catch (err) {
    console.error('削除エラー:', err);
  }
}

import { promises as fs } from 'fs';

async function renamePath(oldPath, newPath) {
  try {
    await fs.rename(oldPath, newPath);
    console.log('名前変更/移動 成功！');
  } catch (err) {
    console.error('エラー:', err);
  }
}

import path from 'path';
const fullPath = path.join('/users', 'joe', 'notes.txt');
// Windows: \users\joe\notes.txt
// Linux/macOS: /users/joe/notes.txt

import path from 'path';
const absolutePath = path.resolve('myfile.txt');
// カレントディレクトリからの絶対パスを返す
// 例: /path/to/current/directory/myfile.txt

import path from 'path';
const dir = path.dirname('/users/joe/notes.txt'); // '/users/joe'

import path from 'path';
const base = path.basename('/users/joe/notes.txt'); // 'notes.txt'
const baseWithoutExt = path.basename('/users/joe/notes.txt', '.txt'); // 'notes'

import path from 'path';
const ext = path.extname('/users/joe/notes.txt'); // '.txt'

import path from 'path';
const normalized = path.normalize('/users/joe/.././notes.txt'); // '/users/notes.txt'

import path from 'path';
console.log(path.sep); // Windows: '\', Linux/macOS: '/'

const p1 = fs.readFile('file1.txt');
const p2 = fs.readFile('file2.txt');

try {
  const results = await Promise.all([p1, p2]);
  // results は [file1の内容, file2の内容] の配列
} catch (err) {
  // いずれか一つでも失敗したら catch へ
}

const p1 = fs.readFile('file1.txt');
const p2 = fs.unlink('nonexistent.txt'); // これは失敗する

const results = await Promise.allSettled([p1, p2]);
// results は以下のような配列:
// [
//   { status: 'fulfilled', value:  },
//   { status: 'rejected', reason: Error(...) }
// ]

const p1 = new Promise(resolve => setTimeout(resolve, 500, 'one'));
const p2 = new Promise(resolve => setTimeout(resolve, 100, 'two'));

try {
  const first = await Promise.race([p1, p2]);
  console.log(first); // 'two' (p2が先に解決するため)
} catch (err) {
  // 最初に失敗した Promise のエラー
}

const p1 = Promise.reject('エラー1');
const p2 = new Promise(resolve => setTimeout(resolve, 100, '成功2'));
const p3 = Promise.reject('エラー3');

try {
  const firstSuccess = await Promise.any([p1, p2, p3]);
  console.log(firstSuccess); // '成功2'
} catch (err) {
  // すべての Promise が失敗した場合 AggregateError
  console.error(err.errors); // ['エラー1', 'エラー3']
}

import fs from 'fs';

const readableStream = fs.createReadStream('large-file.txt', 'utf8');

readableStream.on('data', (chunk) => {
  console.log('データ受信:', chunk.length, 'bytes');
  // ここで chunk を処理
});

readableStream.on('end', () => {
  console.log('読み込み完了');
});

readableStream.on('error', (err) => {
  console.error('読み込みエラー:', err);
});

import fs from 'fs';

const writableStream = fs.createWriteStream('output.txt');

writableStream.write('最初のデータ\n');
writableStream.write('次のデータ\n');
writableStream.end('最後のデータ'); // end() で書き込みを終了

writableStream.on('finish', () => {
  console.log('書き込み完了');
});

writableStream.on('error', (err) => {
  console.error('書き込みエラー:', err);
});

import fs from 'fs';
import zlib from 'zlib'; // 圧縮・解凍モジュール

const readable = fs.createReadStream('large-file.txt');
const writable = fs.createWriteStream('output.txt.gz');
const gzip = zlib.createGzip(); // Transform Stream

readable.pipe(gzip).pipe(writable);

// エラーハンドリングは各ストリームに設定推奨
readable.on('error', handleError);
gzip.on('error', handleError);
writable.on('error', handleError);

function handleError(err) {
  console.error('ストリームエラー:', err);
  // 必要ならストリームを破棄するなど
}

import fs from 'fs';
import zlib from 'zlib';
import { pipeline } from 'stream/promises'; // Promise版を使う

async function processStream() {
  const readable = fs.createReadStream('large-file.txt');
  const writable = fs.createWriteStream('output.txt.gz');
  const gzip = zlib.createGzip();

  try {
    await pipeline(readable, gzip, writable);
    console.log('パイプライン完了');
  } catch (err) {
    console.error('パイプラインエラー:', err);
  }
}
processStream();

// 実行: node app.js arg1 arg2=value
console.log(process.argv);
// 出力例:
// [
//   '/path/to/node',       // Node.js実行可能ファイルのパス
//   '/path/to/app.js',     // 実行スクリプトのパス
//   'arg1',                // 引数1
//   'arg2=value'           // 引数2
// ]

console.log('NODE_ENV:', process.env.NODE_ENV);
console.log('PATH:', process.env.PATH);
// 環境変数を設定して実行: MY_VAR=abc node app.js
console.log('MY_VAR:', process.env.MY_VAR); // 'abc'

console.log('カレントワーキングディレクトリ:', process.cwd());

if (someErrorCondition) {
  console.error('致命的なエラーが発生しました。終了します。');
  process.exit(1); // 0以外のコードは通常エラーを示す
}
console.log('正常終了します。');
process.exit(0); // 正常終了

console.log('プロセスID:', process.pid);

console.log('実行プラットフォーム:', process.platform);
// 'darwin' (macOS), 'win32' (Windows), 'linux' など

console.log('起動からの経過時間 (秒):', process.uptime());

console.log('メモリ使用状況:', process.memoryUsage());
// { rss: ..., heapTotal: ..., heapUsed: ..., external: ..., arrayBuffers: ... }

process.on('uncaughtException', (err, origin) => {
  console.error(`キャッチされなかった例外: ${err}\n` +
                `発生源: ${origin}`);
  // ここでログ記録などを行い、プロセスを終了するのが一般的
  process.exit(1);
});
// throw new Error('テスト例外'); // これが発生すると上記リスナーが呼ばれる

process.on('unhandledRejection', (reason, promise) => {
  console.error('処理されなかったPromise Rejection:', reason);
  // 将来的には uncaughtException 同様、プロセス終了がデフォルトになる可能性あり
  // process.exit(1);
});
// Promise.reject('テストリジェクション'); // これが発生すると上記リスナーが呼ばれる

try {
  const data = JSON.parse('{ invalid json');
} catch (e) {
  console.error('パースエラー:', e.message); // e は Error オブジェクト
}

fs.readFile('...', (err, data) => {
  if (err) {
    // エラー処理
    return;
  }
  // 成功処理
});

// .catch()
somePromiseFunc()
  .then(...)
  .catch(err => { /* エラー処理 */ });

// async/await
async function myAsyncFunc() {
  try {
    await anotherPromiseFunc();
  } catch (err) {
    /* エラー処理 */
  }
}

const stream = fs.createReadStream(...);
stream.on('error', (err) => {
  console.error('ストリームエラー:', err);
});