Flexbox ble tilgjengelig i alle store nettlesere rundt 2015 og løste umiddelbart problemet utviklere hadde hacket rundt i et tiår: vertikal sentrering. Men de fleste lærte det baklengs — de pugget justify-content: center fra et jukseark uten å forstå hvorfor det fungerer. Når layouten ikke oppfører seg riktig, gjør dette kunnskapsgapet en fem-minutters oppgave til en time med prøving og feiling. Denne guiden bygger den mentale modellen først, og dekker deretter alle egenskapene som faktisk betyr noe i virkelige prosjekter.

Den mentale modellen: én akse om gangen

Kjernekonceptet i Flexbox er at det legger ut elementer langs en enkelt akse. Det er en hovedakse — retningen elementene flyter — og en krysskasse, som løper vinkelrett. Den kritiske innsikten nesten alle nybegynnere går glipp av: flex-direction bestemmer hvilken akse som er hvilken. Alt annet følger av det.

css
/* Default: main axis runs LEFT → RIGHT, cross axis runs TOP → BOTTOM */
.container {
  display: flex;
  flex-direction: row; /* default */
}

/* Rotated: main axis now runs TOP → BOTTOM, cross axis runs LEFT → RIGHT */
.container {
  display: flex;
  flex-direction: column;
}

/*
  justify-content  →  controls alignment on the MAIN axis
  align-items      →  controls alignment on the CROSS axis

  This is why centering something in both axes looks like this:
*/
.center-both {
  display: flex;
  justify-content: center; /* horizontally centred (main axis = row) */
  align-items: center;     /* vertically centred (cross axis)        */
}
Forvirringen som snubler alle: når du bytter til flex-direction: column, kontrollerer justify-content ikke lenger horisontal justering — det kontrollerer vertikal justering, fordi hovedaksen har rotert. align-items kontrollerer nå det horisontale. Husk denne rotasjonen hver gang noe ikke justerer seg der du forventer det.

Beholder-egenskaper

Disse egenskapene plasseres på flex-beholderen — foreldreelementet med display: flex. De kontrollerer hvordan alle underordnede elementer fordeles og justeres.

css
/* display: flex makes the element a block-level flex container.
   display: inline-flex makes it inline (sits in text flow). */
.nav {
  display: flex;
}

/* flex-direction — which way does the main axis run? */
.nav {
  flex-direction: row;         /* left to right (default)  */
  flex-direction: row-reverse; /* right to left            */
  flex-direction: column;      /* top to bottom            */
  flex-direction: column-reverse; /* bottom to top         */
}

/* flex-wrap — what happens when items overflow the container? */
.card-grid {
  flex-wrap: nowrap;       /* all items forced onto one line (default) */
  flex-wrap: wrap;         /* items wrap onto additional lines         */
  flex-wrap: wrap-reverse; /* items wrap in reverse order              */
}

/* gap — space between items. Modern approach; avoids margin hacks. */
.card-grid {
  gap: 1.5rem;             /* same in both directions              */
  gap: 1rem 2rem;          /* row-gap column-gap                   */
}

gap-egenskapen fortjener spesiell omtale. Før den fantes var det vanlige mønsteret å legge til marginer på flex-elementer og deretter kansellere de ytre kantene med negative marginer. gap erstatter alt dette rent — bruk det overalt i stedet.

css
/* justify-content — alignment on the MAIN axis */
.nav {
  justify-content: flex-start;    /* packed to start (default)              */
  justify-content: flex-end;      /* packed to end                          */
  justify-content: center;        /* packed to centre                       */
  justify-content: space-between; /* first/last at edges, equal gaps between */
  justify-content: space-around;  /* equal space around each item           */
  justify-content: space-evenly;  /* equal space between every gap          */
}

/* align-items — alignment on the CROSS axis (single line) */
.nav {
  align-items: stretch;   /* items fill cross-axis height (default)         */
  align-items: flex-start;/* items align to start of cross axis             */
  align-items: flex-end;  /* items align to end of cross axis               */
  align-items: center;    /* items centred on cross axis                    */
  align-items: baseline;  /* items aligned by their text baseline           */
}

/* align-content — cross-axis alignment when there are MULTIPLE lines
   (only takes effect with flex-wrap: wrap and enough items to wrap) */
.card-grid {
  flex-wrap: wrap;
  align-content: flex-start;    /* rows packed to top                       */
  align-content: center;        /* rows centred vertically                  */
  align-content: space-between; /* rows spread out with space between       */
}

