1. 👋 はじめに

プログラミングを学び始めると、たくさんの構文や概念が出てきて混乱しますよね。

でも実は、どんなプログラミング言語にも共通する「基本の考え方」 があります。

このシリーズでは、言語を問わず使えるコーディングの基礎を体系的に解説します！

このシリーズで使うコード例について：
主にPython・TypeScriptを使って説明しますが、
考え方はJava・Ruby・PHP・Goなどどの言語にも共通します。

この記事を読めば：

✅ プログラムの3つの基本構造がわかる
✅ 関数の役割と作り方がわかる
✅ スコープ（変数の有効範囲）がわかる

2. 🏗️ プログラムの3つの基本構造

どんな複雑なプログラムも、たった3つの構造の組み合わせで書かれています。

構造	一言で言うと	例え
📋 順次処理	上から順番に実行する	レシピの手順通りに料理する
🔀 分岐処理	条件によって処理を変える	信号が赤なら止まる・青なら進む
🔁 反復処理	同じ処理を繰り返す	全員に同じ書類を配る

3. 📋 順次処理（Sequential）

一言で言うと

プログラムは基本的に「上から下へ」順番に実行されます。
これが順次処理です。

コード例

# Python の例
name = "Alice"          # ① 変数に名前を代入
greeting = "こんにちは"  # ② 変数に挨拶を代入
message = greeting + "、" + name + "さん！"  # ③ 文字列を結合
print(message)          # ④ 表示する
# 出力：こんにちは、Aliceさん！

// TypeScript の例
const name = "Alice";
const greeting = "こんにちは";
const message = `${greeting}、${name}さん！`;
console.log(message);
// 出力：こんにちは、Aliceさん！

重要なポイント：
①→②→③→④の順番で必ず実行されます。
③を①や②より前に書くとエラーになります（name や greeting がまだ定義されていないため）。

4. 🔀 分岐処理（Branching）

一言で言うと

「もし〇〇なら△△する、そうでなければ□□する」という処理です。
条件によって実行するコードを変えることができます。

if文の基本

# Python の例
score = 75

if score >= 90:
    print("優秀！🌟")
elif score >= 70:
    print("合格！✅")
elif score >= 50:
    print("もう少し📚")
else:
    print("不合格❌")

# 出力：合格！✅

// TypeScript の例
const score = 75;

if (score >= 90) {
  console.log("優秀！🌟");
} else if (score >= 70) {
  console.log("合格！✅");
} else if (score >= 50) {
  console.log("もう少し📚");
} else {
  console.log("不合格❌");
}

分岐処理のポイント

種類	使い方	例
`if`	条件が真のとき実行	90点以上なら「優秀」
`elif` / `else if`	前の条件が偽で、この条件が真のとき	70点以上なら「合格」
`else`	すべての条件が偽のとき	それ以外は「不合格」

⚠️ 条件を書く順番に注意！
if文は上から順番に条件が判定され、最初に一致したブロックだけが実行されます。

例えば score >= 70 を一番上に書いてしまうと…
if score >= 70:       # ← 95点もここで「合格」になってしまう！
    print("合格！✅")
elif score >= 90:     # ← ここには絶対到達しない
    print("優秀！🌟")
95点の人が「合格！✅」と表示され「優秀！🌟」に絶対到達しません。
範囲が狭い（厳しい）条件から先に書くのが基本ルールです。

条件式でよく使う比較演算子

演算子	意味	Python の例	TypeScript の例
`==`	等しい	`score == 100`	`score === 100` ※
`!=`	等しくない	`score != 0`	`score !== 0` ※
`>`	より大きい	`score > 90`	`score > 90`
`>=`	以上	`score >= 70`	`score >= 70`
`<`	より小さい	`score < 50`	`score < 50`
`<=`	以下	`score <= 30`	`score <= 30`
かつ	両方の条件を満たす	`score >= 70 and score < 90`	`score >= 70 && score < 90`
または	どちらかの条件を満たす	`score < 0 or score > 100`	`score < 0 \|\| score > 100`

