React Native Academy · Les

Flexbox-richting, JustifyContent en AlignItems

Bepaal met flexDirection, justifyContent en alignItems hoe children binnen een View worden gerangschikt, gecentreerd, verdeeld en uitgelijnd.

Les 2 van 413 stappen

Flexbox-richting, JustifyContent en AlignItems is een gratis React Native Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject React Native Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus React Native Academy bevat in totaal 4 lessen.

Flexbox is het standaardlay-outsysteem

React Native gebruikt Flexbox als lay-outalgoritme voor elke View-component — er is geen blok- of inline-indeling zoals in CSS. Elke View is automatisch een Flex-container, wat betekent dat de onderliggende elementen standaard volgens Flexbox-regels worden geplaatst. Het belangrijkste verschil met Flexbox in CSS voor het web is dat React Native standaard flexDirection op 'column' instelt, niet op 'row' zoals op het web. Daardoor worden onderliggende elementen standaard verticaal gestapeld, wat overeenkomt met de indeling van de meeste mobiele schermen.

import { View, StyleSheet } from 'react-native';

export default function DefaultFlex() {
  return (
    // No flexDirection needed — 'column' is the default
    <View style={styles.container}>
      <View style={styles.box1} />
      <View style={styles.box2} />
      <View style={styles.box3} />
    </View>
  );
}

const styles = StyleSheet.create({
  container: { flex: 1, backgroundColor: '#f5f5f5', padding: 16 },
  box1: { height: 60, backgroundColor: '#ff6b6b', marginBottom: 8 },
  box2: { height: 60, backgroundColor: '#4f86f7', marginBottom: 8 },
  box3: { height: 60, backgroundColor: '#51cf66' },
});

flexDirection: row versus column

flexDirection bepaalt de hoofdas van de Flex-container. Met 'column' (de standaardwaarde) worden onderliggende elementen van boven naar beneden gestapeld. Met 'row' staan ze van links naar rechts. De waarden 'column-reverse' en 'row-reverse' draaien de volgorde om. Als je flexDirection wijzigt, verandert ook op welke as justifyContent en alignItems werken — justifyContent werkt altijd langs de hoofdas en alignItems langs de dwarsas. Dit is de belangrijkste Flexbox-eigenschap om te begrijpen.

import { View, StyleSheet } from 'react-native';

export default function DirectionDemo() {
  return (
    <View style={{ flex: 1, gap: 16, padding: 16 }}>
      {/* Column: children stack vertically (default) */}
      <View style={{ flexDirection: 'column', height: 120, backgroundColor: '#f0f0f0' }}>
        <View style={styles.box} />
        <View style={styles.box} />
      </View>

      {/* Row: children sit side by side */}
      <View style={{ flexDirection: 'row', height: 60, backgroundColor: '#f0f0f0' }}>
        <View style={styles.box} />
        <View style={styles.box} />
      </View>
    </View>
  );
}

const styles = StyleSheet.create({
  box: { width: 50, height: 50, backgroundColor: '#4f86f7', margin: 4 },
});

justifyContent: uitlijnen langs de hoofdas

justifyContent bepaalt hoe onderliggende elementen over de hoofdas worden verdeeld (verticaal voor column, horizontaal voor row). De handigste waarden zijn: 'flex-start' (aan het begin plaatsen, standaard), 'flex-end' (aan het einde plaatsen), 'center' (de groep centreren), 'space-between' (het eerste en laatste element raken de randen, met gelijke tussenruimten), 'space-around' (gelijke ruimte rond elk element) en 'space-evenly' (gelijke ruimte, ook aan de randen). 'space-between' wordt vooral vaak gebruikt voor navigatiebalken en rijen met actieknoppen.

import { View, Text, StyleSheet } from 'react-native';

export default function SpaceBetween() {
  return (
    <View style={styles.row}>
      <Text style={styles.tab}>Home</Text>
      <Text style={styles.tab}>Search</Text>
      <Text style={styles.tab}>Profile</Text>
    </View>
  );
}

const styles = StyleSheet.create({
  row: {
    flexDirection: 'row',
    justifyContent: 'space-between', // distribute across full width
    paddingHorizontal: 24,
    paddingVertical: 16,
    backgroundColor: '#fff',
    borderTopWidth: 1,
    borderTopColor: '#eee',
  },
  tab: { fontSize: 14, color: '#666' },
});

alignItems: uitlijnen langs de dwarsas

