プログラミングの関数とは？基礎から関数型プログラミングまで完全ガイド

// ⭕ 良い例：自動販売機関数（引数と戻り値の型がしっかり定義されている）
// money(お金)と drinkName(飲み物の名前)を受け取り、string(文字列)を返す
function buyDrink(money: number, drinkName: string): string {
  const price = 150; // ジュースの価格設定
  
  if (money >= price) {
    const change = money - price;
    return `${drinkName}を買いました！ お釣りは${change}円です。`;
  } else {
    return `お金が足りません。${price}円入れてください。`;
  }
}

// 関数の呼び出し（自動販売機を使う）
const result1 = buyDrink(200, "コーラ");
console.log(result1); // 出力: コーラを買いました！ お釣りは50円です。

const result2 = buyDrink(100, "お茶");
console.log(result2); // 出力: お金が足りません。150円入れてください。

// ❌ 実務でNGな書き方（型が指定されていない・anyになっている）
// どんなデータが入ってくるか分からず、TypeScriptのメリットが完全に死んでしまう
// function badBuyDrink(money: any, drinkName: any) { ... }

// 【変数】ただのデータ（名詞）
const basePrice: number = 1000;

// 【関数】処理のまとまり（動詞）
function getTaxIncludedPrice(): number {
  return basePrice * 1.1; // 10%の消費税を計算して返す
}

// ⭕ 正しい使い方：関数に () をつけて「実行」し、その結果を変数に入れる
const finalPrice: number = getTaxIncludedPrice(); 
console.log(finalPrice); // 出力: 1100

// ❌ よくある初心者のミス： () をつけ忘れる
// 関数を実行せず、関数という「機械自体」を代入しようとしてしまう
// const wrongPrice: number = getTaxIncludedPrice; 
// 🚨 TypeScriptエラー: 型 '() => number' を型 'number' に割り当てることはできません。

// 💡 命名規則のコツ
// 実務では、一目で違いがわかるように
// 変数名は名詞（例: price, userData）
// 関数名は動詞から始める（例: calculatePrice(), getUserData()）
// というルールを守るのがベストプラクティスです。

// 1. 関数の定義（宣言）
// functionキーワードを使って、挨拶を表示する関数を作成
function sayHello() {
  console.log("こんにちは！TypeScriptの世界へようこそ。");
}

// 2. 関数の呼び出し（実行）
// カッコ () をつけないと実行されません
sayHello(); // 出力: こんにちは！TypeScriptの世界へようこそ。

// 💡 豆知識（巻き上げ）
// functionキーワードで作った関数は、定義する前に呼び出しても動きます（実務では少し読みづらくなる原因にもなります）
callBeforeDefine(); // 出力: 呼ばれました！

function callBeforeDefine() {
  console.log("呼ばれました！");
}

// アロー関数の定義
// () => { 処理 } という形を作り、constで変数に代入する
const sayGoodbye = () => {
  console.log("さようなら！また明日。");
};

// 呼び出し方は同じ
sayGoodbye(); // 出力: さようなら！また明日。

// ❌ よくあるミス：定義する前に呼び出すとエラーになる（巻き上げされない）
// calculateTotal(); // 🚨 エラー: 'calculateTotal' が初期化される前にアクセスできません。

const calculateTotal = () => {
  console.log("合計を計算します");
};

// ⭕ 良い例：引数と戻り値にしっかり型を指定したアロー関数
// price(数値) と taxRate(数値) を受け取り、最終的な計算結果(数値)を返す
const getTaxIncludedPrice = (price: number, taxRate: number): number => {
  return price * taxRate;
};

const finalPrice = getTaxIncludedPrice(1000, 1.1);
console.log(finalPrice); // 出力: 1100

// ❌ 悪い例（実務でバグを生む原因）
// 戻り値の型(: number)を書き忘れている。
// もし内部の計算ミスで文字列を返してしまっても、関数定義の段階では気づきにくい。
const badCalculate = (a: number, b: number) => {
  // return a + b; のつもりが...
  return "計算結果は " + (a + b); // 文字列になってしまった！
};

// ❌ さらに悪い例：引数に any 型を使う（TypeScriptの意味がなくなる）
const worstCalculate = (a: any, b: any): any => {
  return a + b;
};

// --- 配列操作の例（非破壊的メソッドの活用） ---

// ユーザーの年齢一覧（数値の配列）
const userAges: number[] = [18, 25, 30, 16, 42];

// 【filter関数】20歳以上のユーザーだけを抽出して「新しい配列」を作る
// age => age >= 20 というアロー関数を引数として渡しています
const adultAges: number[] = userAges.filter(age => age >= 20);

console.log(adultAges); // 出力: [25, 30, 42]
console.log(userAges);  // 出力: [18, 25, 30, 16, 42] （元の配列は壊れていない！安全！）

// --- 文字列操作の例 ---

const message: string = "TypeScriptは難しいです。";

// 【replace関数】指定した文字を別の文字に置き換える
const positiveMessage: string = message.replace("難しい", "楽しい");

console.log(positiveMessage); // 出力: TypeScriptは楽しいです。

// --- 乱数（ランダムな整数）を生成する ---

// 1から指定した最大値までのランダムな整数を返す関数
const getRandomNumber = (max: number): number => {
  // Math.random() で 0~0.999... を出し、maxを掛けて切り捨てることで整数を作る
  return Math.floor(Math.random() * max) + 1;
};

