Getting started with the @belongings CSS rule

The CSS @property is a great operation that brings additional control and flexibility to custom properties, often known as CSS variables.

It was introduced as part of the CSS Houdini initiative, which was designed to give developers deeper access to the browser’s rendering engine. @property The rule means that you can define custom properties with specific types, default values, and even the ability to animate CSS cases.

In this article we will find out what @property The rule is because it is useful and the best way you can leverage it for your web activities.

What is it? @property For?

CSS custom properties, often known as CSS variables, have made sorts even more reusable. This means you can define a value once and use it everywhere in your stylesheet.

However, one limitation has been the inability to specify a property’s type or set default values ​​all at once in CSS. This means that any value can also be assigned to a convention property, which can lead to unexpected results and make it harder to take care of your sorts in some situations.

This is the position @property rule is available. This means that you can set a default value, provides a fallback value that could be used if the custom property is not explicitly set, allows the custom property to be animated, and defines a type for a convention property.

This promises that a variable {{a}} can best accept a chosen type of information, such as a size, a color, or a value.

The property type is printed with the syntax property. Accepts a string value that defines the value of the CSS type, as follows:

Example

Let’s say we now have a button phase. We’d like to set some defaults for this phase. Traditionally, we would use custom properties to set the background color and border radius of the button phase, like this:

.button {
  background-color: #fff;
  border-radius: 8px;
}

Or, use CSS variables to set values ​​once and reuse them throughout your stylesheet:

:root {
  --button-bg: #fff;
  --button-rounded: 8px;
}

What if we wanted to make sure that the background color is always a sound color value and the border radius is always a sound size value?

We can use the @property rule to establish the type of custom properties and set the default values.

To do this, we need to create a couple of custom properties defined with the following alternatives inside @property rule:

@property --button-bg {
  syntax: '';
  initial-value: #0D74CE;
  inherits: false;
}
@property --button-rounded {
  syntax: '';
  initial-value: 8px;
  inherits: false;
}

In this example we now have two custom properties that define the background color and the border radius of the button stage.

We use the syntax property to specify the type of custom property, while the initial-value property gadget the default value.

We also use the inherits property to specify whether or not the custom property inherits its value from the parent stage, in which case we set all to false to prevent inheritance.

Once set, we can use custom properties in our sorts, like this:

.button {
  background-color: var(--button-bg);
  border-radius: var(--button-rounded);
}

See @belongings CSS pen via HONGKIAT (@hkdc)
on CodePen.

In conclusion

The CSS @property the rule takes a very powerful step forward to custom CSS properties, or CSS variables. All number one and newer browsers already improve CSS properties @property rule.

To summarize, CSS @property rule is a great operation and an excellent addition to the CSS language that allows you to write more maintainable and type-safe stylesheets. For those who haven’t already, check it out for your next effort!

The article Getting Beginning with CSS @belongings Rule first appeared on Hongkiat.

wordpress website Development

Source: https://www.hongkiat.com/blog/css-property-rule/

[ continue ]

wordpress Maintenance Plans | wordpress hosting

Learn more