Her er en ekte navigasjonslinje som kombinerer disse. Logoen sitter til venstre, og navigasjonslenkene skyves til høyre med margin-left: auto — et klassisk Flexbox-triks. justify-content: space-between-tilnærmingen fungerer også, men auto-margin-teknikken er mer fleksibel når du har mer enn to grupper.

css
/* Nav: logo left, links right */
.site-nav {
  display: flex;
  align-items: center;
  gap: 1rem;
  padding: 0 2rem;
  height: 64px;
  background: #1a1a2e;
}

.site-nav .logo {
  font-size: 1.25rem;
  font-weight: 700;
  color: #fff;
  text-decoration: none;
}

.site-nav .nav-links {
  display: flex;
  align-items: center;
  gap: 1.5rem;
  margin-left: auto; /* pushes everything after it to the right */
  list-style: none;
  margin-top: 0;
  margin-bottom: 0;
  padding: 0;
}

.site-nav .nav-links a {
  color: #ccc;
  text-decoration: none;
  font-size: 0.9rem;
}

.site-nav .nav-links a:hover {
  color: #fff;
}

Element-egenskaper

Disse egenskapene plasseres på flex-elementene — de direkte barna til flex-beholderen. De kontrollerer hvordan individuelle elementer vokser, krymper og dimensjonerer seg selv.

  • flex-grow — hvor mye av det tilgjengelige ledige rommet dette elementet tar. Standard 0 (ikke voks). Sett til 1 på et element og det tar all gjenværende plass.
  • flex-shrink — hvor mye dette elementet krymper i forhold til andre når det ikke er nok plass. Standard 1. Sett til 0 for å hindre et element i å krympe.
  • flex-basis — den opprinnelige størrelsen på elementet før vekst eller krymping. Kan være en lengde (250px, 30%) eller auto (bruk elementets innholdsstørrelse).
  • align-self — overstyrer align-items for ett spesifikt element. Godtar de samme verdiene: auto, flex-start, flex-end, center, baseline, stretch.
  • order — endrer visuell rekkefølge uten å berøre HTML. Standard 0. Lavere verdier vises først. Bruk sparsomt — det bryter tabulatorrekkefølgen og forårsaker tilgjengelighetsproblemer for tastatur- og skjermleserbrukere.
css
/* Classic sidebar + main content layout */
.app-layout {
  display: flex;
  min-height: 100vh;
}

.sidebar {
  flex: 0 0 280px; /* don't grow, don't shrink, always 280px wide */
  background: #f5f5f5;
  padding: 2rem 1.5rem;
}

.main-content {
  flex: 1; /* grow to fill all remaining space */
  padding: 2rem;
  min-width: 0; /* critical: prevents content overflow in flex children */
}

/* Responsive: stack vertically on mobile */
@media (max-width: 768px) {
  .app-layout {
    flex-direction: column;
  }

  .sidebar {
    flex: none; /* reset — don't use flex-basis on column layout */
  }
}
min-width: 0-fellen: Som standard kan ikke flex-elementer krympe under minimumsstørrelsen for innhold. Hvis du har et langt ord eller en bred tabell inne i et flex-element, vil det flyte over i stedet for å bryte. Å legge til min-width: 0 på flex-elementet løser dette. Det dukker opp konstant med hovedinnholdsområdet i sidelinjebygg.

flex-forkortelsen forklart

flex-forkortelsen pakker flex-grow, flex-shrink og flex-basis inn i én deklarasjon. W3C-spesifikasjonen definerer en håndfull nøkkelordverdier som dekker de vanlige tilfellene, og de forveksles ofte med hverandre.

css
/* flex: 1
   Expands to: flex-grow: 1; flex-shrink: 1; flex-basis: 0%
   Meaning: grow and shrink freely; start from zero (ignore content size).
   All items with flex: 1 share space equally, regardless of content.
   Most common choice for "fill available space". */
.tab { flex: 1; }

/* flex: auto
   Expands to: flex-grow: 1; flex-shrink: 1; flex-basis: auto
   Meaning: grow and shrink freely; start from the item's content size.
   Items with more content get more space — proportional, not equal. */
.column { flex: auto; }

/* flex: none
   Expands to: flex-grow: 0; flex-shrink: 0; flex-basis: auto
   Meaning: completely rigid — don't grow, don't shrink, stay at content size.
   Use for items that should never flex (icons, avatars, fixed labels). */
.avatar { flex: none; }

