【保存版】プログラミングの基本構文を初心者向けにわかりやすく解説【AI時代でも覚えるべき文法】

Mirai

プログラミングの基本構文って、何から覚えればいいんでしょうか?

Zetto

最初に押さえるべき構文は絞れますね。この記事で解説する構文を理解すれば、どんなプログラムも「読めるようになる」感覚が出てきますよ!

この記事では、JavaScriptをベースにプログラミングの基本構文を体系的に解説します。

本記事の専門性
現役フリーランスエンジニアのZettoです。Oracle認定Java Goldを保有し、JavaやTypeScript(Vue.js)を使った実務案件を複数経験しています。

プログラミングの基本構文を学ぼうとしたとき、「何から手をつければいいかわからない」と感じる方は多いです。

読み終わる頃には、基本構文の全体像が把握でき、「次に何を学べばいいか」まで見えるようになります。

ぜひ参考にしてみてください。

目次

プログラミングの基本構文とは

プログラミング基本構文

まず「プログラミングの基本構文」の意味と、なぜ今も自分で覚える必要があるのかを解説します。

  • 基本構文の意味と役割
  • AI時代でも基本構文を自分で覚える理由

基本構文の意味と役割

プログラミングの基本構文とは、コンピューターに指示を出すための「文法ルール」のことです。

人間同士の会話に日本語や英語の文法があるように、プログラミングにも言語ごとに決まった書き方のルールがあります。この文法ルールを「構文(シンタックス)」と呼びます。

構文は大きく分けると以下の要素で成り立っています。

  • データを扱う:変数・データ型・演算子
  • 処理を制御する:条件分岐・繰り返し処理
  • 処理をまとめる:関数・クラス
  • データをまとめる:配列・オブジェクト

構文を間違えると、コンピューターは命令を理解できずエラーを返してきます。

基本構文さえ押さえてしまえば、どのプログラミング言語を学ぶときにも応用が効きます。

AI時代でも基本構文を自分で覚える理由

「ChatGPTやCopilotがコードを書いてくれるなら、構文を覚える必要はないんじゃないか?」という疑問はよく聞きます。

結論から言うと、基本構文を自分で理解することは2026年現在でも必要です。理由は3つあります。

  • AIが生成したコードを読めないと、エラーが起きたときに対処できない
  • 「どんな処理をさせたいか」をAIに正しく指示するには、構文の知識が必要になる
  • コードレビューや設計の判断は、構文理解があってはじめてできる

僕自身、プライベートでAIを使ってアプリ開発をしていますが、AIが出してくれるコードを読んで意図を理解できるから使えています。構文がわからない状態でAIにコードを生成させるのは、セキュリティ的にも怖い部分があります。

AIは強力な相棒ですが、「基礎を理解した上で使う人」と「丸投げしている人」では、スキルの伸び方に大きな差が出ます。

Zetto

基本構文を理解すればAIが作ったコードも読めるし、指示だって正確に出せるようになります!

プログラミングの基本構文の書き方【基礎編】

基本構文7つのポイント

初心者が最初に覚えるべき基本構文を解説します!

  • 変数・定数|データを保存する仕組み
  • データ型|扱えるデータの種類
  • 演算子|計算・比較に使う記号
  • 条件分岐|処理を場合分けする方法
  • 繰り返し処理|同じ処理を自動化する仕組み
  • 関数|処理をひとまとめにする方法
  • 配列・オブジェクト|複数データを管理する方法

変数・定数|データを保存する仕組み

変数

変数とは、データを一時的に記憶しておく「箱」のことです。

たとえば「ユーザーの名前」「点数」「商品の値段」など、プログラムの中で使い回したい値に名前をつけて保存しておきます。

JavaScriptでは letconst を使って変数を作ります。

let score = 80;   // あとで変更する可能性がある値はlet
score = 90;       // letは上書きできる
console.log(score); // 90

let はあとから値を変更できます。一方 const は一度代入したら変更できません。