alignItems bepaalt hoe onderliggende elementen op de dwarsas worden geplaatst (loodrecht op de hoofdas). In een column-container worden ze horizontaal uitgelijnd; in een row-container verticaal. Waarden zijn: 'flex-start' (standaard voor column op Android, elementen sluiten aan bij het begin), 'flex-end', 'center' en 'stretch' (elementen worden uitgerekt om de dwarsas te vullen — dit is de standaard op iOS en is logisch voor column-indelingen waarin je elementen over de volledige breedte wilt). 'baseline' lijnt de tekstbaselines van onderliggende elementen uit.

import { View, Text, StyleSheet } from 'react-native';

export default function AlignDemo() {
  return (
    <View style={styles.container}>
      {/* Row: alignItems centers children vertically */}
      <View style={styles.row}>
        <Text style={styles.smallText}>Small</Text>
        <Text style={styles.largeText}>LARGE</Text>
        <Text style={styles.smallText}>Small</Text>
      </View>
    </View>
  );
}

const styles = StyleSheet.create({
  container: { flex: 1, padding: 20 },
  row: {
    flexDirection: 'row',
    alignItems: 'center', // vertically center all items
    backgroundColor: '#e8f0fe',
    padding: 16,
    borderRadius: 8,
  },
  smallText: { fontSize: 12, color: '#666', marginHorizontal: 8 },
  largeText: { fontSize: 28, fontWeight: 'bold', color: '#111', marginHorizontal: 8 },
});

Inhoud centreren met flex, justify en align

Een veelvoorkomend patroon is inhoud zowel verticaal als horizontaal centreren — voor opstartschermen, lege toestanden of laadindicatoren. Stel flex: 1 in op de container zodat deze de beschikbare ruimte vult en pas vervolgens justifyContent: 'center' en alignItems: 'center' toe. Omdat de standaardwaarde van flexDirection column is, worden de onderliggende elementen zowel verticaal als horizontaal in het midden van het scherm geplaatst. Deze combinatie van drie eigenschappen is waarschijnlijk het meest gebruikte lay-outrecept in React Native.

import { View, Text, StyleSheet } from 'react-native';

export default function CenteredScreen() {
  return (
    <View style={styles.container}>
      <Text style={styles.emoji}>🎯</Text>
      <Text style={styles.title}>Nothing here yet</Text>
      <Text style={styles.subtitle}>Add your first item to get started</Text>
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center', // vertical center (column main axis)
    alignItems: 'center',     // horizontal center (column cross axis)
    backgroundColor: '#f8f9fa',
  },
  emoji: { fontSize: 56, marginBottom: 16 },
  title: { fontSize: 22, fontWeight: 'bold', color: '#333' },
  subtitle: { fontSize: 14, color: '#999', marginTop: 8, textAlign: 'center' },
});

alignSelf: uitlijning op de dwarsas overschrijven

alignSelf overschrijft voor één specifiek onderliggend element de waarde van alignItems van de ouder. Dezelfde waarden als bij alignItems zijn toegestaan: 'auto' (de instelling van de ouder gebruiken), 'flex-start', 'flex-end', 'center' en 'stretch'. Dit is handig wanneer de meeste elementen dezelfde uitlijning hebben, maar één element anders moet worden behandeld — bijvoorbeeld een rij pictogrammen waarin één pictogram groter is en bovenaan moet worden uitgelijnd terwijl de andere in het midden staan. Gebruik alignSelf spaarzaam; het is beter te onderhouden om alignItems van de ouder aan te passen en waar nodig wrapper-Views te gebruiken.

import { View, Text, StyleSheet } from 'react-native';

export default function AlignSelfExample() {
  return (
    <View style={styles.row}>
      <View style={styles.boxSmall} />
      {/* This box aligns to flex-end independently */}
      <View style={[styles.boxSmall, { alignSelf: 'flex-end', backgroundColor: 'red' }]} />
      <View style={styles.boxSmall} />
    </View>
  );
}

const styles = StyleSheet.create({
  row: {
    flexDirection: 'row',
    alignItems: 'center', // default for siblings
    height: 100,
    backgroundColor: '#e8f0fe',
    padding: 8,
    gap: 8,
  },
  boxSmall: { width: 50, height: 50, backgroundColor: '#4f86f7', borderRadius: 6 },
});

gap, rowGap en columnGap