/* flex: 0 0 200px
   Explicit: don't grow, don't shrink, always exactly 200px.
   Same as writing out all three values. More readable for fixed-size items. */
.sidebar { flex: 0 0 200px; }

/* Practical difference: flex: 1 vs flex: auto in a tab bar
   With flex: 1  → all tabs are equal width regardless of label length
   With flex: auto → "Settings" tab is wider than "Home" tab */
.tabs { display: flex; }
.tab-equal  { flex: 1;    } /* equal width tabs     */
.tab-auto   { flex: auto; } /* content-sized tabs   */

Vanlige virkelige layouter

Her er fire mønstre du vil bruke jevnlig — bygget med kun Flexbox.

css
/* 1. Sticky footer
   The footer always sits at the bottom, even on short pages.
   body (or .app-shell) becomes a column flex container. */
body {
  display: flex;
  flex-direction: column;
  min-height: 100vh;
  margin: 0;
}

main {
  flex: 1; /* expands to push footer down */
}

footer {
  /* stays at the bottom */
}
css
/* 2. Centred modal / hero content
   Both axes centred — the Flexbox vertical-centring party trick. */
.hero {
  display: flex;
  justify-content: center;
  align-items: center;
  min-height: 100vh;
  padding: 2rem;
  background: linear-gradient(135deg, #667eea, #764ba2);
}

.hero-content {
  max-width: 640px;
  text-align: center;
  color: #fff;
}
css
/* 3. Nav bar: logo left, links right */
.site-nav {
  display: flex;
  align-items: center;
  padding: 0 2rem;
  height: 64px;
}

.site-nav .nav-links {
  margin-left: auto; /* auto margin consumes all free space to its left */
  display: flex;
  gap: 1.5rem;
  list-style: none;
  padding: 0;
  margin-top: 0;
  margin-bottom: 0;
}
css
/* 4. Card row that wraps on mobile */
.card-grid {
  display: flex;
  flex-wrap: wrap;
  gap: 1.5rem;
}

.card {
  flex: 1 1 280px; /* grow and shrink, but never below 280px wide */
  background: #fff;
  border-radius: 8px;
  padding: 1.5rem;
  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.08);
}

/* On wide screens: 3-4 cards per row.
   On narrow screens: cards wrap into their own rows automatically.
   No media query needed for the wrap itself — flex-wrap handles it. */

Flexbox vs Grid — når bruker man hva

Dette spørsmålet dukker opp konstant, og svaret er enklere enn de fleste artikler gjør det til: Flexbox er for endimensjonale layouter. CSS Grid er for todimensjonale layouter. Hvis du legger ut elementer i en enkelt rad eller en enkelt kolonne — en navigasjonslinje, en knappegruppe, en kortrull — er Flexbox det riktige verktøyet. Hvis du trenger å kontrollere både rader og kolonner simultant — en full sidelayout, et fotomosaik, et skjemarutenett — bruk Grid i stedet.

I praksis bruker du begge i samme prosjekt. Grid håndterer strukturen på sidenivå (topptekst, sidepanel, hoved, bunntekst). Flexbox håndterer komponentene innenfor disse regionene (navigasjonslinjen, kortinnholdet, knappesamlingen inne i en modal). De utfyller hverandre snarere enn å konkurrere.

Det ene gråsoneområdet: kortrutenett som skal ha rader med lik høyde og elementer justert i kolonner. Flexbox med flex-wrap: wrap kan gjøre dette, men elementer i samme visuelle rad har ingen relasjon til hverandre — høydene deres er uavhengige. Grids implisitte radsizing håndterer dette automatisk. Hvis du trenger kortene i en innpakket rad til å alle ha samme høyde OG ha sine interne elementer justert på tvers av kort, er Grid renere.

Oppsummering

Flexbox-mentale modellen er: velg en retning, forstå hvilke egenskaper som kontrollerer hvilken akse, og velg deretter om elementer skal vokse, krympe eller forbli faste. Når det klikker, blir juksearket et oppslagsverk — ikke en krykke. MDN Flexbox-guiden er den beste referansen for kanttilfeller, og CSS-Tricks komplette guide er fortsatt det mest nyttige visuelle juksearket som finnes. For produksjonsbruk er nettleserstøtten i praksis universell — ingen prefikser nødvendig. W3C-spesifikasjonen er verdt å bla gjennom hvis du noen gang møter et genuint forvirrende kanttilfelle.

← All CSS articles Browse all categories →