DEV Community: Vasco Neves

4# CSS Interview Topics

Vasco Neves — Sun, 11 Sep 2022 12:51:25 +0000

CSS Preprocessor
CSS Sprites

CSS Preprocessor

CSS Preprocessors are tools that extend the functionality of vanilla CSS by adding a wide variety of logical syntax such as you might see in a normal programming language. A browser can only understand CSS, which at times may not be enough to write clean and reusable rules.

A few of most popular CSS preprocessors:

Sass
LESS
Stylus
PostCSS

.circle {
  border: 1px solid #ccc;
  border-radius: 50px;
  overflow: hidden;
}
.avatar {
  @extend .circle;
}

.circle {
  border: 1px solid #ccc;
  border-radius: 50px;
  overflow: hidden;
}

.avatar:extend(.circle) {}

CSS Sprites

CSS Sprites are a means of combining multiple images into a single image file for use on a website. Using the image sprites instead of separate images will significantly reduce the number of HTTP requests a browser makes to the server, which can be very effective for improving the loading time of web pages and overall site performance.

Resource:. Svg sprit

3# CSS Interview Topics

Vasco Neves — Mon, 15 Aug 2022 16:02:00 +0000

BEM CSS
- Block
- Element
- Modifier

What is BEM CSS?

BEM stands for Block, Element, and Modifier. It’s a CSS naming methodology to reduce the CSS footprint and maintain large CSS codebases.

/* Block component */
.btn {}

/* Element that depends upon the block */ 
.btn__price {}

/* Modifier that changes the style of the block */
.btn--orange {} 
.btn--big {}

Block

A block holds every element inside and acts as a scope. Think of it as bigger structural chunks of your code.

<div class="card">
 <img src="...">
 <h2>...</h2>
 <p>...</p>
 <a>...</a>
</div>

Element

An element is a component within the block that performs a particular function. It should only make sense in the context of its block.

<div class="card">
 <img class="card__img" src="...">
 <h2 class="card__title" >...</h2>
 <p class="card__description" >...</p>
 <a class="card__button">...</a>
</div>

Modifier

A modifier adds additional styles to a specific element(s).

<div class="card card--dark">
 <img src="...">
 <h2 class="card__title card__title--large">...</h2>
 <p>...</p>
 <a>...</a>
</div>

2# CSS Interview Topics

Vasco Neves — Tue, 09 Aug 2022 18:04:18 +0000

Basic Selectors
- Universal Selector
- Element Selector
- Class & ID Selector
- Attribute Selectors
Grouping Selectors
Combinators Selectors
Pseudo Selectors
Selectors Priority

Basic Selectors

Universal Selector

Selector	Description
*	Selects all elements

Element Selector

Selector	Description
`<input>`	Selects all `<input>` elements

Class & ID Selector

Selector	Description
`.container`	Will match any element that has a class of "container"
`#firstname`	Will match any element that has a ID of "firstname"

Note:. There should be only one element with a given ID in a document.

Attribute Selector

Selector	Description
`[attr]`	Selects elements with a attr attribute
`[target="_blank"]`	Selects elements with an target matching
`[title~="flower"]`	Select elements with an attribute value containing a specified word "flower"
`[class^="top"]`	Selects all elements with a class attribute value that starts with "top"
`[href$=".org"]`	Selects elements with an href ending ".org"
`[href*="exam"]`	Selects elements with an href containing "exam"

[class=|"top"] Select elements with the specified attribute, whose value can be exactly the specified value, or the specified value followed by a hyphen, like class="top-text"

Grouping Selectors

Selector	Description
`div,span`	Selects both elements

Combinators Selectors

Selector	Description
`div p`	Selects nodes that are descendants of the first element
`ul > li`	Selects nodes that are direct children of the first element
`div ~ p`	Selects both elements
`h2 + p`	Matches the second element only if it immediately follows the first element

col || td Matches the second element only if it immediately follows the first element

Pseudo Selectors

Selector	Description
`:`	Selects elements based on state information that is not contained in the document tree
`::`	Selects the pseudo element

Selectors Priority

The more specifically a CSS selector targets an HTML element, the higher is its specificity. We can imagine that each CSS selector have a value assign like you can see below, the higher the value the more importance have.

Inline style worth 1000
#id selectors are worth 100
.class selectors are worth 10
tag selectors are worth 1

CSS Selector	Description
Inherited styles	Lowest specificity of all selectors - since an inherited style targets the element's parent, and not the HTML element itself.
*	Lowest specificity of all directly targeted selectors
element	Higher specificity than universal selector and inherited styles.
attribute	Higher specificity than element selector
class	Higher specificity than attribute, element and universal selectors.
ID	Higher specificity than class selector.
Combined selectors	Gets the specificity of the selectors combined.
CSS properties set directly on element, inside style attribute.	Stronger specificity than ID selector.

BUT everything changes when it is used !important
and why is that, basically !important change the priority of the selectors and the one that have it will even override inline styles.

1# CSS Interview Topics

Vasco Neves — Wed, 03 Aug 2022 10:41:42 +0000

CSS is one of the essential skills for frontend developers and a topic that is normally asked about in interview process.

Flexbox Layout
Grid Layout
When to use it?

Flexbox Layout

Flexbox Layout was designed for a layout in one dimension, either a row or a column.

Property	Values
display:	flexbox, inline-flex;
flex-direction:	row, row-reverse, column, column-reverse;
flex-wrap:	nowrap, wrap, wrap-reverse;
flex-flow:	<‘flex-direction’>, <‘flex-wrap’>
justify-content:	flex-start, flex-end, center, space-between, space-around;
align-items:	flex-start, flex-end, center, baseline, stretch;
align-content:	flex-start, flex-end, center, space-between, space-around, stretch;

