Tuesday, June 25, 2024
HomeCSSCSS Size Models | CSS-Methods

CSS Size Models | CSS-Methods


You’re going to see quite a bit numbers in CSS. Listed below are a number of examples?

/* Integers */

/* Pixels */

/* em */

/* rem */

/* Proportion */

/* Characters */

/* Viewport models */

/* Container models */

Whereas these all imply various things, they basically do the identical factor: outline a component’s dimensions in CSS. We’d like models in CSS as a result of they decide the way to measurement parts on a web page, whether or not it’s the peak of a field, the width of a picture, the font-size of a heading, the margin between two parts, how lengthy an animation runs, and so on. With out them, the browser would don’t have any means of understanding the way to apply numbers to a component.

So, what the heck is px? What’s up with this factor known as rem? How are these completely different than different size models? The unit defines what sort of quantity we’re coping with, and each does one thing completely different, giving us a lot of methods to measurement issues in CSS.

Kinds of numbers

You might assume a quantity is only a quantity, and also you’re not improper. Numbers are numbers! However we are able to distinguish between a number of completely different varieties of numbers, which is useful context for discussing the various kinds of models we connect them to since “quantity” can imply, nicely, a quantity of various issues.

  • Integers (actually a unit-less quantity, e.g. 3)
  • Numbers (identical as an integer, solely measured in decimals, e.g. 3.2)
  • Dimensions (both a quantity or integer with a unit, e.g. 3.2rem)
  • Ratios (the quotient between two divided numbers, e.g. 3/2)
  • Percentages (e.g. 3%)

Acquired that? They’re all numbers however with nuances that make them ever-so-slightly completely different.

From right here, we are able to consider numbers in CSS as falling into two particular varieties of modelsabsolute and relative. Let’s begin issues off our deep dive on CSS size models by breaking these down.

Absolute models

An absolute unit is like Invoice Murray within the film Groundhog Day: it’s at all times the identical. In different phrases, regardless of the quantity is, that’s precisely the way it computes within the browser no matter how different parts are sized.

The most typical absolute worth you’ll see is the pixel worth. It’s form of laborious to outline, however a pixel is the smallest constructing block of a graphical show, like a pc display screen. And it’s based mostly on the decision of the display screen. So, in case you’re on a brilliant high-resolution display screen, a pixel shall be smaller than it will be on a low-resolution display screen, because the decision can pack extra pixels right into a smaller quantity of house for larger readability. However have a look at the instance under. All the containers are sized with pixels, so you will get a way of how massive 50px is in comparison with 250px.

Absolute values are good in that they’re predictable. That might, nonetheless, change in some conditions, significantly in the case of zooming. If, say, a person zooms right into a web page utilizing browser settings, then something outlined with an absolute worth goes to extend its absolute measurement accordingly. So, if the font-size of a paragraph is ready to 20px, the paragraph goes to be bigger because the person zooms nearer into the web page. And since zooming is commonly used to make content material extra readable, utilizing absolute values that retain their sizing could possibly be a very good strategy for making pages extra accessible by permitting customers to zoom issues as much as a spot that extra comfy to learn.

However then once more, see Josh Collinsworth’s click-baity, however improbable, put up titled “Why it’s best to by no means use px to set font-size in CSS” for an exhaustive rationalization of how pixels behave when used to set the font-size of a component. It’s an ideal learn to raised perceive the habits and limitations of pixel models.

And, hey: pixels are solely one in all many varieties of absolute lengths which are out there in CSS. In actual fact, we are able to group them by the varieties of issues they measure:

Size models

Size models are just a little humorous as a result of they will technically be both an absolute unit or a relative unit. However we’re discussing them in absolute phrases in the mean time and can revisit them after we get additional alongside to relative size models.

A size is basically a dimension, which is any integer proceeded by a unit, in accordance with the record of varieties of numbers we checked out earlier. And after we discuss dimensions, we’re actually speaking concerning the bodily measurement of a component.

Unit Title
cm Centimeters
mm Millimeters
Q Quarter-millimeters
in Inches
computer Picas
pt Factors
px Pixels

What we’re taking a look at listed here are the varieties of models you would possibly use see on a tape measure (e.g., cm and in) or in print design (e.g. computer and pt). They’re what they’re and what you see is what you get.

Angle models

Angle models are purely geometric. They’re good for setting form dimensions — like a circle’s radius, setting the route of a linear-gradient(), or setting the how a lot we wish to rotate() one thing.