const diceRoll: number = getRandomNumber(6); // 1〜6のサイコロ
console.log(`サイコロの目は ${diceRoll} です！`);

// --- 三角関数を使う際の注意点 ---

const angle: number = 90; // 90度

// ❌ よくあるミス：角度をそのまま渡してしまう
// const wrongSin = Math.sin(angle); 

// ⭕ 正しいやり方：角度（度数法）をラジアン（弧度法）に変換してから渡す
// 変換公式: ラジアン = 角度 * (円周率 / 180)
const radian: number = angle * (Math.PI / 180);
const correctSin: number = Math.sin(radian);

console.log(`90度のサイン値は ${correctSin} です`); // 出力: 90度のサイン値は 1 です

// ❌ 悪い例（純粋関数ではない・不変性を破っている）
let globalTotal = 0;
const impureAdd = (num: number): number => {
  globalTotal += num; // 外側の変数を書き換えている（副作用）
  return globalTotal;
};

const users = ["田中", "佐藤"];
const addUsersBad = (newUserName: string) => {
  users.push(newUserName); // 元の配列を直接書き換えている（破壊的変更）
};

// ⭕ 良い例（純粋関数・不変性を保っている）
// 外側の変数に依存せず、引数だけで計算を完結させている
const pureAdd = (a: number, b: number): number => {
  return a + b; 
};

// スプレッド構文を使い、元の配列はそのままに「新しい配列」を作って返す
const addUsersGood = (currentUsers: string[], newUserName: string): string[] => {
  return [...currentUsers, newUserName];
};

const updatedUsers = addUsersGood(["田中", "佐藤"], "鈴木");
// 出力: ["田中", "佐藤", "鈴木"] （元の ["田中", "佐藤"] は無傷のまま）

// --- オブジェクト指向の例（データと処理がセット。状態を書き換える） ---
class UserOOP {
  constructor(public name: string, public age: number) {}

  // 自分自身の状態（プロパティ）を直接書き換える
  haveBirthday() {
    this.age += 1;
  }
}
const user1 = new UserOOP("田中", 20);
user1.haveBirthday(); // user1の中身が直接 21歳 に変更される

// --- 関数型プログラミングの例（データと処理を分離。新しいデータを返す） ---
// データはただの型定義
type UserFP = { readonly name: string; readonly age: number };

const user2: UserFP = { name: "佐藤", age: 20 };

// 処理は独立した純粋関数。引数としてデータを受け取り、新しいオブジェクトを返す
const haveBirthdayFP = (user: UserFP): UserFP => {
  return { ...user, age: user.age + 1 };
};

const updatedUser2 = haveBirthdayFP(user2); 
// user2 自体は 20歳のまま。updatedUser2 という新しい 21歳のデータが作られる

// ❌ テストしづらい関数（外部の環境や時間に依存している）
const isWeekendBad = (): boolean => {
  const today = new Date().getDay(); // 実行する日によって結果が変わる！
  return today === 0 || today === 6;
};

// ⭕ 関数型プログラミングの利点を活かしたテストしやすい純粋関数
// 「判定したい日付」を引数として受け取るようにする
const isWeekendGood = (date: Date): boolean => {
  const day = date.getDay();
  return day === 0 || day === 6;
};

// 💡 テスト時のイメージ（引数を与えれば結果が100%予測できるためテストが簡単）
const saturday = new Date("2026-05-23"); // 土曜日
console.log(isWeekendGood(saturday)); // 必ず true になる

type Product = { name: string; price: number; inStock: boolean };
const cart: Product[] = [
  { name: "ノート", price: 200, inStock: true },
  { name: "ペン", price: 150, inStock: true },
  { name: "消しゴム", price: 100, inStock: false },
];

// ❌ デメリット：やりすぎた関数型の書き方（複雑なreduceチェーン）
// 初心者は「for文を使わない」ことに固執して、難解なコードを書きがち
const totalStockPriceBad = cart.reduce((acc, item) => {
  return item.inStock ? acc + item.price : acc;
}, 0);

// ⭕ 実務で推奨される、可読性の高い関数型の書き方
// 無理に1つにまとめず、filterとmapなどで「言葉のように」処理を分ける
const totalStockPriceGood = cart
  .filter(item => item.inStock)       // まず在庫があるものだけを絞り込む
  .map(item => item.price)            // 次に価格だけの配列にする
  .reduce((sum, price) => sum + price, 0); // 最後に合計する

console.log(totalStockPriceGood); // 出力: 350

// ❌ 悪い例：TypeScriptの型を使っているが、中身が書き換え可能（関数型に反する）
type MutableUser = { name: string; age: number };
const user1: MutableUser = { name: "田中", age: 25 };
// 関数を通さずとも、どこからでも直接書き換えられてしまう（バグの原因）
user1.age = 26; 

// ⭕ 良い例：readonly を使って「不変（イミュータブル）」を保証する
type ImmutableUser = { readonly name: string; readonly age: number };
const user2: ImmutableUser = { name: "佐藤", age: 30 };

// 🚨 user2.age = 31; // TypeScriptが「読み取り専用プロパティであるため、'age' に代入することはできません」とエラーを出して守ってくれる！

// 新しいデータが必要な場合は、純粋関数とスプレッド構文で「新しいオブジェクト」を作る
const haveBirthday = (user: ImmutableUser): ImmutableUser => {
  return { ...user, age: user.age + 1 };
};

const updatedUser = haveBirthday(user2);
console.log(updatedUser.age); // 出力: 31