Bedingte React-Renderung und Liste-Ausgabe ohne Fußfeuerwaffen

Dieser Leitfaden erstellt erneut einen praktikablen Weg für: Bedingte Darstellung in React sowie Liste-Darstellung – und die wahre Natur von „key“. Der Fokus liegt auf Verträgen, Überprüfungen sowie Code, den man ohne Rückschluss auf die Absicht in ein Repository einfügen kann. Zur Übersicht sollten Sie vor dem Ändern des Codes die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien definieren. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zustände schließen zu müssen. Erhalten Sie neben den funktionalen Ergebnissen auch Aufzeichnungen zu Laufzeiten und Kosten. Frühe Sichtbarkeit verhindert überraschende Rechnungen in gemeinsam genutzten Umgebungen.

Bedingte Darstellung – Zeigen oder Nicht-Zeigen

Zur bedingten Darstellung – um anzuzeigen oder nicht anzuzeigen, sollten Sie die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definieren. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zustände schließen zu müssen. Bewahren Sie die Konfiguration außerhalb des Anwendungscode auf. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort zusammengefasst sein, den die Operator überprüfen können. Platzieren Sie Typen neben Komponenten und halten Sie die Props begrenzt. Zu umfangreiche Prop-Listen führen zu den Problemen, die TypeScript verhindern soll.

Ansatz 1 – Branch mit if, und geben Sie null zurück, wenn nichts dargestellt wird

Für Ansatz 1 – Zweig mit if, und geben Sie null zurück, wenn nichts gezeichnet wird. Definieren Sie vor dem Ändern des Codes die Eingaben, den Eigentümer der Schritt und die Abbruchkriterien. Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zustände schließen zu müssen. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf und den Notfallweg. Wiederholungsversuche sowie die Handhabung von Fehlern gehören zum Produkt. Platzieren Sie Typen zusammen mit Komponenten und halten Sie die Eigenschaften begrenzt. Umfangreiche Eigenschaftensätze führen zu den Schulden, die TypeScript verhindern soll.

type Props = { isInStock: boolean };

function StockBadge({ isInStock }: Props) {
  if (!isInStock) {
    return null; // out of stock — draw nothing
  }
  return <span className="badge">In stock</span>;
}

Ansatz 2 – Einer von Zwei mit dem Ternäroperator

Zur Vorgehensweise 2 – einer der beiden Ansätze mit dem Ternäroperator – sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen. Bevorzugen Sie kleine, testbare Einheiten vor umfangreichen Skripten. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortungsbereich verweisen. Platzieren Sie Typen zusammen mit Komponenten und halten Sie die Props begrenzt. Umfangreiche Prop-Listen führen zu den Problemen, die TypeScript verhindern soll. Zur Vorgehensweise 2 – einer der beiden Ansätze mit dem Ternäroperator – sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen. Erhalten Sie neben den funktionalen Ergebnissen auch Informationen zu Laufzeiten und Kosten. Frühe Sichtbarkeit verhindert überraschende Rechnungen in gemeinsam genutzten Umgebungen.

function StockBadge({ isInStock }: Props) {
  return (
    <span className="badge">
      {isInStock ? 'In stock' : 'Out of stock'}
    </span>
  );
}

Ansatz 3 – „Nur wenn“ mit &&

Beim Ansatz 3 – „Nur wenn“ mit && sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Die Konfiguration sollte außerhalb des Anwendungscode gespeichert werden. Umgebungsdateien, Geheimdatenspeicher sowie Feature-Flags sollten an einem Ort zusammengefasst sein, den die Operator überprüfen können. Man sollte explizite bedingte Darstellungen vor cleveren Kurzschlüssen bevorzugen, die in der Produktion Fehler verbergen.

function Cart({ count }: { count: number }) {
  return (
    <div>
      <h2>Cart</h2>
      {count > 0 && <p>Items in cart: {count}</p>}
    </div>
  );
}

Die häufigste Falle bei && – die Zahl 0