const name = "Zetto"; // 変更しない値はconst
// name = "Mirai";    // エラーになる
console.log(name);    // Zetto

2026年現在のJavaScriptでは、基本的に const を使い、値が変わるときだけ let を使うのが主流です。「変わらないものはconst、変わるものはlet」と覚えるだけで十分ですね。

定数

定数とは、一度値を代入したら変更できない変数のことです。JavaScriptでは const がこれに該当します。

const MAX_SCORE = 100;
const PI = 3.14159;

// MAX_SCORE = 200; // エラー:定数は再代入できない

定数は主に「設定値」や「変わらないルール」を表すときに使います。定数名はすべて大文字・アンダースコア区切りにするのが慣習です(例:MAX_SCOREAPI_URL)。

データ型|扱えるデータの種類

変数に入れるデータにはいくつかの「種類(型)」があります。これを「データ型」と呼びます。

数値型

整数・小数を問わず、数値はすべて Number 型として扱われます。

const age = 28;       // 整数
const price = 1980.5; // 小数

文字列型

テキストデータはクォートで囲んで表します。シングル・ダブル・バッククォートのいずれも使えます。

const name = "Zetto";       // 文字列型(ダブルクォート)
const greeting = 'こんにちは'; // 文字列型(シングルクォート)

数字の 1 と文字列の "1" は見た目が似ていても、コンピューターにとっては別物です。この違いを知っておくだけで、初心者が陥りがちなバグをかなり防げます。

console.log(1 + 2);      // 3(数値の計算)
console.log("1" + "2");  // "12"(文字列の結合になる)

真偽値型

true(真)か false(偽)の2値しか持たない型です。条件分岐と組み合わせてよく使います。

const isLoggedIn = true;  // ログイン済み
const isAdmin = false;    // 管理者ではない

その他の基本型として、値が「ない」ことを明示する null、値がまだ設定されていない undefined があります。また、複数データをまとめる型として配列(Array)とオブジェクト(Object)がありますが、こちらは後述します。

演算子|計算・比較に使う記号

演算子とは、計算・比較・論理判断をするための記号のことです。

算術演算子(計算)

console.log(10 + 3);  // 13(足し算)
console.log(10 - 3);  // 7(引き算)
console.log(10 * 3);  // 30(掛け算)
console.log(10 / 3);  // 3.333...(割り算)

比較演算子(比較)

2つの値を比べて truefalse を返します。

console.log(5 > 3);    // true(5は3より大きい)
console.log(5 < 3);    // false
console.log(5 == "5"); // true(値だけ比較・型は無視)
console.log(5 === "5");// false(値と型を両方比較)

===== の違いは重要です。=== は値と型の両方が一致したときに true を返します。現在のJavaScriptでは基本的に === を使うのがベストプラクティスです。

論理演算子

複数の条件を組み合わせるときに使います。

const a = true;
const b = false;

console.log(a && b); // false(AND:両方trueのときtrue)
console.log(a || b); // true(OR:どちらかtrueのときtrue)
console.log(!a);     // false(NOT:反転)

代入演算子

let x = 10;
x += 5;  // x = x + 5 と同じ → 15
console.log(x); // 15

+= は「今の値に足して代入する」演算子です。-=*=/= も同様に使えます。

条件分岐|処理を場合分けする方法

条件分岐とは、「もし〜なら〇〇する、そうでなければ△△する」という処理のことです。

if文の基本

const score = 75;

if (score >= 80) {
  console.log("合格です");
} else if (score >= 60) {
  console.log("もう少しです");
} else {
  console.log("不合格です");
}
// → "もう少しです"

else if で追加の条件を、else で「それ以外すべて」を書きます。条件は上から順番に評価されるので、書く順番が重要です。

switch文

条件の分岐が多い場合は switch 文が読みやすくなります。

const day = "月";

switch (day) {
  case "月":
    console.log("週の始まりですね");
    break;
  case "金":
    console.log("もうすぐ週末ですね");
    break;
  default:
    console.log("通常の平日ですね");
}