💡 TypeScriptの === と == の違い
TypeScript（JavaScript）では == と === の2種類があります。

演算子比較の仕方例

== 型を変換してから比較（緩い比較） "5" == 5 → true になる！

=== 型も含めて厳密に比較（厳格な比較） "5" === 5 → false

予期しないバグを防ぐため、TypeScript・JavaScriptでは === を使うのが基本ルール です。

5. 🔁 反復処理（Iteration）

一言で言うと

同じ処理を繰り返す構造です。
「全員に」「10回」「条件を満たすまで」といった繰り返しを書けます。

forループ：決まった回数・リストを繰り返す

# Python の例：リストの各要素を処理
fruits = ["りんご", "バナナ", "みかん"]

for fruit in fruits:
    print(f"🍎 {fruit}")

# 出力：
# 🍎 りんご
# 🍎 バナナ
# 🍎 みかん

// TypeScript の例
const fruits = ["りんご", "バナナ", "みかん"];

for (const fruit of fruits) {
  console.log(`🍎 ${fruit}`);
}

TypeScriptには他の構文もありますが、今回は割愛させて頂きます。ご興味のある方はご自身で調べてみてください。

whileループ：条件が満たされるまで繰り返す

# Python の例：カウントダウン
count = 5

while count > 0:
    print(f"カウント：{count}")
    count -= 1  # countを1減らす ← これがないと無限ループになる！

print("🚀 発射！")

# 出力：
# カウント：5
# カウント：4
# カウント：3
# カウント：2
# カウント：1
# 🚀 発射！

⚠️ 無限ループに注意！
while ループは条件がいつか必ず「偽（False）」になるように書かないと、
プログラムが永遠に止まらなくなります（無限ループ）。
PCやブラウザがフリーズする原因になるので注意しましょう。
# ❌ 無限ループの例（count が変化しないので永遠に繰り返す）
count = 5
while count > 0:
    print("止まらない！")
    # count -= 1 を書き忘れた → 永遠にループ 😱

breakとcontinue：ループの制御

# break：ループを途中で抜ける
for i in range(10):
    if i == 5:
        break       # 5になったら終了
    print(i)
# 出力：0 1 2 3 4

# continue：その回だけスキップして次へ
for i in range(5):
    if i == 2:
        continue    # 2のときだけスキップ
    print(i)
# 出力：0 1 3 4

※　range(n) → 0～n-1まで繰り返します

3つの反復処理の使い分け

種類	使う場面	例
`for`	リストや決まった回数の繰り返し	全ユーザーにメールを送る
`while`	条件が満たされるまで繰り返す	パスワードが正しくなるまで入力を求める
`break`	条件を満たしたらループを終了	探していたデータが見つかったら終了
`continue`	特定の条件のときだけスキップ	エラーデータを飛ばして処理を続ける

6. 🔧 関数（Function）

関数とは？

関数とは「処理をひとまとめにして、名前をつけて再利用できるようにしたもの」です。
同じ処理を何度も書かなくて済むようになります。

関数を使わない場合の問題

# ❌ 関数なし：同じ処理が繰り返される
print("==========")
print("こんにちは、Aliceさん！")
print("==========")

print("==========")
print("こんにちは、Bobさん！")
print("==========")

print("==========")
print("こんにちは、Charlieさん！")
print("==========")
# → 同じパターンが3回！修正するときに3か所直す必要がある

関数を使った場合

# ✅ 関数あり：一度定義して何度でも使える
def greet(name: str) -> None:
    """指定した名前に挨拶を表示する。

    Args:
        name: 挨拶する相手の名前
    """
    print("==========")
    print(f"こんにちは、{name}さん！")
    print("==========")

# 呼び出す
greet("Alice")
greet("Bob")
greet("Charlie")
# → 区切り線のデザインを変えたいときは1か所直すだけ！

関数の基本構造

def 関数名(引数1: 型, 引数2: 型) -> 戻り値の型:
    """docstring：この関数が何をするかの説明"""
    # 処理
    return 戻り値