Für die häufigste Falle mit && – die Zahl 0 – sollten Sie die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definieren. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch den Notfallweg gemeinsam. Wiederholungsversuche und die Handhabung von Fehlern gehören zum Produkt. Ziehen Sie explizite bedingte Darstellungen vor cleveren Abkürzungen, die Fehler in der Produktion verbergen.

function Cart({ count }: { count: number }) {
  return (
    <div>
      <h2>Cart</h2>
      {/* 🔴 trap: if count is 0, "0" shows up on screen */}
      {count && <p>Items in cart: {count}</p>}
    </div>
  );
}

function App() {
  return (
    <>
      <Cart count={0} />
      <Cart count={10} />
    </>
  );
}

export default App;

// ✅ count > 0 is true/false, so it's safe
{count > 0 && <p>Items in cart: {count}</p>}

Listendarstellung – Zeichnen eines Arrays in einer Schleife

Zur Darstellung von Listen – Zeichnen eines Arrays in einer Schleife – sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Punkt aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen. Bevorzugen Sie kleine, testbare Einheiten vor umfangreichen Skripten. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortungsbereich verweisen. Wählen Sie explizite bedingte Darstellungen statt cleverer Abkürzungen, die Fehler in der Produktion verbergen. Zur Darstellung von Listen – Zeichnen eines Arrays in einer Schleife – sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Punkt aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen. Erhalten Sie neben den funktionalen Ergebnissen auch Angaben zu Laufzeiten und Kosten. Frühe Sichtbarkeit verhindert überraschende Rechnungen in gemeinsam genutzten Umgebungen.

type Product = {
  id: number;
  name: string;
  price: number;
};

const products: Product[] = [
  { id: 1, name: 'Mechanical Keyboard', price: 89000 },
  { id: 2, name: 'Wireless Mouse', price: 45000 },
  { id: 3, name: 'USB Hub', price: 23000 },
];

function ProductList() {
  return (
    <ul>
      {products.map((product) => (
        <li key={product.id}>
          {product.name} — {product.price.toLocaleString()} won
        </li>
      ))}
    </ul>
  );
}

key – das Namensattribut, das React verwendet, um Elemente voneinander zu unterscheiden

Für die Schlüssel – die Name-Tag-React verwendet, um die Elemente voneinander zu unterscheiden – sollten vor der Codeänderung die Eingabedaten, der Eigentümer des Schritts sowie die Abbruchkriterien definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zustände schließen zu müssen. Die Konfiguration sollte außerhalb des Anwendungscode gespeichert werden. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort zusammengefasst sein, den die Operator überprüfen können. Die Schlüssellisten müssen stabile Geschäftsidentifikatoren sein und nicht Array-Indizes, insbesondere dann, wenn sich die Reihenfolge ändern kann.

Warning: Each child in a list should have a unique "key" prop.

Schlüssel sollten „stabil und eindeutig“ sein

Für Schlüssel, die „stabil und eindeutig“ sein sollten, müssen vor dem Ändern des Codes die Eingaben, der Eigentümer des Schritts sowie die Abbruchkriterien definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Notfallweg. Wiederholungsversuche und die Handhabung von Fehlern gehören zum Produkt. Die Listen von Schlüsseln müssen stabile Geschäftsidentifikatoren sein, keine Array-Indizes, insbesondere dann, wenn sich die Reihenfolge ändern kann.

<li key={product.id}>   // ✅ each product's unique id — stable

Achtung – Verwenden Sie keinen Array-Index als Schlüssel

Für Trap: Verwenden Sie den Array-Index nicht als Schlüssel. Definieren Sie vor dem Ändern des Codes die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Ziehen Sie kleine, testbare Einheiten vor großen Skripten vor. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung hinweisen. Listen-Schlüssel müssen stabile Geschäfts-ID‑Werte sein – keine Array-Indizes –, insbesondere dann, wenn sich die Reihenfolge ändern kann. Für Trap: Verwenden Sie den Array-Index nicht als Schlüssel. Definieren Sie vor dem Ändern des Codes die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Erfassen Sie neben den funktionalen Ergebnissen auch die Laufzeiten und Kosten. Frühzeitige Sichtbarkeit verhindert überraschende Rechnungen in gemeinsam genutzten Umgebungen.

