The Box Model

A Sidebar About Shorthand #

Padding—and many other properties, like border and margin—can be specified with a shorthand property to make it easier to use the same spacing all around, or shared top/bottom and left/right.

Shorthand Properties – MDN
There are some S shuttles though.

		section { padding: 20px; }
section { padding: 20px 40px; }
section { padding: 20px 40px 80px; }
section { padding: 20px 40px 80px 40px; }

	

		section {
	padding-top: 20px;
	padding-bottom: 80px;
	padding-right: 40px;
	padding-left: 40px;
}

	

Absolute Units #

		.pixels {
	height: 360px;
	width: 720px;
}

.inches {
	height: 5in;
	width: 10in;
}

.mm {
	height: 84mm;
	width: 400mm;
}

	

Relative Units #

		/* Relative to nearest sized ancestor. */
.percentage {
	height: 90%;
	width: 85%;
}

/* Relative to viewport height/width. */
.viewport {
	height: 75vh;
	width: 80vw;
}

/* Relative to element font-size. */
.em {
	height: 14em; /* 1em is one line. */
	width: 4.8em;
}

/* Also relative to font size */
.ch {
	width: 1ch; /* 1ch is one letter. */
}

/* Relative to :root font-size. */
.rem {
	height: 12rem;
	width: 2.4rem;
}

	

Combine Them With a calc #

		.absolute-and-relative {
	width: calc(50% - 20px);
}

.computer-do-the-math {
	width: calc(100% / 12);
}

	

Limit/Constrain Them #

		.constrained-width {
	min-width: 200px;
	width: 50%;
	max-width: 400px;
}

.constrained-height {
	min-height: 100px;
	height: 100%;
	max-height: 200px;
}

/* Handy to watch your line lengths! */
p {
	max-width: 65ch; /* 65ish letters. */
}

	

CSS is big and massive and overwhelming and sometimes indefensibly nonsensical—but remember that you can do a surprising amount with just these basic properties! No matter how complex it gets, it always comes back to these basics.

Static #

By default, every element is static—just meaning its normal, stacked position in the document.

You’ll rarely, if ever, actually set this yourself—it’s the default!

Relative #

The first thing we might want to do is adjust an element from that normal static position, which we can do with relative positioning.

Once you have set position: relative; you can use the top, right, bottom, and left values (with any of the units, above) to move the element away from its default, normal position in the flow:

Absolute #

Absolute positioning is somewhat similar to relative—but instead of placing an element in relation to its own default position, it uses the position of its nearest positioned ancestor as the origin.

So absolute elements will go “up the tree” of parents and wrapper elements until they find one set to anything other than default/static—then the same offset properties the element around from there.

Importantly, position: absolute; also removes the element from the normal document flow—meaning it takes up no space in the page layout.

This is often used for exacting, specific design elements.

Fixed #

Fixed positioning also removes the element from the document flow, but it places elements with relation to the browser viewport—the boundaries of the window or device.

So position: fixed; brings the element completely out of the page’s normal flow, like it is sitting on its own separate layer.

This is often used for things like navigation elements.

Sticky #

The most recent addition to the position party, position: sticky; elements are placed according to the normal flow of the document, like static, until their nearest scrolling ancestor (usually the viewport) moves past them. The element is then stuck in relation to this element.

This is often used for headers on tables and lists.

“Depth” #

Okay, z-index is not strictly positioning—it is a separate property. You can see that all these position properties have given us ways to make things overlap, and z-index is how we can decide the front-to-back ordering (think z-axis).

By default, items that are lower in the HTML (coming after each other) are in front of higher, earlier elements:

A whole lot of things make a new stacking context (including most position changes) which is kind of like a group (or a Figma frame) that has its own internal depth/overlap order.

No amount of internal z-index adjustments can break something out of that group—which is one of the reasons why z can be really difficult to understand and tricky to use. But you can always adjust the z-index of the group, as we do here!

Block #

So as we discussed, most HTML elements are block-level by default. But you can also set display: block; manually on an inline element, too. This would mean that it starts on a new line, takes up the full width available, and you can specify a height, width, and use margin above and below:

Inline #

And going the other way, you can make block elements switch to inline with display: inline;. They will no longer start on their own lines, will only take up as much space as their content/children, and don’t accept height and width (or any -top/-bottom) properties:

But Also inline-block #

You can also combine the qualities of block and inline with display: inline-block;. These elements take height and width (and vertical margin) like block-level elements, but do not start on their own line:

And Sometimes none #

Setting display: none; hides an element visually from the document—as well as taking it out of the flow. (Keep in mind the HTML is still there, if someone opens up the source code.)

This is a common way to hide/show (by setting another display property) elements on the page, but it will reflow the document when applied—as if the element is actually added/removed from the HTML:

…vs. Visibility? #

You can also hide something visually without taking it out of the document flow, which is useful when you don’t want the page to jump/reflow when something appears/disappears.

Setting visibility: hidden; keeps the space an element had before, but makes it invisible and unable to be interacted with. The value visible is the default:

…vs. Opacity? #

Another way to hide an element visually is to adjust its opacity, which uses values on a scale from 0–1. This differs from visibility because elements with no (or partial) opacity can still be interacted with:

Keep in mind that display: none;, visibility: hidden;, and opacity: 0; only hide things in the rendered browser view. The HTML is still visible in the source code!

Left and Right #

The declarations float: left; and float: right; take an element out of the normal flow and place it on the left or right side of its parent container.

Any text siblings will then flow around the element—like a text wrap—filling up any available space to its side. They will go as far up as the top of the floated element:

Don’t Forget to clear #

Since this takes the floated element out of the flow, if we want the following element (often another text block, like a <p>) to not move up it needs to be cleared with clear: left; , clear: right;, or clear: both;.

Applied on the following element, it will make it stay entirely below (clear of) the floated element:

If you have a parent wrapper and no following element, there won’t be anything there to clear the float—meaning the parent will collapse down to the size of the text content. Almost never what you want.

You can solve this broken look with a clearfix hack, which uses a pseudo-element as an ersatz last-child to clear the container.

Generally, folks try and avoid floats—they aren’t common in modern design patterns and have been giving people headaches for… decades now.

They require you to know how long your content is and also how big your viewport/page will be—both things that you don’t always have control over in responsive/mobile 2024. But sometimes they are still the only thing that can do what you need!

… flex and grid? #

We’ll cover these next unit! They’ll make your (layout) life easier.

		E.g.:
____________

 H1 has a 1 character margin

 So does H2

     P starts here and could
     go on forever. Wow, a 5
     character left margin
     sure looks great!
      _____
     | + + | Wow, you can do
     |  @  | images as well?
     | --- | Then you'll
     |_____| want a 1 character
     margin on the left side.
     Until, you're below the
     image that is.

This is where we [find] the
simple stacked box model is
a bit too simple.

	

Håkon Wium Lie