Unit Title Description Instance
deg Levels A full circle is the same as 360deg. rotate(180deg)
grad Gradiens A full circle is the same as 400grad. rotate(200grad)
rad Radiens A full circle is the same as (i.e., 2 × 3.14), or about 6.2832rad. rotate(3.14rad)
flip Turns A full circle is 1turn, like a bicycle wheel making one full rotation. rotate(.5turn)
Time models

Time models are what you’d anticipate finding on a clock or watch, however solely measure in seconds and milliseconds. Apparently the online can’t be measured in minutes, hours, days, weeks, months, or years. Maybe we’ll get a brand new class of “calendar models” in some unspecified time in the future, or possibly there’s no good use case for that form of factor. 🤷‍♂️

Unit Title Description Instance
s Seconds One full minute of time is the same as 60s. animation-duration: 2s
ms Milliseconds One full second of time os equal to 1000ms. animation-duration: 2000ms
Frequency models

You received’t see frequency models used fairly often and for good cause: they’re not supported by any browser on the time of this writing. However they’re specced to vary sound frequency, corresponding to a sound’s pitch. One of the best I could make of it because it presently stands is that frequencies can be utilized to control an audio file with a better or decrease pitch measured in hertz and kilohertz.

Unit Title Description Instance
Hz Hertz Measures the variety of frequencies per second <supply src="https://css-tricks.com/css-length-units/tubthumping.mp3" sort="audio/mpeg" frequency="100Hz">
kHz Kilohertz A worth of 1Hz is the same as 0.001kHz. <supply src="https://css-tricks.com/css-length-units/tubthumping.mp3" sort="audio/mpeg" frequency="0.1kHz">

Should you’re questioning what constitutes a “low” pitch from a “excessive” one, the spec explains it like this:

[W]hen representing sound pitches, 200Hz (or 200hz) is a bass sound, and 6kHz (or 6khz) is a treble sound.

Decision models

Decision is what number of little dots are packed right into a display screen — such because the display screen you’re taking a look at proper now — the place extra dots per inch of house improves the readability and high quality of the show. The less dots there are, the extra pixelated and blurry the show.

Why would you want one thing like this? Nicely, it’s nice for concentrating on kinds to particular screens that assist sure resolutions in a media question.