// 🔴 common but dangerous pattern
{products.map((product, index) => (
  <li key={index}>{product.name}</li>
))}

Zusammenfassen – Bedingungen + Listen

Zur Zusammenstellung – Bedingungen + Liste: Definieren Sie die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien, bevor Sie Code ändern. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zustände schließen zu müssen. Bewahren Sie die Konfiguration außerhalb des Anwendungscode auf. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort zusammengefasst sein, den die Operator überprüfen können. Platzieren Sie Typen neben den Komponenten und halten Sie die Eigenschaften begrenzt. Zu umfangreiche Eigenschaftensätze führen zu den Schulden, die TypeScript verhindern soll.

type Product = {
  id: number;
  name: string;
  price: number;
  inStock: boolean;
};

function ProductList({ products }: { products: Product[] }) {
  // when the list is empty — conditional rendering
  if (products.length === 0) {
    return <p>No products to display.</p>;
  }

  return (
    <ul>
      {products.map((product) => (
        <li key={product.id}>
          {product.name} — {product.price.toLocaleString()} won
          {/* badge only when out of stock — && (safe since the left side is boolean) */}
          {!product.inStock && <span className="badge"> (Out of stock)</span>}
        </li>
      ))}
    </ul>
  );
}

// dummy data — swap in an empty array [] to see the "No products" message
const products: Product[] = [
  { id: 1, name: 'Mechanical Keyboard', price: 89000, inStock: true },
  { id: 2, name: 'Wireless Mouse', price: 42000, inStock: false },
  { id: 3, name: 'USB-C Hub', price: 35000, inStock: true },
];

function App() {
  return <ProductList products={products} />;
}

Zusammenfassung

Zum Abschluss sollten Sie die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien definieren, bevor Sie Code ändern. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Notfallfall. Wiederholungsversuche und die Handhabung von Fehlern gehören zum Produkt. Platzieren Sie Typen zusammen mit Komponenten und halten Sie die Eigenschaften begrenzt. Zu umfangreiche Eigenschaftensätze führen zu den Schulden, die TypeScript verhindern soll.

Referenzen

Zur Referenz: Definieren Sie die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien, bevor Sie Code ändern. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen. Ziehen Sie kleine, testbare Einheiten vor großen Skripten. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung hinweisen. Platzieren Sie Typen zusammen mit Komponenten und halten Sie die Eigenschaften begrenzt. Umfangreiche Eigenschaftensätze führen zu den Schulden, die TypeScript verhindern soll. Zur Referenz: Definieren Sie die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien, bevor Sie Code ändern. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen. Erhalten Sie neben den funktionalen Ergebnissen auch Angaben zu Laufzeiten und Kosten. Frühzeitige Sichtbarkeit verhindert überraschende Rechnungen in gemeinsam genutzten Umgebungen.

Operative Checkliste

Für die Betriebskontrollliste sollten vor der Codeänderung die Eingaben, der Verantwortliche für den jeweiligen Schritt sowie die Abbruchkriterien definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen.

Betrachten Sie diese Phase als Vertrag zwischen den Eingaben und den validierten Ausgaben. Benennen Sie die Ergebnisdokumente, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab.

Ziehen Sie explizite bedingte Darstellungen vor intelligenten Abkürzungen, die Fehler in der Produktion verbergen.

Ziehen Sie langweilige Zuverlässigkeit vor clevere, einmalige Demonstrationen.

Erhalten Sie Zeiten und Kosten zusammen mit den funktionalen Ergebnissen fest. Frühzeitige Sichtbarkeit verhindert überraschende Rechnungen in gemeinsam genutzten Umgebungen.

Ziehen Sie explizite bedingte Darstellungen vor intelligenten Abkürzungen, die Fehler in der Produktion verbergen.

Vor der Einführung des Stacks sollten Versionen eingefroren werden, ein „goldener“ Transkript für den kritischen Pfad erstellt und die Rollback-Schritte bestätigt werden. Geteilte Umgebungen benötigen Rate Limits, Überprüfungen der Nutzungsrechte sowie einen klaren Verantwortlichen für die Rotation von Geheimnissen.