Flex Properties

Grid Layout

Grid was designed for two-dimensional layout, rows and columns at the same time.

Property	Description
column-gap	Specifies the gap between the columns
gap	A shorthand property for the row-gap and the column-gap properties
grid	A shorthand property for the grid-template-rows, grid-template-columns, grid-template-areas, grid-auto-rows, grid-auto-columns, and the grid-auto-flow properties
grid-area	Either specifies a name for the grid item, or this property is a shorthand property for the grid-row-start, grid-column-start, grid-row-end, and grid-column-end properties
grid-auto-columns	Specifies a default column size
grid-auto-flow	Specifies how auto-placed items are inserted in the grid
grid-auto-rows	Specifies a default row size
grid-column	A shorthand property for the grid-column-start and the grid-column-end properties
grid-column-end	Specifies where to end the grid item
grid-column-gap	Specifies the size of the gap between columns
grid-column-start	Specifies where to start the grid item
grid-gap	A shorthand property for the grid-row-gap and grid-column-gap properties
grid-row	A shorthand property for the grid-row-start and the grid-row-end properties
grid-row-end	Specifies where to end the grid item
grid-row-gap	Specifies the size of the gap between rows
grid-row-start	Specifies where to start the grid item
grid-template	A shorthand property for the grid-template-rows, grid-template-columns and grid-areas properties
grid-template-areas	Specifies how to display columns and rows, using named grid items
grid-template-columns	Specifies the size of the columns, and how many columns in a grid layout
grid-template-rows	Specifies the size of the rows in a grid layout
row-gap	Specifies the gap between the grid rows

Grid Properties

The fr unit

The fr unit represents a fraction of the available space in the grid container.

When to use it?

The main difference between the Flexbox and Grid layout is that Flexbox creates content-first design while Grid creates layout-first design.

If you are well aware of your content before making the layout, then the better option will be to use Flexbox, otherwise opt for the Grid.

Flexbox layout is the most appropriate for the components and small-scale layouts.

Grid layout is more focused to larger scale layouts which aren’t linear in their design.

Javascript Hoisting

Vasco Neves — Tue, 02 Aug 2022 20:57:40 +0000

JavaScript Hoisting is one of the hot topics in a interview process and that is why I am going to help you master hoisting.

What is it?

Scope
Blocks
Global Scope
Block Scope
Scope Pollution

How it works?

Variable Hoisting
Function Hoisting
Class Hoisting

Exercises

Hoisting Exercises

Scope

Scope defines where variables can be accessed or referenced.

Blocks

Block is the code found inside a set of curly braces {}

function greet() {
    b = 'hello';
    console.log(b); // hello
    var b;
}

greet();

Global Scope

Global scope are variables that are declared outside of blocks.

const color = 'blue';

const returnSkyColor = () => {
  return color; // blue 
};

console.log(returnSkyColor()); // blue

Block Scope

Variables that are declared with block scope are known as local variables, because they are only available to the code that is part of the same block.

const logSkyColor = () => {
  let color = 'blue'; 
  console.log(color); // blue 
};

logSkyColor(); // blue 
console.log(color); // ReferenceError

Scope Pollution

Scope pollution is when we have too many global variables that exist in the global namespace, or when we reuse variables across different scopes.

let num = 50;

const logNum = () => {
  num = 100; // Take note of this line of code
  console.log(num);
};

logNum(); // Prints 100
console.log(num); // Prints 100

Variable Hoisting

Variable hoisting acts differently depending on how the variable is declared (var,let,const).

Notes:

Variables declared with the keyword let are block scoped;
The const keyword allow immutable variables. That is, variables whose value cannot be modified once assigned;
Variables declared with let and const remain uninitialised at the beginning of execution whilst variables declared with var are initialised with a value of undefined.

Variable var

var foo;

console.log(foo); // undefined

foo = 'foo';

console.log(foo); // "foo"

Variable let & const

console.log(foo); // Uncaught ReferenceError: Cannot access 'foo' before initialization

let foo = 'bar';  // Same behavior for variables declared with const

Function hoisting

Function hoisting allows us to call a function before it is defined

foo(); // "foo"

function foo() {
    console.log('foo');
}

BUT NOT Function Expressions

foo(); // Uncaught TypeError: foo is not a function
var foo = function () { }

bar(); // Uncaught ReferenceError: Cannot access 'bar' before initialization
let bar = function () { }

baz(); // Uncaught ReferenceError: Cannot access 'baz' before initialization
const baz = function () { }

Class Hoisting

var Frodo = new Hobbit();
Frodo.height = 100;
Frodo.weight = 300;
console.log(Frodo); // Output: ReferenceError: Hobbit is not defined

class Hobbit {
  constructor(height, weight) {
    this.height = height;
    this.weight = weight;
  }
}

Hoisting Exercises


function func11(){
    var a=5;
    console.log(a, b); 
    var b=6;
}
func11();

console.log(var1);   
var var1 = 1;
function func(){
  console.log(var1);    
  var var1 = 2;
  console.log(var1);    
}
var var1 = 3;
console.log(var1);     
func();

function func(){
  //console.log(var1);   
  //console.log(let1);   
  if(true){
    var var1 = 2;
    let let1 = 23;
  }
  //console.log(var1);   
  //console.log(let1);   
}
var var1 = 3;
func();

func1();        
func2();        
function func1(){
    console.log('func1');
}
var func2 = function(){
    console.log('func2');
}

var var1=2;
console.log(i);       
for(var i=0; i<11; i++){
    console.log('asdf');
}
console.log(i);