img {
  max-width: 500px;

/* Double the decision and above */
@media (min-resolution >= 2dppx) {
  img {
    max-width: 100%;
Unit Title Description Instance
dpi Dots per inch The variety of dots packed into one inch of house. @media
(min-resolution: 96dpi) {}
dpcm Dots per centimeter The variety of dots packed into one centimeter of house. @media
(min-resolution: 960dpcm) {}
dppx (or x) Dots per pixel The variety of dots packed into one pixel of house. @media
(min-resolution: 1dppx) {}

Curiously, the specification makes point out of an infinite worth that’s supported by decision media queries for concentrating on screens with out decision constraints. It’s not a lot of a “catch-all” worth for concentrating on any form of display screen, however for circumstances after we’re utilizing the media question vary syntax to guage whether or not a sure worth is larger than, lower than, or equal to it:

For output mediums that don’t have any bodily constraints on decision (corresponding to outputting to vector graphics), this characteristic should match the infinite worth. For the aim of evaluating this media characteristic within the vary contextinfinite have to be handled as bigger than any doable <decision>. (That’s, a question like (decision > 1000dpi)shall be true for an infinite media.)

W3C Media Queries Degree 4 specification

Relative models

relative unit is extraordinarily well-named as a result of no matter worth we use for a relative unit depends upon the scale of one thing else. Say now we have an HTML component, a <div>, and we give it an absolute peak worth (not a relative one) of 200px.

<div class="field">
  I'm 200 pixels tall
.field {
  peak: 200px;

That peak won’t ever change. The .field component shall be 200px tall it doesn’t matter what. However let’s say we give the component a relative width (not an absolute one) of 50%.

<div class="field">
  I'm 200 pixels tall and 50% extensive
.field {
  peak: 200px;
  width: 50%;

What occurs to our field? It takes up 50%, or half, of the out there house on the display screen.

See that? Go forward and open that demo in a brand new window and alter the width of the display screen. And see, too, how the peak by no means modifications as a result of it’s an absolute size unit in pixels. The width, in the meantime, is fluidly resized as “50% of the out there house” modifications with the width of the display screen.

That’s what we imply when speaking about computed values with relative numbers. A relative quantity acts form of like a multiplier that calculates the worth used to set a size based mostly on what sort of unit it’s relative to. So, a price of 3rem goes to wind up turning into a unique worth when it’s computed.

Percentages, like 50%, are just one sort of relative unit. We’ve got many, many others. As soon as once more, it’s useful to interrupt issues out into separate teams to grasp the variations simply as we did earlier with absolute models.


We’ve already mentioned percentages in fairly good element. What makes a proportion relative is that it computes to a quantity worth based mostly on the size of one other component. So, a component that’s given width: 25% in a container that’s set to width: 1000px computes to width: 250px.

Unit Title Relative to…
% P.c The dimensions of the component’s father or mother container.
Font relative models

The em and rem models we checked out earlier are prime examples of relative models that you will notice in all places. They’re extremely useful, as we noticed, as a result of altering the font-size worth of a component’s father or mother or the <html> component, respectively, causes the component’s personal font-size worth to replace in accordance with the up to date worth.

In different phrases, we don’t have to straight change a component’s font-size when updating the font-size of different parts — it’s relative and scales with the change.

Unit Title Relative to…
em Aspect The font-size worth of the component’s father or mother container.
rem Root component The font-size worth of the <html> component.
ch Character The width of 1 character of content material relative to the father or mother component’s font. The computed width could replace when changing one font with one other, aside from monospace fonts which are persistently sized.
rch Root character The identical factor as a ch unit besides it’s relative to the font of the basis component, i.e. <html>.
lh Line peak The line-height worth of the component’s father or mother container.
rlh Root component line peak The line-height worth of the <html> component.
cap Capital letter The peak of a capital letter for a specific font relative to the father or mother component.
rcap Root capital letter The identical measure as cap however relative to the basis component, i.e. <html>.
ic Worldwide character The width of a CJK character, or overseas glyph, e.g. from a Chinese language font, relative to a component’s father or mother container.
ric Root worldwide character The identical measure as ic however relative to the basis component, i.e. <html>.
ex X-height The peak of the letter x of a specific font, or an equal for fonts that don’t include an x character, relative to the father or mother component.
rex Root x-height The identical measure as ex however relative to the basis component, i.e. <html>.

A few of these phrases will make extra sense to typography nerds than others. The next diagram highlights the strains that correspond to relative font models.

Four lines drawn over a line of text illustrating the ascender height, x-height, baseline, and descender height.

So, on the expense of beating this idea into the bottom, if width: 10ch computes to a sure variety of pixels when utilizing one font, it’s seemingly that the computed worth will change if the font is swapped out with one other one with both bigger or smaller characters.

Viewport relative models
Unit Title Relative to…
vh / vw Viewport Peak / Viewport Width The peak and width of the viewport (i.e., seen a part of the display screen), respectively.
vmin / vmax Viewport Minimal / Viewport Most The lesser and higher of vh and vw, respectively.
lvh / lvw Giant Viewport Peak / Giant Viewport Width The peak and width of the viewport when the system’s digital keyboard or browser UI is out of view, leaving a bigger quantity of accessible house.
lvb / lvi Giant Viewport Block / Giant Viewport Inline These are the logical equivalents of lvh and lvw, indicating the block and inline instructions.
svh / svw Small Viewport Peak / Small Viewport Width The peak and width of the viewport when the system’s digital keyboard or browser UI is in view, making the quantity of accessible house smaller.
svb / svi Small Viewport Block / Small Viewport Inline These are the logical equivalents of svh and svw, indicating the block and inline instructions.
dvh / dvw Dynamic Viewport Peak / Dynamic Viewport Width The peak and width of the viewport accounting for the out there house altering if, say, the system’s digital keyboard or browser UI is in view.
dvb / dvi Dynamic Viewport Block / Dynamic Viewport Inline These are the logical equivalents of dvh and dvw, indicating the block and inline instructions.
dvmin / dvmax Dynamic Viewport Minimal / Dynamic Viewport Most The lesser and higher of dvh/dvb and dvw/dvi, respectively.

Ah, viewport models! After we say that one thing needs to be 100% extensive, which means it takes up the total width of the include it’s in. That’s as a result of a proportion unit is at all times relative to its nearest father or mother component. However a  viewport unit is at all times relative to the scale of the viewport, or browser window. If a component has a viewport peak of 100vh and a viewport width of 100vw, then will probably be as tall and extensive as the total browser window.

This generally is a neat approach to create one thing like a hero banner on the prime of your web site. For instance, we are able to make a banner that’s at all times one half (50vh) the peak of the viewport making it outstanding regardless of how tall somebody’s browser is. Change the CSS within the top-left nook of the next demo from peak: 50vh to one thing else, like 75vh to see how the banner’s peak responds.

There’s one thing else that’s essential to know when working with viewport models. You know the way cell phones, like iPhone or an Android system, have digital keyboards the place you sort straight on the display screen? That keyboard modifications the scale of the viewport. That implies that at any time when the keyboard opens, 100vh is now not the total peak of the display screen however no matter house is leftover whereas the keyboard is open, and the structure may get tremendous squished because of this.

That’s why now we have the svh, lvh, and dvh models along with vh:

  • svh is the same as the “small” viewport peak, which happens when the keyboard is open.
  • lvh is the same as the “massive” viewport peak, which is when the keyboard is disabled and out of view.
  • dvh is a contented medium between svh and lvh in that it’s “dynamic” and updates its worth accordingly when the keyboard is displayed or not.
  • dvmin / dvmax is the higher ore lesser of dvh, respectively.

It’s a little bit of a tightrope stroll in some circumstances and a very good cause why container queries and their models (which we’ll get to subsequent) are rising in popularity. Take a look at Ahmed Shader’s article “New Viewport Models” for a complete rationalization about viewport models with detailed examples of the problems chances are you’ll run into. You might also be eager about Sime Vidas’s “New CSS Viewport Models Do Not Resolve The Traditional Scrollbar Downside” for a greater understanding of how viewport models compute values.

Container relative models
Unit Title Equal to…
cqw Container question width 1% of the queried container’s width
cqh Container question peak 1% of the queried container’s peak
cqi Container question inline measurement 1% of the queried container’s inline measurement, which is its width in a horizontal writing mode.
cqb Container question block measurement 1% of the queried container’s inline measurement, which is its peak in a horizontal writing mode.
cqmin Container question minimal measurement The worth of cqi or cqb, whichever is smaller.
cqmax Container question most measurement The worth of cqi or cqb, whichever is bigger.

Container models are designed for use with container queries. Simply as we’re in a position to goal a particular display screen measurement with a media question, we are able to goal the particular measurement of a specific component and apply kinds utilizing a container question.

We received’t do a giant ol’ deep dive into container queries right here. The related bit is that now we have CSS size models which are relative to a container’s measurement. For instance, if we had been to outline a container:

.parent-container {
  container-type: inline-size;

…then we’re watching that component’s inline-size — which is equal to width in a horizontal writing mode — and may apply kinds to different parts when it reaches sure sizes.

.child-element {
  background: rebeccapurple;
  width: 100%;

  @container father or mother (width > 30ch) {
    .child-element {
      background: dodgeblue;
      width: 50cqi;

Attempt resizing the next demo. When the father or mother container is larger than 30ch, the kid component will change backgrounds and shrink to one-half the father or mother container’s width, or 50cqi.

What about unit-less numbers?

Oh yeah, there are occasions once you’re going to see numbers in CSS that don’t have any unit in any respect — only a single integer or quantity with out something appended to it.

aspect-ratio: 2 / 1; /* Ratio */
column-count: 3; /* Specifies various columns */
flex-grow: 1; /* Permits the component to stretch in a flex structure */
grid-column-start: 4; /* Locations the component on a particular grid line */
order: 2; /* Units the order of elemnents in a flex or grid structure */
scale: 2; /* The elementis scaled up or down by an element */
z-index: 100; /* Aspect is positioned in a numbered layer for stacking */
zoom: 0.2;  /* The component zooms in or out by an element */

This isn’t a complete record of all of the CSS properties that settle for unit-less numeric values, however it’s a strong image of once you would use them. You’ll see that normally a unit-less quantity is an specific element, corresponding to a particular column to place a component, a particular layer in a stacking context, a boolean that permits or disables a characteristic, or the order of parts. However observe that anytime we declare “zero” as a quantity, we are able to write it with or with no prepended unit, as zero at all times evaluates to zero it doesn’t matter what unit we’re coping with.

border: 0; /* No border */
box-shadow: 0 0 5px #333; /* No shadow offset */
margin: 0; /* No margin */
padding: 0; /* No padding */

We will create our personal customized models!

In some circumstances, we could wish to work with a numeric worth, however CSS doesn’t precisely acknowledge it as one. In these circumstances, the quantity is acknowledged as a “string” worth as a substitute, no matter whether or not or not it incorporates alphabetical characters. That’s the place we are able to use @property to create what’s known as a “customized property” that evaluates a numeric worth in a sure means.

Right here’s a very good instance. There was a time when it was just about unimaginable to animate a gradient that modifications colours over time as a result of to take action would require (1) a coloration operate that enables us to vary a coloration worth’s hue (which now we have with hsl()) and (2) with the ability to interpolate that hue worth across the coloration spectrum, between a variety of 0deg and 360deg.

Sounds easy sufficient, proper? Outline a variable that begins at 0 after which cycles by 360 levels on the finish of an animation. However this doesn’t work:

/* 👎 */
.component {
  --hue: 0;
  animation: rainbow 10s linear infinite;
  background: linear-gradient(hsl(--hue 50% 50%);

@keyframes rainbow {
  from { --huw: 0; }
  to { --hue: 360deg; }

That’s as a result of CSS reads the variable as a string as a substitute of a quantity. We’ve got to register that variable as a customized property in order that CSS aptly reads it as a numeric worth.

@property --hue {
  syntax: "<quantity>";
  initial-value: 0;
  inherits: true;

There we go! Now that we’ve given CSS a touch that the --hue syntax is that of a <quantity>, we are able to animate away!

/* 👍 */
@property --hue {
  syntax: "<quantity>";
  initial-value: 0;
  inherits: true;

.component {
  --hue: 0;
  animation: rainbow 10s linear infinite;
  background: linear-gradient(hsl(--hue 50% 50%);

@keyframes rainbow {
  from { --huw: 0; }
  to { --hue: 360deg; }

Discover a deeper rationalization of this identical instance in “Interpolating Numeric CSS Variables” by Geoff Graham.

When to make use of one unit over one other

That is tremendous difficult as a result of CSS is extraordinarily versatile and there aren’t any definitive or hard-and-fast guidelines for when to make use of a particular sort of CSS size unit over one other. In some circumstances, you completely have to make use of a particular unit as a result of that’s how a sure CSS characteristic is specced, like utilizing angle models to set the route of a linear gradient:

.component {
  background: linear-gradient(
    135deg, pink, blue;

The identical goes for the values we use in sure coloration features, like utilizing percentages to set the saturation and lightness ranges within the hsl() operate:

.component {
  background: hsl(0 100% 10%);

Talking of coloration features, we outline alpha transparency with both an integer or quantity:

.component {
  background: hsl(0 100% 10% / 0.5); /* or just .5 */

All that being stated, many circumstances are going to be a point of “it relies upon” however there are some cases the place it is sensible to make use of a particular unit in your work.

Typically set font sizes in rem and em models

This fashion, you possibly can set issues up in a means the place altering the font-size worth of the <html> or a father or mother component updates the font sizes of their descendants.

html {
  font-size: 18px; /* Inherited by all different parts */

.father or mother {
  font-size: 1rem; /* Updates when the `html` measurement modifications */

.little one {
  font-size: 1em; /* Updates when the father or mother measurement modifications */

Declare “zero” with out models in case you’d like

It’s not a giant deal or something, however leaving off the models shortens the code a smidge, and anytime we’re in a position to write shorter code it’s a chance for quicker web page efficiency. The affect could also be negligible, however we’re in a position to do it since 0 at all times computes to 0, it doesn’t matter what unit we’re working with.

Use container models for responsive design, the place doable

Container queries usually are so gosh-darn nice for responsive layouts as a result of they have a look at the scale of the container and allow us to apply kinds to its descendants when the container is a sure measurement.

.father or mother {
  container: my-container / inline-size; /* Appears at width */

.little one {
  show: flex;
  flex-direction: column;
  max-width: 100vh; /* 100% of the viewport */

/* When the container is larger than 600px extensive */
@container my-container (width >= 600px) {
  .little one {
    flex-direction: row;
    max-width: 50%; /* 50% of the father or mother elenent */

So, if we going to measurement the .little one component — or any of its youngsters — it’s price specifying sizes in relation to the container’s measurement with container models than, say, the viewport’s measurement with viewport models.

.father or mother {
  container: my-container / inline-size; /* Appears at width */

.little one {
  show: flex;
  flex-direction: column;
  max-width: 100cqi; /* 100% of the container */

/* When the container is larger than 600px extensive */
@container my-container (width >= 600px) {
  .little one {
    flex-direction: row;
    max-width: 50cqi; /* 50% of the container */

Use percentages once you’re not sure of the context

Sure, use container models for responsive design, however that solely does you good if you already know you’re within the context of a container. It’s doable, although, that you simply use the identical element somewhere else, and a type of locations may not be a registered container.

In that case, go along with a proportion worth as a result of percentages are relative to no matter father or mother component you’re in, no matter whether or not or not it’s a container. This fashion, you possibly can declare a component’s measurement as 100% to take up the total house of no matter father or mother component incorporates it.

The one phrase of warning is to notice that we’re solely basing the scale on the father or mother. In the meantime, container models can type any descendant within the container, regardless of the place it’s positioned.

Viewport models are nice for laying out containers

You might be considering that viewport models are a foul factor since we’ve been advising in opposition to them in so many circumstances, like font sizing, however they’re nonetheless extremely helpful, significantly in the case of establishing a full-page structure.

I say “full-page” structure as a result of container queries are the gold normal for sizing parts in accordance with the house they’ve of their container. But when we’re working with a full web page of containers, that is the place viewport models can be utilized to ascertain a responsive structure at a better stage.

If the weather of particular person containers have a look at their container for sizing data, then the sizing and placement of particular person containers themselves in all probability ought to take a look at the viewport because it straight influences the quantity of house on the web page.


Aspect (em) and Relative component (rem) models

Let’s speak particularly about these two little buggers. We noticed how a proportion unit calculates its measurement by the scale of one thing else. em and rem models are form of the identical, however they’re calculated based mostly on the relative font measurement of particular parts.

Let’s begin with em models and say now we have an HTML component, a <div> with a .field class, and we set its font measurement to 20px. Meaning any textual content inside that component is 20px.

Nice, now what if we determine we’d like further textual content within the field, and provides it a relative font measurement of 1.5em?

See how a font measurement of 1.5em is bigger than the 20px textual content? That’s as a result of the bigger textual content is predicated on the field’s font measurement. Behind the scenes, that is what the browser is calculating:

20px * 1.5 = 30px

So, the relative font measurement is multiplied by the pixel font measurement, which winds up being 30px.

And guess what? rem models do the very same factor. However as a substitute of multiplying itself by the pixel font measurement of the father or mother container, it appears on the pixel font measurement of the particular <html> component. By default, that’s 16px.

/* That is the browser's default font measurement */
html {
  font-size: 16px;

.field {
  font-size: 1.5rem; /* 16px * 1.5 = 24px */

And if we modify the HTML component’s font measurement to one thing else?

html {
  font-size: 18px;

.field {
  font-size: 1.5rem; /* 18px * 1.5 = 27px */
Character unit (ch)

The character unit (ch) is one other is one other unit relative to font measurement and, whereas it isn’t used all that usually, it’s amazingly nice at sizing issues based mostly on the quantity of content material displayed in a component, as a result of one character unit equals the width of 1 character of content material. Right here’s how I wrap my very own head round it. If now we have this in our HTML:

<p>The massive brown canine lazily jumped over the fence.</p>

…and this CSS:

p {
  width: 10ch;

What we get is a paragraph that’s 10 characters extensive. Meaning the textual content will break after the tenth character, together with areas.

However observe that the phrases themselves don’t break. If the content material is meant to interrupt after 10 characters, the browser will begin the following line after a whole phrase as a substitute of breaking the phrase into a number of strains, conserving every little thing straightforward to learn.

Should you’re questioning once you would possibly attain for the ch unit, it’s completely boss at establishing line lengths which are extra nice and legible, particularly for lengthy type content material like this information you’re studying.

Line peak unit (lh)

The line-height unit (lh) appears on the line-height property worth of the component’s containing (i.e., father or mother) component and makes use of that worth to measurement issues up.

.father or mother {
  line-height: 1.5;

.little one {
  peak: 3lh; /* 3 * 1.5 = 4.5 */

When would you utilize this? Personally, I discover lh helpful for setting an actual peak on one thing based mostly on the variety of strains wanted for the textual content. You may see this clearly demonstrated in Temani Afif’s “CSS Ribbon” impact that makes use of lh to ascertain dimensions for every row of textual content that makes for consistently-sized strains that adapt to regardless of the father or mother component’s font-size worth occurs to be,

Absolute vs. Relative Models
Container Models
Viewport Models
Angle Models
Time Models
Decision Models


Please enter your comment!
Please enter your name here

Most Popular

Recent Comments