Gebruik in plaats van margin aan elk onderliggend element toe te voegen gap op de container om uniforme ruimte tussen Flex-elementen in te stellen. gap stelt zowel de rij- als kolomruimte in, terwijl rowGap en columnGap deze afzonderlijk regelen. Hierdoor heb je geen marginBottom op alle elementen behalve het laatste nodig en ook geen truc met negatieve marges op de container. Ondersteuning voor gap is toegevoegd in React Native 0.71 (beschikbaar in Expo SDK 48+), dus controleer je RN-versie voordat je dit in oudere projecten gebruikt.

import { View, StyleSheet } from 'react-native';

export default function GapExample() {
  return (
    <View style={styles.container}>
      {[1, 2, 3, 4].map(n => (
        <View key={n} style={styles.card} />
      ))}
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    flexDirection: 'row',
    flexWrap: 'wrap',
    gap: 12,           // equal gap between all children
    padding: 16,
    backgroundColor: '#f5f5f5',
  },
  card: {
    width: '47%',      // two columns
    height: 100,
    backgroundColor: '#4f86f7',
    borderRadius: 10,
  },
});

flexWrap: onderliggende elementen naar volgende regels laten doorlopen

Standaard krimpen Flex-elementen zodat ze op één regel passen en worden ze nooit afgebroken. Stel flexWrap: 'wrap' in op de container zodat onderliggende elementen naar de volgende rij (bij een row-richting) of kolom (bij een column-richting) kunnen doorlopen wanneer er geen ruimte meer is. Dit vormt de basis voor tagwolken, rasterachtige indelingen met percentages voor de breedte en elke interface waarin elementen vanzelf naar de volgende regel moeten doorlopen. 'nowrap' is de standaardwaarde; 'wrap-reverse' laat elementen in de tegenovergestelde richting doorlopen.

import { View, Text, StyleSheet } from 'react-native';

const tags = ['React Native', 'Mobile', 'iOS', 'Android', 'JavaScript', 'Flexbox', 'Expo'];

export default function TagCloud() {
  return (
    <View style={styles.container}>
      {tags.map(tag => (
        <View key={tag} style={styles.tag}>
          <Text style={styles.tagText}>{tag}</Text>
        </View>
      ))}
    </View>
  );
}

const styles = StyleSheet.create({
  container: { flexDirection: 'row', flexWrap: 'wrap', gap: 8, padding: 16 },
  tag: { backgroundColor: '#e8f0fe', paddingHorizontal: 12, paddingVertical: 6, borderRadius: 16 },
  tagText: { color: '#4f86f7', fontSize: 13, fontWeight: '500' },
});

Een praktische kopindeling

Pas je kennis van Flexbox toe om een veelvoorkomend patroon in mobiele apps te bouwen: een navigatiekop met links een terugknop, in het midden een titel en rechts een menupictogram. Gebruik flexDirection: 'row' en alignItems: 'center' op de kopcontainer. Geef de titel flex: 1, zodat deze uitzet en de resterende ruimte vult en zichzelf tussen de pictogrammen met vaste breedte aan de zijkanten centreert. Dit is netter dan position: 'absolute' gebruiken voor het centreren en werkt correct met titels van verschillende lengtes.

import { View, Text, TouchableOpacity, StyleSheet } from 'react-native';

export default function Header({ title, onBack, onMenu }) {
  return (
    <View style={styles.header}>
      <TouchableOpacity style={styles.sideBtn} onPress={onBack}>
        <Text style={styles.icon}>←</Text>
      </TouchableOpacity>

      <Text style={styles.title} numberOfLines={1}>{title}</Text>

      <TouchableOpacity style={styles.sideBtn} onPress={onMenu}>
        <Text style={styles.icon}>⋯</Text>
      </TouchableOpacity>
    </View>
  );
}

const styles = StyleSheet.create({
  header: {
    flexDirection: 'row',
    alignItems: 'center',
    paddingHorizontal: 16,
    paddingVertical: 12,
    backgroundColor: '#fff',
    borderBottomWidth: StyleSheet.hairlineWidth,
    borderBottomColor: '#ddd',
  },
  sideBtn: { width: 40, alignItems: 'center' },
  title: { flex: 1, fontSize: 18, fontWeight: '600', color: '#111', textAlign: 'center' },
  icon: { fontSize: 22, color: '#333' },
});

Flexbox-lay-outs opsporen en corrigeren