case の末尾に break を書き忘れると、次の case まで処理が流れてしまうので注意が必要です。

繰り返し処理|同じ処理を自動化する仕組み

繰り返し処理とは、同じ処理を指定した回数・条件が満たされる間だけ繰り返す仕組みです。

for文(回数が決まっているとき)

for (let i = 0; i < 5; i++) {
  console.log(i + "回目");
}
// 0回目 〜 4回目

for (初期値; 条件; 増減) { 処理 } という構造です。

while文(条件が満たされる間)

let count = 0;
while (count < 3) {
  console.log("count: " + count);
  count++;
}
// count: 0 〜 count: 2

条件の更新を忘れると無限ループになるので注意が必要です。

forEach(配列のループ)

配列の各要素に対して処理を行うときに使います。

const fruits = ["りんご", "バナナ", "みかん"];

fruits.forEach((fruit) => {
  console.log(fruit);
});
// りんご、バナナ、みかん

実務では for 文より forEach を使う場面が多いです。配列を扱うときはまず forEach を思い浮かべるといいかなと思います。

関数|処理をひとまとめにする方法

関数とは、よく使う処理に名前をつけてひとまとめにしたものです。同じ処理を何度も書かずに、関数を呼び出すだけで使い回せます。

関数定義・引数・戻り値

// 関数の定義
function greet(name) {       // nameが「引数」
  return "こんにちは、" + name + "さん!"; // returnが「戻り値」
}

// 関数の呼び出し
console.log(greet("Zetto")); // こんにちは、Zettoさん!
console.log(greet("Mirai")); // こんにちは、Miraiさん!

引数(ひきすう)は関数に渡す値、戻り値(もどりち)は関数が返す結果のことです。

アロー関数

2015年以降のJavaScriptで使える、より簡潔な書き方です。実務ではこちらが主流です。

const greet = (name) => "こんにちは、" + name + "さん!";

console.log(greet("Zetto")); // こんにちは、Zettoさん!

実務では無名関数よりアロー関数を使う場面の方が圧倒的に多いです。forEachmap などと組み合わせてよく使います。

配列・オブジェクト|複数データを管理する方法

配列

配列(Array)は、複数のデータを順番付きで管理する仕組みです。

const fruits = ["りんご", "バナナ", "みかん"];
console.log(fruits[0]); // りんご(0番目から始まる)
console.log(fruits.length); // 3(要素の数)

fruits.push("ぶどう");    // 末尾に追加
fruits.unshift("いちご"); // 先頭に追加

fruits.pop();    // 末尾を削除
fruits.shift();  // 先頭を削除

map は元の配列を変えずに新しい配列を作るので、実務でよく使います。

const fruits = ["りんご", "バナナ", "みかん"];

// map(各要素を加工した新しい配列を返す)
const upperFruits = fruits.map((fruit) => fruit + "!");
console.log(upperFruits); // ["りんご!", "バナナ!", "みかん!"]

map は元の配列を変えずに新しい配列を作るので、実務でよく使います。

オブジェクト

オブジェクト(Object)は、名前(キー)と値のセットでデータを管理する仕組みです。

const user = {
  name: "Zetto",
  age: 30,
  isEngineer: true
};

console.log(user.name); // Zetto(ドット記法)
console.log(user["age"]); // 30(ブラケット記法)

オブジェクトの中にオブジェクトや配列を入れることもできます(ネスト構造)。

const user = {
  name: "Zetto",
  address: {
    city: "大阪",
    country: "日本"
  },
  skills: ["Java", "TypeScript", "Vue.js"]
};

console.log(user.address.city); // 大阪
console.log(user.skills[0]);    // Java

実務ではAPIのレスポンスがこのようなネスト構造になっていることが多く、読み解けないと何もできなくなります。早めに慣れておきたい概念ですね。

Zetto