function 関数名(引数1: 型, 引数2: 型): 戻り値の型 {
  // 処理
  return 戻り値;
}

引数と戻り値

関数は「自動販売機」のようなものです🥤

【自動販売機】
  お金 + ボタン（引数 / Input）
      ↓ 中で処理が行われる
  ジュース（戻り値 / Output）が出てくる

【関数】例：a＋bを実行する関数
  a=3, b=5（引数 / Input）
      ↓ 関数の中で処理が行われる
  8（戻り値 / Output）が返ってくる

自動販売機の中でどう冷やされているかは知らなくていい。
「何(お金)を入れると何(ジュース)が出てくるか」だけわかれば使えます。
関数も同じです！

# 引数（input）：関数に渡す値
# 戻り値（output）：関数が返す値

def add(a: int, b: int) -> int:
    """2つの数値を足し算する。

    Args:
        a: 1つ目の数値
        b: 2つ目の数値

    Returns:
        2つの数値の合計
    """
    return a + b

result = add(3, 5)   # 引数：3と5
print(result)        # 戻り値：8

良い関数の条件

条件	説明	目安
1つのことだけする	複数の責任を持たせない	関数名が1動詞で表現できる
短い	長すぎる関数は読みにくい	20〜30行以内
名前が明確	何をする関数かすぐわかる	`get_user`・`send_email` など
引数が少ない	引数が多いと使いにくい	3〜4個以内を目安に

7. 🌐 スコープ（Scope）

スコープとは？

スコープとは「変数が使える範囲」のことです。
どこで宣言した変数がどこから参照できるかを決めるルールです。

グローバルスコープとローカルスコープ

# グローバル変数：どこからでもアクセスできる
greeting = "こんにちは"   # ← グローバルスコープ

def say_hello(name: str) -> None:
    """名前に挨拶する。

    Args:
        name: 挨拶する相手の名前
    """
    # ローカル変数：この関数の中だけで使える
    message = f"{greeting}、{name}さん！"  # ← ローカルスコープ
    print(message)

say_hello("Alice")
print(greeting)   # ✅ グローバルなのでOK
print(message)    # ❌ エラー！関数の外からは使えない

スコープのイメージ

🌍 グローバルスコープ（プログラム全体）
  greeting = "こんにちは"

  📦 関数のスコープ（関数の中だけ）
    name = "Alice"
    message = "こんにちは、Aliceさん！"
    ↑ この変数は関数の外からは見えない

  📦 別の関数のスコープ
    name = "Bob"   ← 同じ名前でも別の変数！

なぜスコープが重要なのか

メリット	説明
🔒 変数の衝突を防ぐ	別の場所で同じ名前の変数を使っても干渉しない
🧹 メモリの効率化	関数が終わればローカル変数は自動で解放される
🐛 バグの範囲を限定する	変数の影響範囲が小さいほどバグを見つけやすい

ブロックスコープ（JavaScript・TypeScript）

// TypeScript の例
function example(): void {
  // if ブロックのスコープ
  if (true) {
    const blockVar = "ブロック内だけ";
    console.log(blockVar); // ✅ OK
  }
  console.log(blockVar);   // ❌ エラー！ブロックの外では使えない
}

💡 var より const / let を使おう！
JavaScriptの古い var はブロックスコープを無視して関数スコープになるため
意図しないバグを生みやすいです。
現代のJavaScript・TypeScriptでは const・let を使いましょう。

8. 🏷️ 型・静的型付け・動的型付け

型（Type）とは？

型とは「このデータは何種類のものか」を示すラベルです。
数値なのか・文字列なのか・真偽値なのかをコンピュータに伝えます。

よく使う基本的な型

型	意味	Python の例	TypeScript の例
整数型	小数のない数値	`int` → `42`	`number` → `42`
浮動小数点型	小数のある数値	`float` → `3.14`	`number` → `3.14`
文字列型	テキスト	`str` → `"hello"`	`string` → `"hello"`
真偽値型	真か偽か	`bool` → `True / False`	`boolean` → `true / false`
リスト・配列	複数の値の集まり	`list` → `[1, 2, 3]`	`number[]` → `[1, 2, 3]`
辞書・オブジェクト	キーと値のペア	`dict` → `{"name": "Alice"}`	`object` → `{name: "Alice"}`

