<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>JavaScript基礎 | React入門</title>
	<atom:link href="https://react-js.jp/category/javascript/feed" rel="self" type="application/rss+xml" />
	<link>https://react-js.jp</link>
	<description>WebアプリUI構築のためのJavaScriptライブラリ</description>
	<lastBuildDate>Thu, 19 Nov 2026 02:32:46 +0000</lastBuildDate>
	<language>ja</language>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	<generator>https://wordpress.org/?v=7.1.5</generator>

<image>
	<url>https://react-js.jp/wp-content/uploads/cropped-React_logo_logotype_emblem_512-32x32.png</url>
	<title>JavaScript基礎 | React入門</title>
	<link>https://react-js.jp</link>
	<width>32</width>
	<height>32</height>
</image> 
<atom:link rel="hub" href="https://pubsubhubbub.appspot.com"/>
<atom:link rel="hub" href="https://pubsubhubbub.superfeedr.com"/>
<atom:link rel="hub" href="https://websubhub.com/hub"/>
<atom:link rel="self" href="https://react-js.jp/category/javascript/feed"/>
	<item>
		<title>JavaScriptの分割代入とは？オブジェクト・配列の書き方とReactでの活用例</title>
		<link>https://react-js.jp/destructuring-assignment</link>
					<comments>https://react-js.jp/destructuring-assignment#respond</comments>
		
		<dc:creator><![CDATA[りあぴ]]></dc:creator>
		<pubDate>Thu, 19 Nov 2026 02:30:52 +0000</pubDate>
				<category><![CDATA[JavaScript基礎]]></category>
		<category><![CDATA[JavaScript]]></category>
		<category><![CDATA[React]]></category>
		<category><![CDATA[Tips]]></category>
		<category><![CDATA[モダンJavaScript]]></category>
		<guid isPermaLink="false">https://react-js.jp/?p=116</guid>

					<description><![CDATA[JavaScriptのサンプルコードや公式ドキュメントを読み始めると、関数の引数に function Profile({ name, age }) のように波括弧 {} がいきなり出てきて「これってどういう意味？」と手が [&#8230;]]]></description>
										<content:encoded><![CDATA[<p>JavaScriptのサンプルコードや公式ドキュメントを読み始めると、関数の引数に function Profile({ name, age }) のように波括弧 {} がいきなり出てきて「これってどういう意味？」と手が止まることがあります。</p>
<p>私がJavaScriptを勉強し始めたころも、チュートリアルのコードに出てくる ({ name, age }) という書き方がいまいち読めなくて、props.name で書き直していた時期がありました。</p>
<p>その正体が、モダンJavaScriptで頻繁に使われる分割代入（Destructuring）です。最初は見慣れない記号の並びに戸惑うかもしれませんが、仕組み自体は「オブジェクトや配列の中身を一気に変数へ取り出すショートカット」にすぎません。</p>
<p>この記事では、オブジェクトと配列それぞれの分割代入の書き方と、React開発で毎日目にする定番パターンを整理します。</p>

  <div id="toc" class="toc tnt-number toc-center tnt-number border-element"><input type="checkbox" class="toc-checkbox" id="toc-checkbox-2" checked><label class="toc-title" for="toc-checkbox-2">目次</label>
    <div class="toc-content">
    <ol class="toc-list open"><li><a href="#toc1" tabindex="0">オブジェクトの分割代入</a></li><li><a href="#toc2" tabindex="0">別の変数名で受け取る・デフォルト値を決める</a></li><li><a href="#toc3" tabindex="0">配列の分割代入</a></li><li><a href="#toc4" tabindex="0">React開発で分割代入がよく登場する2つの場面</a><ol><li><a href="#toc5" tabindex="0">1. コンポーネントの props を受け取るとき</a></li><li><a href="#toc6" tabindex="0">2. useState などのフックを使うとき</a></li></ol></li><li><a href="#toc7" tabindex="0">まとめ</a></li></ol>
    </div>
  </div>

<h2><span id="toc1">オブジェクトの分割代入</span></h2>
<p>通常、オブジェクトからプロパティを取り出して変数に入れようとすると、以下のようにプロパティの数だけ行が増えてしまいます。</p>
<pre><code>const user = {
  name: "りあぴ",
  age: 17,
  lang: "JavaScript"
};

// 従来の取り出し方
const name = user.name;
const age = user.age;

console.log(name, age);
// "りあぴ" 17</code></pre>
<p>分割代入を使うと、左辺を {} で囲むことで、同じ名前のプロパティをまとめて変数に取り出せます。</p>
<pre><code>const user = {
  name: "りあぴ",
  age: 17,
  lang: "JavaScript"
};

// 分割代入を使った取り出し方
const { name, age } = user;

console.log(name, age);
// "りあぴ" 17</code></pre>
<p>user. を何度も書かなくて済むので、取り出したい項目が増えるほどコードがだいぶスッキリします。必要なプロパティだけを指定すればよいので、lang のように使わない項目は書かなくて大丈夫です。</p>
<h2><span id="toc2">別の変数名で受け取る・デフォルト値を決める</span></h2>
<p>オブジェクトの分割代入には、実務でよく使われる便利な書き方が2つあります。</p>
<p>ひとつは別の変数名（エイリアス）を付ける書き方です。すでに同じ名前の変数が存在しているときに重宝します。コロン : の右側に新しい変数名を書きます。</p>
<pre><code>const user = { name: "りあぴ" };

// name プロパティを userName という変数名で取り出す
const { name: userName } = user;

console.log(userName);
// "りあぴ"</code></pre>
<p>もうひとつは、プロパティが undefined だったときのデフォルト値（初期値）を指定する書き方です。イコール = を使って指定します。</p>
<pre><code>const user = { name: "りあぴ" };

// role が存在しない（undefined）なので "一般ユーザー" が入る
const { name, role = "一般ユーザー" } = user;

console.log(name, role);
// "りあぴ" "一般ユーザー"</code></pre>
<p><a href="https://react-js.jp/nullish-coalescing">以前の記事で紹介したNull合体演算子（??）</a>と少し似ていますが、分割代入の = は undefined のときだけ初期値が使われ、null のときは null のままになるという違いがあります。ひとまず「プロパティが省略されたときの保険」として覚えておけば十分です。</p>
<h2><span id="toc3">配列の分割代入</span></h2>
<p>配列でも同じように分割代入が使えます。オブジェクトが「プロパティ名」で取り出すのに対し、配列は「並んでいる順番（インデックス）」で変数に入ります。囲む記号も {} ではなく角括弧 [] になります。</p>
<pre><code>const colors = ["赤", "青", "黄色"];

// 0番目から順番に変数へ入る
const [first, second] = colors;

console.log(first, second);
// "赤" "青"</code></pre>
<p>途中の要素を飛ばしたいときは、カンマ , だけを書いてスペースを空けます。</p>
<pre><code>const colors = ["赤", "青", "黄色"];

// 2番目の "青" を飛ばして3番目だけ取る
const [first, , third] = colors;

console.log(first, third);
// "赤" "黄色"</code></pre>
<p>配列の分割代入は、オブジェクトほど頻繁には使いませんが、次に紹介するReactの「フック（Hooks）」で毎回登場します。</p>
<h2><span id="toc4">React開発で分割代入がよく登場する2つの場面</span></h2>
<p>Reactを書いていると、分割代入はほぼすべてのファイルに登場します。特に以下の2つの形はよく見かける定番パターンです。</p>
<h3><span id="toc5">1. コンポーネントの props を受け取るとき</span></h3>
<p>親コンポーネントから渡されたデータ（props）を、関数の引数部分でそのまま分割代入して受け取る書き方です。</p>
<pre><code>// 分割代入を使わない場合（毎回 props. を書く必要がある）
function UserCard(props) {
  return (
    &lt;div&gt;
      &lt;h2&gt;{props.name}&lt;/h2&gt;
      &lt;p&gt;好きな言語：{props.lang}&lt;/p&gt;
    &lt;/div&gt;
  );
}

// 分割代入を使う場合（現在の一般的な書き方）
function UserCard({ name, lang = "未設定" }) {
  return (
    &lt;div&gt;
      &lt;h2&gt;{name}&lt;/h2&gt;
      &lt;p&gt;好きな言語：{lang}&lt;/p&gt;
    &lt;/div&gt;
  );
}</code></pre>
<p>関数の丸括弧 () の中に波括弧 {} が入っているので最初はギョッとしますが、「props というオブジェクトから name と lang をその場で取り出しているだけ」と分かれば読みやすくなります。</p>
<h3><span id="toc6">2. useState などのフックを使うとき</span></h3>
<p>Reactで画面の状態（State）を管理する useState という機能は、「現在の値」と「値を更新する関数」の2つを配列で返してきます。それを配列の分割代入で受け取るのがお決まりのスタイルです。</p>
<pre><code>import { useState } from "react";

function Counter() {
  // useState が返す配列から、値と更新関数を順番に取り出している
  const [count, setCount] = useState(0);

  return (
    &lt;button onClick={() =&gt; setCount(count + 1)}&gt;
      クリック回数：{count}
    &lt;/button&gt;
  );
}</code></pre>
<p>この [count, setCount] という書き方は、特別なReact専用文法ではなく、JavaScript標準の「配列の分割代入」そのものです。</p>
<h2><span id="toc7">まとめ</span></h2>
<p>分割代入は、オブジェクトや配列から必要な値だけをスッキリ取り出すための書き方です。</p>
<ul>
<li>オブジェクト： const { name, age = 20 } = user;（名前で取り出す・{} を使う）</li>
<li>配列： const [first, second] = array;（順番で取り出す・[] を使う）</li>
</ul>
<p>最初は見慣れない記号に戸惑うかもしれませんが、Reactのコードを読み書きしていると自然と手が覚えていきます。まずは props の受け取り方から少しずつ使ってみてください。</p>
]]></content:encoded>
					
					<wfw:commentRss>https://react-js.jp/destructuring-assignment/feed</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>JavaScriptのNull合体演算子（??）とは？&#124;&#124;（OR演算子）との違いを解説</title>
		<link>https://react-js.jp/nullish-coalescing</link>
					<comments>https://react-js.jp/nullish-coalescing#respond</comments>
		
		<dc:creator><![CDATA[りあぴ]]></dc:creator>
		<pubDate>Thu, 19 Nov 2026 01:56:39 +0000</pubDate>
				<category><![CDATA[JavaScript基礎]]></category>
		<category><![CDATA[JavaScript]]></category>
		<category><![CDATA[React]]></category>
		<category><![CDATA[Tips]]></category>
		<category><![CDATA[モダンJavaScript]]></category>
		<guid isPermaLink="false">https://react-js.jp/?p=112</guid>

					<description><![CDATA[JavaScriptで変数に初期値（デフォルト値）を入れたいとき、昔からよく使われてきたのが &#124;&#124;（OR演算子）です。ただ、最近のコードを読んでいると、ハテナを2つ並べた ??（Null合体演算子）を見かけることが増えて [&#8230;]]]></description>
										<content:encoded><![CDATA[<p>JavaScriptで変数に初期値（デフォルト値）を入れたいとき、昔からよく使われてきたのが ||（OR演算子）です。ただ、最近のコードを読んでいると、ハテナを2つ並べた ??（Null合体演算子）を見かけることが増えてきました。</p>
<p>どちらも「値がなかったら代わりの値を使う」という似た動きをしますが、実は数値の 0 や空文字 &#8220;&#8221; を扱ったときに結果が変わってきます。ついうっかり || のまま書いてしまって「なぜか 0 が消えて初期値に上書きされる……」とハマりがちなポイントなので、この機会に違いを整理しておきましょう。</p>

  <div id="toc" class="toc tnt-number toc-center tnt-number border-element"><input type="checkbox" class="toc-checkbox" id="toc-checkbox-4" checked><label class="toc-title" for="toc-checkbox-4">目次</label>
    <div class="toc-content">
    <ol class="toc-list open"><li><a href="#toc1" tabindex="0">Null合体演算子（??）とは？</a></li><li><a href="#toc2" tabindex="0">昔からある ||（OR演算子）との違い</a></li><li><a href="#toc3" tabindex="0">オプショナルチェーン（?.）との組み合わせ</a></li><li><a href="#toc4" tabindex="0">React開発で ?? が役立つ場面</a></li><li><a href="#toc5" tabindex="0">どう使い分ければいい？（迷ったときの基準）</a></li></ol>
    </div>
  </div>

<h2><span id="toc1">Null合体演算子（??）とは？</span></h2>
<p>Null合体演算子（Nullish Coalescing Operator）は、左側の値が null または undefined のときだけ、右側の値を返してくれる演算子です（ES2020で導入されました）。</p>
<pre><code>const name = null;
const displayName = name ?? "ゲスト";

console.log(displayName);
// "ゲスト"</code></pre>
<p>左側の name が null なので、右側の &#8220;ゲスト&#8221; が使われました。undefined の場合も同じ動きになります。</p>
<p>一方で、左側にちゃんとした値が入っていれば、そのまま左側の値が返ってきます。</p>
<pre><code>const name = "りあぴ";
const displayName = name ?? "ゲスト";

console.log(displayName);
// "りあぴ"</code></pre>
<h2><span id="toc2">昔からある ||（OR演算子）との違い</span></h2>
<p>では、昔から使われてきた || と何が違うのでしょうか。|| は null や undefined だけでなく、JavaScriptで「偽（falsy）」と判定される値すべてに反応して右側の値を返してしまいます。</p>
<p>JavaScriptで偽（falsy）扱いになる主な値は以下の通りです。</p>
<ul>
<li>null</li>
<li>undefined</li>
<li>0（数値のゼロ）</li>
<li>&#8220;&#8221;（空文字）</li>
<li>false</li>
<li>NaN</li>
</ul>
<p>つまり、「値として有効なはずの 0 や空文字 &#8220;&#8221;」まで「値がない」とみなされてしまうのが || の弱点です。</p>
<p>実際にコンソールで動かして見比べてみると違いがはっきり分かります。</p>
<pre><code>const count = 0;

// || を使うと、0 が無視されて 10 になってしまう
console.log(count || 10);
// 10

// ?? を使うと、0 がそのまま有効な値として使われる
console.log(count ?? 10);
// 0</code></pre>
<p>ゲームのスコアや商品の在庫数、アンケートの回答数など、0 という数字そのものに意味があるデータを扱うとき、|| を使っていると気づかないうちにバグを生みやすくなります。</p>
<p>空文字 &#8220;&#8221; でも同じことが起きます。</p>
<pre><code>const message = "";

// || だと空文字が上書きされる
console.log(message || "メッセージなし");
// "メッセージなし"

// ?? だと空文字のまま通る
console.log(message ?? "メッセージなし");
// ""</code></pre>
<p>「ユーザーが意図的に空欄で保存したデータ」をそのまま扱いたいときは ?? の方が安全です。</p>
<h2><span id="toc3">オプショナルチェーン（?.）との組み合わせ</span></h2>
<p>Null合体演算子（??）は、<a href="https://react-js.jp/optional-chaining">以前の記事で紹介したオプショナルチェーン（?.）</a>と組み合わせて使うのが定番です。</p>
<p>外部APIから取得したデータのように、階層が深くて途中の項目が抜けているかもしれないオブジェクトから値を取り出すとき、以下のように書けます。</p>
<pre><code>const user = {
  name: "りあぴ",
  score: 0
  // profile はまだ作られていない
};

// profile.bio は存在しないので「自己紹介未設定」になる
const bio = user.profile?.bio ?? "自己紹介未設定";
console.log(bio);
// "自己紹介未設定"

// score は 0 なので、0 がそのまま表示される
const score = user.score ?? "未計測";
console.log(score);
// 0</code></pre>
<p>?. でエラーを防ぎつつ、最後の仕上げに ?? で表示用のデフォルト値を添える流れは、実際の開発でもよく使われる書き方です。</p>
<h2><span id="toc4">React開発で ?? が役立つ場面</span></h2>
<p>Reactでコンポーネントを作っていると、親から渡ってくる props や、サーバーから取得したデータの初期値設定で ?? がよく登場します。</p>
<p>たとえば、商品の価格やポイント数を表示するコンポーネントを考えてみます。</p>
<pre><code>function PointBadge({ point }) {
  // point が未取得（undefined）のときだけ「--」にする
  // 0ポイントのときはちゃんと「0 pt」と表示したい
  return (
    &lt;span&gt;保有ポイント：{point ?? "--"} pt&lt;/span&gt;
  );
}</code></pre>
<p>もしここを {point || &#8220;&#8211;&#8220;} と書いてしまうと、本当に 0 ポイントのユーザーに対して「保有ポイント：&#8211; pt」と表示されてしまいます。数値や真偽値（true / false）が入りうる場所では、迷わず ?? を使うようにすると安心です。</p>
<h2><span id="toc5">どう使い分ければいい？（迷ったときの基準）</span></h2>
<p>最初からすべての場面を厳密に覚えようとしなくても大丈夫です。普段コードを書くときは、次の基準だけ意識しておけば困りません。</p>
<ul>
<li>基本は ?? を使う（null と undefined のときだけ初期値にしたい場合がほとんどなため）</li>
<li>空文字 &#8220;&#8221; や 0 のときも初期値に置き換えたい場合だけ || を使う（例：フォームが未入力（&#8221;&#8221;）のときに「未入力」と出したいときなど）</li>
</ul>
<p>昔からの慣れでつい || を書いてしまいがちですが、今は「デフォルト値といえばまず ??」くらいに考えておくと安全です。</p>
<p>なお、オブジェクトから値を取り出すときにデフォルト値を指定する方法として、<a href="https://react-js.jp/destructuring-assignment">分割代入</a>の書き方もあります。?? とは効き方が少し違うので、あわせて確認してみてください。</p>
]]></content:encoded>
					
					<wfw:commentRss>https://react-js.jp/nullish-coalescing/feed</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>JavaScriptのオプショナルチェーン（?.）とは？</title>
		<link>https://react-js.jp/optional-chaining</link>
					<comments>https://react-js.jp/optional-chaining#respond</comments>
		
		<dc:creator><![CDATA[りあぴ]]></dc:creator>
		<pubDate>Thu, 19 Nov 2026 00:42:59 +0000</pubDate>
				<category><![CDATA[JavaScript基礎]]></category>
		<category><![CDATA[JavaScript]]></category>
		<category><![CDATA[React]]></category>
		<category><![CDATA[Tips]]></category>
		<category><![CDATA[モダンJavaScript]]></category>
		<guid isPermaLink="false">https://react-js.jp/?p=103</guid>

					<description><![CDATA[JavaScriptでWebAPIから取得したデータや、階層が深いオブジェクトから値を取り出すとき、「途中のプロパティが存在しなくてエラーになってしまった！」という経験はありませんか？ かつては if 文や &#038; [&#8230;]]]></description>
										<content:encoded><![CDATA[<p>JavaScriptでWebAPIから取得したデータや、階層が深いオブジェクトから値を取り出すとき、「途中のプロパティが存在しなくてエラーになってしまった！」という経験はありませんか？</p>
<p>かつては if 文や &#038;&#038;、in 演算子などを何重にも書いて安全確認をしていましたが、現在のJavaScriptではオプショナルチェーン（?.）を使うだけで、スッキリと安全に書けるようになっています。</p>
<p>この記事では、オプショナルチェーンの基本的な使い方と、React開発でどのように役立つのかを初心者向けに解説します。</p>

  <div id="toc" class="toc tnt-number toc-center tnt-number border-element"><input type="checkbox" class="toc-checkbox" id="toc-checkbox-6" checked><label class="toc-title" for="toc-checkbox-6">目次</label>
    <div class="toc-content">
    <ol class="toc-list open"><li><a href="#toc1" tabindex="0">オプショナルチェーン（?.）とは？</a></li><li><a href="#toc2" tabindex="0">昔はどう書いていたの？（if 文や &#038;&#038;、in 演算子の苦労）</a><ol><li><a href="#toc3" tabindex="0">昔の書き方その1：if 文を入れ子にする</a></li><li><a href="#toc4" tabindex="0">昔の書き方その2：&#038;&#038;（論理積）でつなぐ</a></li><li><a href="#toc5" tabindex="0">昔の書き方その3：in 演算子でプロパティの存在を確認する</a></li></ol></li><li><a href="#toc6" tabindex="0">今の書き方：オプショナルチェーン（?.）</a></li><li><a href="#toc7" tabindex="0">配列や関数の呼び出しにも使える</a><ol><li><a href="#toc8" tabindex="0">配列へのアクセス（?.[]）</a></li><li><a href="#toc9" tabindex="0">関数の呼び出し（?.()）</a></li></ol></li><li><a href="#toc10" tabindex="0">Null合体演算子（??）との組み合わせ</a></li><li><a href="#toc11" tabindex="0">React開発でオプショナルチェーンが役立つ場面</a></li><li><a href="#toc12" tabindex="0">注意点：なんでも ?. にすれば良いわけではない</a></li><li><a href="#toc13" tabindex="0">まとめ</a></li></ol>
    </div>
  </div>

<h2><span id="toc1">オプショナルチェーン（?.）とは？</span></h2>
<p>オプショナルチェーン（Optional Chaining）は、オブジェクトのプロパティやメソッドにアクセスする際、途中の値が null または undefined であってもエラーを出さずに undefined を返してくれるJavaScriptの構文です（ES2020で導入されました）。</p>
<p>通常のドット（.）の代わりに、ハテナを付けた ?. を使って記述します。</p>
<pre><code>const user = {
  name: "りあぴ",
  profile: {
    sns: {
      x: "@riapi_js"
    }
  }
};

// 存在する場合：そのまま値が取れる
console.log(user.profile?.sns?.x);
// "@riapi_js"

// 存在しない場合：エラーにならず undefined になる
console.log(user.address?.city);
// undefined</code></pre>
<p>もしここで通常の . を使って user.address.city と書いてしまうと、address が undefined であるため TypeError: Cannot read properties of undefined というエラーが発生し、プログラムが止まってしまいます。</p>
<h2><span id="toc2">昔はどう書いていたの？（if 文や &#038;&#038;、in 演算子の苦労）</span></h2>
<p>オプショナルチェーンが登場する前は、外部APIから受け取ったデータ（すべての項目が揃っているか保証がないデータ）を扱う際、親から順番に「存在するかどうか」をすべて確認する必要がありました。</p>
<h3><span id="toc3">昔の書き方その1：if 文を入れ子にする</span></h3>
<pre><code>let city;
if (user && user.address && user.address.city) {
  city = user.address.city;
}</code></pre>
<h3><span id="toc4">昔の書き方その2：&#038;&#038;（論理積）でつなぐ</span></h3>
<pre><code>const city = user && user.address && user.address.city;</code></pre>
<p>階層が深くなればなるほど、user &#038;&#038; user.profile &#038;&#038; user.profile.sns &#038;&#038; &#8230; のように同じ変数名を何度も書く必要があり、コードが長くなって読みづらくなっていました。</p>
<h3><span id="toc5">昔の書き方その3：in 演算子でプロパティの存在を確認する</span></h3>
<p>値が 0 や空文字 &#8220;&#8221; の場合でも「プロパティ自体が存在するか」を厳密に調べたいときは、in 演算子（または hasOwnProperty）を使って以下のように書くこともありました。</p>
<pre><code>let city;
if (user && 'address' in user && user.address && 'city' in user.address) {
  city = user.address.city;
}</code></pre>
<p>プロパティ名を文字列（&#8217;address&#8217; など）で書く必要があるうえ、やはり階層の数だけチェックが増えるため、かなり大変な書き方でした。</p>
<h2><span id="toc6">今の書き方：オプショナルチェーン（?.）</span></h2>
<p>オプショナルチェーンを使えば、上のコードがたった1行で済みます。</p>
<pre><code>const city = user?.address?.city;</code></pre>
<p>途中で null や undefined に出会った時点で評価をストップし、安全に undefined を返してくれます。</p>
<p>※ちなみに： if (user.address.city) のような昔の書き方だと、値が 0 や &#8220;&#8221;（空文字）だった場合にも「存在しない（false）」と判定されてしまいますが、オプショナルチェーン（user.address?.city）なら 0 や &#8220;&#8221; もそのまま正しく取得できます。</p>
<h2><span id="toc7">配列や関数の呼び出しにも使える</span></h2>
<p>オプショナルチェーンはオブジェクトのプロパティだけでなく、配列の要素や関数の呼び出しにも使えます。</p>
<h3><span id="toc8">配列へのアクセス（?.[]）</span></h3>
<pre><code>const list = null;

// 配列が存在しない場合でもエラーにならない
console.log(list?.[0]);
// undefined</code></pre>
<h3><span id="toc9">関数の呼び出し（?.()）</span></h3>
<pre><code>const actions = {
  sayHello: () =&gt; console.log("こんにちは！")
};

// 存在する関数は実行される
actions.sayHello?.();
// "こんにちは！"

// 存在しない関数を呼んでもエラーにならない
actions.sayBye?.();
// （エラーにならず何も起きない）</code></pre>
<h2><span id="toc10">Null合体演算子（??）との組み合わせ</span></h2>
<p>オプショナルチェーンは、値が null や undefined のときにデフォルト値を指定できる Null合体演算子（??） と組み合わせて使うのが定番です。</p>
<pre><code>const user = {
  name: "りあぴ"
  // address は未設定
};

// address.city がなければ「未登録」にする
const city = user.address?.city ?? "未登録";

console.log(city);
// "未登録"</code></pre>
<p>このように書くことで、「データが欠けていてもエラーにならず、画面には親切な代替テキストを表示する」という処理が1行で書けます。</p>
<p>?? と || の違いや使い分けは、<a href="https://react-js.jp/nullish-coalescing">Null合体演算子（??）と ||（OR演算子）の違い</a>の記事で詳しく解説しています。</p>
<h2><span id="toc11">React開発でオプショナルチェーンが役立つ場面</span></h2>
<p>ReactでWebアプリを作っていると、オプショナルチェーンは毎日のように使います。特に役立つのが外部APIからデータを取得して画面に表示するときです。</p>
<p>Reactでは、通信が終わる前（データが届く前）にも最初の画面描画（レンダリング）が走ります。</p>
<pre><code>function UserProfile({ user }) {
  // 通信完了前は user が null や undefined の可能性がある
  return (
    &lt;div&gt;
      &lt;h2&gt;{user?.name ?? "読み込み中..."}&lt;/h2&gt;
      &lt;p&gt;住んでいる街：{user?.address?.city ?? "未設定"}&lt;/p&gt;
    &lt;/div&gt;
  );
}</code></pre>
<p>もしここで user.name と書いてしまうと、データが届く一瞬のあいだにエラーが起きて画面が真っ白になってしまいます。user?.name と書いておくだけで、通信中の安全な表示を簡単に実現できます。</p>
<h2><span id="toc12">注意点：なんでも ?. にすれば良いわけではない</span></h2>
<p>便利なオプショナルチェーンですが、「必ず存在すべきデータ」にまで無闇に ?. を付けるのはおすすめしません。</p>
<p>もしバグやデータの不備で本来あるはずの値が欠けていた場合、?. を付けているとエラーが出ずに undefined のまま処理が進んでしまい、「なぜか画面に何も表示されないけどエラーも出ない」と原因究明が難しくなることがあるためです。</p>
<ul>
<li>外部APIのレスポンスや、未入力の可能性がある項目 → ?. を使う</li>
<li>必ず存在することが保証されている項目 → 通常の . を使う</li>
</ul>
<p>という基準で使い分けるのがおすすめです。</p>
<h2><span id="toc13">まとめ</span></h2>
<p>オプショナルチェーン（?.）を使うと、深い階層のオブジェクトや外部から取得した不確かなデータから、エラーを恐れずに安全に値を取り出すことができます。</p>
<ul>
<li>昔：user &#038;&#038; user.address &#038;&#038; user.address.city や in 演算子でチェック</li>
<li>今：user?.address?.city</li>
</ul>
<p>Null合体演算子（??）と組み合わせれば、Reactでのデータ表示や条件分岐のコードも短く読みやすくなります。モダンJavaScriptの基本である<a href="https://react-js.jp/let-const">変数宣言（let, const）</a>の記事とあわせて読むと、ES2015以降の書き方の全体像がつかめます。</p>
]]></content:encoded>
					
					<wfw:commentRss>https://react-js.jp/optional-chaining/feed</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
	</channel>
</rss>