ここまで理解できれば、プログラミングの基礎は固まったと言っていいです。

プログラミングで頻出する基本構文

基本構文後に知ること

基礎構文を押さえたら、次は実務でよく登場する重要な概念を理解しましょう。

  • 入出力処理
  • エラー処理とデバッグ
  • スコープ|変数が使える範囲
  • コメント|コードを読みやすくする書き方
  • データ操作

入出力処理

プログラムはデータを受け取り(入力)、結果を出す(出力)という流れで動きます。

出力

JavaScriptで最もよく使う出力方法は console.log です。ブラウザの開発者ツールやNode.jsのコンソールに結果を表示します。

console.log("Hello, World!");  // テキストを出力
console.log(42);               // 数値を出力
console.log([1, 2, 3]);        // 配列を出力
console.log({ name: "Zetto"}); // オブジェクトを出力

console.error() はエラーメッセージ、console.warn() は警告の出力に使います。デバッグのときに使い分けると見やすくなります。

入力

ブラウザ上でユーザーから文字入力を受け取るときは prompt を使います。

const name = prompt("名前を入力してください");
console.log("こんにちは、" + name + "さん!");

実務では prompt よりもHTMLフォームからの入力取得を使う場面がほとんどです。

// HTMLに  がある場合
const input = document.getElementById("nameInput");
const name = input.value;
console.log("入力値:" + name);

出力は console.log、入力はブラウザなら prompt かHTMLフォームが基本です。実務ではフォーム入力の取得を使う場面がほとんどです。

エラー処理とデバッグ

エラーを適切に処理する仕組みを知っておくと、プログラムが予期しない動作で止まることを防げます。

エラー処理

エラーが発生しても処理を止めず、エラーを「捕まえて」対処する仕組みが try-catch です。

try {
  // エラーが起きるかもしれない処理
  const result = JSON.parse("不正なJSON文字列");
} catch (error) {
  // エラーが発生したときの処理
  console.error("エラーが発生しました:", error.message);
} finally {
  // エラーの有無に関わらず必ず実行される
  console.log("処理が完了しました");
}

finally はエラーの有無にかかわらず実行されます。ファイルのクローズ処理やローディング表示の終了など、「必ずやること」を書くときに使います。

構文エラー

コードの書き方が文法ルールに違反しているときに発生します。プログラムが実行される前に検出されます。