静的型付け言語 vs 動的型付け言語

プログラミング言語は「型をいつチェックするか」によって2種類に分けられます。

静的型付け言語

「変数の型をコードに書いておく」言語です。
プログラムを実行する前に型の間違いを発見できます。

// TypeScript（静的型付け）の例
let age: number = 25;       // 型を明示的に書く
age = "二十五";              // ❌ コンパイル前にエラー！
// → 実行する前にミスを発見できる 🎯

特徴	内容
✅ バグを早期発見	実行前にエラーに気づける
✅ エディタの補完が強力	型情報をもとに候補を提示してくれる
✅ コードが読みやすい	変数に何が入るか一目でわかる
⚠️ 記述量が増える	型を書く分コードが長くなる

※　記述量に関してはAIを使ったコーディングが主流になり、苦になるとは言えないかもしれません。手書きのことは結構大きかったです。

動的型付け言語

「変数の型は実行時に自動で決まる」言語です。
型を書かなくてよい分、素早く書けます。

# Python（動的型付け）の例
age = 25          # 型を書かなくていい・自動でintになる
age = "二十五"    # ✅ エラーにならない（実行時に型が変わる）
print(age + 1)    # ❌ 実行してはじめてエラーが出る

特徴	内容
✅ 記述が少ない	型を書かなくていいので素早く書ける
✅ 柔軟に使える	同じ変数に違う型の値を入れられる
⚠️ バグの発見が遅れる	実行してみないと型のエラーに気づけない
⚠️ 大規模開発で管理が難しい	型情報がないとコードが読みにくくなる

Pythonの型ヒント（Type Hints）

動的型付けのPythonでも「型を書く」ことができます！
必須ではありませんが、書いておくとコードが読みやすくなります。

# 型ヒントなし（動的型付けらしい書き方）
def add(a, b):
    return a + b

# 型ヒントあり（静的型付けに近い書き方）
def add(a: int, b: int) -> int:
    """2つの整数を足し算する。

    Args:
        a: 1つ目の整数
        b: 2つ目の整数

    Returns:
        合計値
    """
    return a + b
# → 引数に int を、戻り値に int を期待していることが一目でわかる！

💡 このシリーズのコード例では型ヒントを積極的に使っています。
初心者のうちから型を意識する習慣をつけると、
TypeScript・Java・Goなど他の言語に移ったときにスムーズに学べます。

9. 🎯 まとめ

概念	一言で言うと	重要なポイント
📋 順次処理	上から順番に実行	コードは書いた順に動く
🔀 分岐処理	条件で処理を変える	`if / elif / else` で制御
🔁 反復処理	同じ処理を繰り返す	`for`（回数決まってる）/ `while`（条件次第）
🔧 関数	処理をまとめて再利用	1つのことだけ・短く・名前を明確に
🌐 スコープ	変数が使える範囲	ローカル変数は外から見えない
🏷️ 型	データの種類を示すラベル	静的型付け（実行前チェック）/ 動的型付け（実行時チェック）

「プログラムはどんなに複雑でも、順次・分岐・反復の組み合わせ。」
この3つを理解することがコーディングの出発点です💪

次回は 命名規則 を解説します！
変数・関数・クラスの名前のつけ方・キャメルケース・スネークケースなど、
チームで読みやすいコードを書くための命名の考え方を学びます🌟

💬 質問や感想があれば、コメント欄でお気軽にどうぞ!
👍 役に立ったら、いいね&ストックをお願いします!
🎓 ここまで読んでくださって、本当にありがとうございました!

🔗 シリーズ記事

【第一回】コードの基本構造（この記事）
【第二回】命名規則（近日公開）
【第三回】コードの設計原則（近日公開）
【第四回】コメント・ドキュメント（近日公開）
【第五回】エラーハンドリング（近日公開）
【第六回】テスト・ファイル構造・バージョン管理（近日公開）