Fouten in Flexbox komen vaak voor tijdens het ontwikkelen van een lay-out. Handige technieken om ze op te sporen: voeg tijdelijk een backgroundColor toe aan elke View zodat de grenzen zichtbaar worden, gebruik React DevTools om de berekende lay-out in de componentenstructuur te inspecteren, controleer of flex: 1 ontbreekt bij bovenliggende containers (een container zonder flex: 1 krimpt tot nulhoogte, waardoor de onderliggende elementen onzichtbaar worden) en controleer of flexDirection de bedoelde waarde heeft (React Native gebruikt standaard column, niet row). Alle stijlen verwijderen en ze één voor één terugplaatsen is een betrouwbare manier om lay-outfouten te isoleren.

// Debug technique: color-code your Views temporarily
const debugStyles = StyleSheet.create({
  container: { flex: 1, backgroundColor: 'rgba(255,0,0,0.1)' }, // red tint
  inner: { backgroundColor: 'rgba(0,0,255,0.1)' },              // blue tint
  text: { backgroundColor: 'rgba(0,255,0,0.1)' },               // green tint
});

// Then you can see exactly where each View starts and ends
// Remove these debug colors before shipping!

Rij met pictogram, tekst en actie

Een van de meest voorkomende patronen in mobiele interfaces is een rij in een lijst met links een pictogram, in het midden tekst en rechts een actieknop. Implementeer dit met flexDirection: 'row' op de container en alignItems: 'center' om alle onderliggende elementen verticaal uit te lijnen. Gebruik links een View voor het pictogram met een vaste grootte, in het midden een tekstgebied met flex: 1 zodat dit de beschikbare ruimte vult, en rechts een actieknop met een vaste grootte. Dit patroon komt voor in instellingenschermen, contactenlijsten en gegevensrijke tabelweergaven in mobiele apps.

import { View, Text, TouchableOpacity, StyleSheet } from 'react-native';

export default function SettingsRow({ icon, label, subtitle, onPress }) {
  return (
    <TouchableOpacity style={styles.row} onPress={onPress}>
      {/* Left: icon */}
      <View style={styles.iconContainer}>
        <Text style={{ fontSize: 22 }}>{icon}</Text>
      </View>

      {/* Middle: text content — flex: 1 fills space */}
      <View style={{ flex: 1 }}>
        <Text style={styles.label} numberOfLines={1}>{label}</Text>
        {subtitle && <Text style={styles.subtitle} numberOfLines={1}>{subtitle}</Text>}
      </View>

      {/* Right: chevron */}
      <Text style={styles.chevron}>›</Text>
    </TouchableOpacity>
  );
}

const styles = StyleSheet.create({
  row: { flexDirection: 'row', alignItems: 'center', paddingHorizontal: 16, paddingVertical: 12, backgroundColor: '#fff', gap: 12 },
  iconContainer: { width: 36, height: 36, borderRadius: 8, backgroundColor: '#f0f4ff', alignItems: 'center', justifyContent: 'center' },
  label: { fontSize: 16, color: '#222' },
  subtitle: { fontSize: 13, color: '#999', marginTop: 2 },
  chevron: { fontSize: 22, color: '#ccc', fontWeight: '300' },
});

Korte controle

Test je begrip van de concepten voor mobiele ontwikkeling met React Native uit deze les.

Lesoverzicht

In deze les heb je geleerd: flexDirection bepaalt de hoofdas (standaard een kolom in React Native, geen rij), justifyContent verdeelt onderliggende elementen over de hoofdas en alignItems lijnt onderliggende elementen uit op de kruis-as. Hierna verkennen we de eigenschap flex en responsieve afmetingen voor verschillende schermformaten.

Gratis beginnen

Leer JavaScript met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen
30
Lessen
120

Veelgestelde vragen

Is de les “Flexbox-richting, JustifyContent en AlignItems” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad React Native Academy, waaronder “Flexbox-richting, JustifyContent en AlignItems”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus React Native Academy bevat in totaal 4 lessen.

Wat leer ik in “Flexbox-richting, JustifyContent en AlignItems”?

Bepaal met flexDirection, justifyContent en alignItems hoe children binnen een View worden gerangschikt, gecentreerd, verdeeld en uitgelijnd. Je oefent met React Native Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met React Native Academy te beginnen?

Ervaring vooraf is niet nodig. React Native Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Flexbox-richting, JustifyContent en AlignItems”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over React Native Academy?

Ja. Elke les over React Native Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

  1. StyleSheet.create en inline stijlen
  2. Flexbox-richting, JustifyContent en AlignItems
  3. flex, flexGrow en responsieve afmetingen
  4. Een responsief kaartengrid bouwen
← Terug naar React Native Academy