// セミコロンの抜けや括弧の閉じ忘れなど
console.log("Hello" // SyntaxError: 括弧が閉じていない

プログラムの実行中に発生するエラーを実行時エラーと呼びます。文法は正しくても、処理の途中で問題が起きます。

const user = null;
console.log(user.name); // TypeError: Cannot read properties of null

バグ(不具合)を見つけて修正する作業をデバッグと言います。console.log で変数の中身を確認しながら進めるのが基本です。ブラウザの開発者ツール(F12)のコンソールタブを使うと、リアルタイムで確認できます。僕自身、実務でも console.log を使ったデバッグは毎日やっていますね。

Zetto

エラーを「予測」して try-catch で対処しておくのが、安定したプログラムのコツですね。

スコープ|変数が使える範囲

スコープとは、変数が「どこから参照できるか」の範囲のことです。スコープを理解しておくと、変数の競合や予期しないバグを防げます。

グローバル変数

ファイルのどこからでもアクセスできる変数です。

const globalName = "Zetto"; // グローバル変数

function greet() {
  console.log(globalName); // 関数の中からでもアクセスできる
}

greet(); // Zetto

グローバル変数は便利ですが、どこからでも変更できるため、大きなプログラムではバグの原因になりやすいです。使いすぎには注意が必要ですね。

ローカル変数

関数の中で定義された変数で、その関数の中からしかアクセスできません。

function greet() {
  const localName = "Zetto"; // ローカル変数
  console.log(localName);
}

greet(); // Zetto
// console.log(localName); // エラー:関数の外からはアクセスできない

ブロックスコープ

{} で囲まれたブロック内で定義された変数は、そのブロック内でしか使えません。letconst はブロックスコープを持ちます。

if (true) {
  const blockVar = "ブロック内の変数";
  console.log(blockVar); // ブロック内でアクセスできる
}

// console.log(blockVar); // エラー:ブロックの外からはアクセスできない

スコープは「変数の有効範囲」です。var はブロックスコープを持たないため現在はほぼ使われません。グローバル変数の乱用を避け、必要な範囲で constlet を使うのが保守性の高いコードにつながります。

コメント|コードを読みやすくする書き方

コメントとは、コードの中に書く「人間向けの説明文」です。プログラムの実行には影響しません。

1行コメント

// から行末までがコメントになります。

// これはコメントです
const name = "Zetto"; // 変数nameにZettoを代入

複数行コメント

/**/ で囲んだ範囲がすべてコメントになります。

/*
  この関数はユーザーの名前を受け取り、
  挨拶文を返します。
  引数:name(文字列)
  戻り値:挨拶文(文字列)
*/
function greet(name) {
  return "こんにちは、" + name + "さん!";
}

「何をしているか」より「なぜしているか」を書くと、後から読んだときに理解しやすくなります。コードを読めばわかることをコメントに書く必要はありません。

Zetto

良いコメントは、後から読む自分や他のメンバーへのプレゼントですね。「なぜ」を意識します。

データ操作

文字列・数値・日付は実務で頻繁に扱います。よく使うメソッドを押さえておきましょう。

文字列操作

const str = "Hello, Zetto!";

console.log(str.length);            // 13(文字数)
console.log(str.toUpperCase());     // "HELLO, ZETTO!"(大文字に変換)
console.log(str.toLowerCase());     // "hello, zetto!"(小文字に変換)
console.log(str.includes("Zetto")); // true(含むか確認)
console.log(str.replace("Zetto", "Mirai")); // "Hello, Mirai!"(置換)
console.log(str.split(", "));       // ["Hello", "Zetto!"](分割)
console.log(str.trim());            // 前後の空白を削除

数値処理

console.log(Math.round(3.7));   // 4(四捨五入)
console.log(Math.floor(3.9));   // 3(切り捨て)
console.log(Math.ceil(3.1));    // 4(切り上げ)
console.log(Math.max(1, 5, 3)); // 5(最大値)
console.log(Math.min(1, 5, 3)); // 1(最小値)
console.log(Math.random());     // 0以上1未満のランダムな数

// 文字列を数値に変換
console.log(Number("42"));      // 42
console.log(parseInt("42px"));  // 42(整数部分を取得)

日付処理

const now = new Date();
console.log(now);                           // 現在の日時
console.log(now.getFullYear());             // 年(例:2026)
console.log(now.getMonth() + 1);            // 月(0始まりなので+1する)
console.log(now.getDate());                 // 日
console.log(now.toLocaleDateString("ja-JP")); // "2026/5/20"のような形式

日付の月は 0 始まりなので +1 が必要です。ここは初心者がよくはまるポイントなので覚えておくといいですね。文字列・数値・日付の操作メソッドは全部覚えなくても、「こういうメソッドがある」と知っておくだけで、調べながら使えるようになります。

実務でよく使う重要構文【応用編】

基本構文7つのポイント

実務で特によく使う便利な構文を紹介します。モダンなJavaScriptの書き方として定番のものばかりです。

  • コードを簡潔に書く構文
  • オブジェクト指向の基本
  • 非同期処理の基本

コードを簡潔に書く構文

条件演算子(三項演算子)

if-else を1行で書ける構文です。

const score = 75;

// 条件演算子で1行で書く
const result = score >= 60 ? "合格" : "不合格";
console.log(result); // 合格

条件 ? trueのとき : falseのとき という形です。シンプルな条件分岐をすっきり書けます。

分割代入

配列やオブジェクトから値を取り出して変数に代入する構文です。

// 配列の分割代入
const [first, second, third] = ["りんご", "バナナ", "みかん"];
console.log(first);  // りんご

// オブジェクトの分割代入
const user = { name: "Zetto", age: 30, city: "大阪" };
const { name, age } = user;
console.log(name); // Zetto
console.log(age);  // 30

実務ではAPIのレスポンスからデータを取り出すときに毎日使います。

スプレッド構文

配列やオブジェクトを展開する構文です。

// 配列の結合
const arr1 = [1, 2, 3];
const arr2 = [4, 5, 6];
const merged = [...arr1, ...arr2];
console.log(merged); // [1, 2, 3, 4, 5, 6]

// オブジェクトの結合
const defaults = { theme: "light", lang: "ja" };
const userSettings = { lang: "en", fontSize: 14 };
const settings = { ...defaults, ...userSettings };
console.log(settings); // { theme: "light", lang: "en", fontSize: 14 }

テンプレートリテラル

バッククォート(`)を使った文字列の書き方です。変数を ${} で埋め込めます。

const name = "Zetto";
const age = 30;

// 従来の書き方
console.log("こんにちは、" + name + "さん。" + age + "歳ですね。");

// テンプレートリテラル
console.log(`こんにちは、${name}さん。${age}歳ですね。`);
// こんにちは、Zettoさん。30歳ですね。

条件演算子・分割代入・スプレッド構文・テンプレートリテラルは、モダンなJavaScriptで必ずといっていいほど登場します。最初は読めるようになることを目標にしましょう。

Zetto

これらの構文は読めると、実務のコードがぐっと読みやすくなりますね。最初は難しく感じても、慣れると手放せなくなります。

オブジェクト指向の基本

オブジェクト指向とは、データと処理をひとまとめにした「クラス」という設計図を使ってプログラムを書く考え方です。

クラス

クラスはオブジェクトの「設計図」です。constructor はクラスからオブジェクトを作るときに最初に呼ばれる特別なメソッドです。

class User {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  greet() {
    return `こんにちは、${this.name}です。${this.age}歳です。`;
  }
}

インスタンス

クラス(設計図)をもとに作った実体をインスタンスと呼びます。new キーワードでクラスからインスタンスを生成します。

const zetto = new User("Zetto", 30);
const mirai = new User("Mirai", 25);

console.log(zetto.greet()); // こんにちは、Zettoです。30歳です。
console.log(mirai.greet()); // こんにちは、Miraiです。25歳です。

同じ設計図から異なる値を持つオブジェクトを何個でも作れるのがクラスのメリットです。

継承

既存のクラスを引き継いで、新しいクラスを作る仕組みです。

class Engineer extends User {
  constructor(name, age, skill) {
    super(name, age); // 親クラスのconstructorを呼ぶ
    this.skill = skill;
  }

  introduce() {
    return `${this.greet()} メインスキルは${this.skill}です。`;
  }
}

const zetto = new Engineer("Zetto", 30, "TypeScript");
console.log(zetto.introduce());
// こんにちは、Zettoです。30歳です。 メインスキルはTypeScriptです。

クラスは「設計図」、インスタンスは「設計図から作った実体」です。extends で親クラスを継承し、super で親クラスのメソッドを呼び出します。ReactやVue.jsを学ぶ前にオブジェクト指向の考え方を押さえておくと、理解がスムーズになります。

非同期処理の基本

非同期処理とは、時間のかかる処理(API通信・ファイル読み込みなど)を待っている間も、他の処理を続けられる仕組みです。現代のJavaScript開発では必須の知識です。

Promise

非同期処理の結果(成功・失敗)を扱うオブジェクトです。

const fetchData = new Promise((resolve, reject) => {
  setTimeout(() => {
    const success = true;
    if (success) {
      resolve("データの取得に成功しました");
    } else {
      reject("エラーが発生しました");
    }
  }, 1000); // 1秒後に実行
});

fetchData
  .then((result) => console.log(result))  // 成功時
  .catch((error) => console.error(error)); // 失敗時

async/await

Promise をより読みやすく書ける構文です。実務ではこちらを使う場面がほとんどです。

async function getData() {
  try {
    const response = await fetch("https://api.example.com/users");
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error("エラー:", error);
  }
}

getData();

async をつけた関数の中で await が使えます。await はPromiseが解決されるまで処理を待ちます。try-catch と組み合わせてエラー処理もセットで書くのが定番の書き方です。

Zetto

API通信なしに現代のWebアプリ開発はあり得ませんね。async/awaitはしっかり練習します。

プログラミング実践で必須の知識

基本構文後に知ること

Webアプリ開発では、サーバーとデータをやり取りする場面や、チームで読みやすいコードを書く場面が多く出てきます。

  • API・データ通信の基本
  • 読みやすく保守しやすいコードを書く考え方

API・データ通信の基本

JSON

JSON(JavaScript Object Notation)は、データを文字列でやり取りするための形式です。APIのレスポンスはほぼJSONで返ってきます。

// オブジェクト → JSON文字列に変換
const user = { name: "Zetto", age: 30 };
const jsonString = JSON.stringify(user);
console.log(jsonString); // '{"name":"Zetto","age":30}'

// JSON文字列 → オブジェクトに変換
const parsed = JSON.parse(jsonString);
console.log(parsed.name); // Zetto

JSON.stringifyJSON.parse はAPIを扱うときに頻繁に使います。

API

API(Application Programming Interface)とは、異なるサービス同士がデータをやり取りするための窓口です。たとえば「天気予報APIに都市名を送ると、現在の天気データが返ってくる」というイメージです。

// 天気APIのレスポンス例(JSON形式)
const weatherData = {
  city: "大阪",
  temperature: 28,
  condition: "晴れ"
};

console.log(`${weatherData.city}の気温は${weatherData.temperature}℃です`);
// 大阪の気温は28℃です

HTTP通信

WebブラウザとサーバーがデータをやりとりするときはHTTPという通信規格を使います。主なHTTPメソッドは以下の通りです。

メソッド用途
GETデータの取得
POSTデータの送信・作成
PUTデータの更新(全体)
DELETEデータの削除
// POSTでデータを送信する例
async function createUser(userData) {
  const response = await fetch("https://api.example.com/users", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(userData)
  });

  return response.json();
}

JSONはデータのやり取り形式、APIはサービス間の窓口、HTTPは通信の規格です。この3つはWebアプリ開発の基本セットです。

Mirai

JSON・API・HTTPの関係性がクリアになりました。これらを組み合わせてサーバーと通信するんですね。

読みやすく保守しやすいコードを書く考え方

コードを書けるようになった後は、「読みやすく・直しやすいコード」を意識することが重要です。

DRY原則

DRY(Don’t Repeat Yourself)は「同じことを繰り返さない」という原則です。

// NG:同じ処理を繰り返している
console.log("ユーザー名:田中");
console.log("ユーザー名:鈴木");
console.log("ユーザー名:佐藤");

// OK:関数にまとめる
function printUser(name) {
  console.log("ユーザー名:" + name);
}

printUser("田中");
printUser("鈴木");
printUser("佐藤");

同じコードが複数箇所にあると、修正するときにすべての箇所を直す必要が出てきます。関数やコンポーネントにまとめることで、1か所の修正で済むようになります。

可読性

可読性とは、コードが「どれだけ読みやすいか」です。変数名・関数名はその役割が一目でわかる名前にすることが大切です。

// 可読性が低い
const x = (a, b) => a > b ? a : b;

// 可読性が高い
function getMaxValue(firstNumber, secondNumber) {
  return firstNumber > secondNumber ? firstNumber : secondNumber;
}

僕が実務で意識しているのは「コードを読んで声に出して意味が言えるか」ですね。声に出して意味が言えないコードは、他の人にも読みにくいコードです。

保守性

保守性とは、「後から変更や修正がしやすいか」です。

  • 1つの関数は1つのことだけをする
  • 関数は短くシンプルに保つ
  • マジックナンバー(意味のわからない数字)を避け、定数にする
// NG:マジックナンバー
if (score > 80) { /* 処理 */ }

// OK:定数にして意味を明示する
const PASS_SCORE = 80;
if (score > PASS_SCORE) { /* 処理 */ }

命名規則

JavaScriptでよく使われる命名規則は以下の通りです。

対象規則
変数・関数キャメルケースuserNamegetScore
クラスパスカルケースUserProfileApiClient
定数スネークケース(大文字)MAX_SCOREAPI_URL

DRY・可読性・保守性・命名規則は「書けるコード」を「使えるコード」に変えるための考え方です。最初から完璧にできなくていいですが、意識しながらコードを書く習慣をつけていきましょう。

Zetto

「書ける」から「保守できる」コードへ。この視点の切り替えがプロのエンジニアへの第一歩ですね。

プログラミング基本構文のよくある質問(FAQ)

よくある質問

基本構文は全部覚えてから次に進むべきですか?

全部完璧に覚えてから、という必要はないです。

「変数って何?」「if文って何をする構文?」という問いにすらすら答えられるレベルを目指し、あとは手を動かしながら覚えていくのが最も効率がいいです。

プロのエンジニアでも細かい書き方はその都度調べながらコードを書いています。100点を目指さず、70点で次に進むくらいの心持ちがちょうどいいですね。

複数の言語の構文を同時に学ぶのはアリですか?

初心者のうちはやめた方がいいです。

構文の書き方が似ていても微妙に違うので、混乱してどちらも定着しないケースが多いです。まず1言語の基本構文をしっかり理解してから、2言語目に移るのが結果的に早くなります。

構文を覚えてもプログラムが作れない場合はどうすればいいですか?

「構文を知っている」と「プログラムを作れる」は別のスキルです。

最初はお題(電卓・タイマー・じゃんけんなど)を1つ決めて、答えをAIに聞きながらでもいいので手を動かしてみてください。

「答えを見ながら写経する」だけでも、構文の使い方の感覚が一気に身につきます。最初から自力で作れなくても問題ありません。

まとめ|基本構文を「使える」に変えるために

実践的な構文スキル

この記事で解説したプログラミングの基本構文を整理します。

  • 変数・定数:データを入れる箱。const を基本に let を使い分ける
  • データ型:数値・文字列・真偽値・null・undefinedが基本型。配列・オブジェクトが複合型
  • 演算子:算術・比較・論理・代入の4種類を押さえる
  • 条件分岐:if文・switch文で処理を場合分けする
  • 繰り返し処理:for文・while文・forEachを目的に応じて使い分ける
  • 関数:処理をまとめて再利用できるようにする。アロー関数が実務の主流
  • 配列・オブジェクト:複数データをまとめる。配列は順番付き、オブジェクトは名前付き
  • エラー処理:try-catchでエラーを捕まえて対処する
  • スコープ:変数の有効範囲を理解してバグを防ぐ
  • 非同期処理:async/awaitでAPI通信などの非同期処理をシンプルに書く
  • 重要構文:条件演算子・分割代入・スプレッド構文・テンプレートリテラル

次のアクションとして、今回解説した構文を1つずつ実際にコードを書いて確認してみてください。読んだだけより書いた方が、記憶への定着が全然違います。

Mirai

基本構文の全体像がすっきりしました!何から覚えればいいかがよくわかりました。

Zetto

まずは1つずつ手を動かして試してみてくださいね。「読んだ」より「書いた」の方が、記憶に残りますよ!

プログラミングを効率よく学び、最短でエンジニアになるならプログラミングスクールがおすすめです。下記で僕も受講したことのあるスクールを含め、まとめているので、ぜひ参考にしてみてください。

よかったらシェアしてね!
  • URLをコピーしました!
  • URLをコピーしました!
目次