DEV Community: Ankit Kumar

Django authenticate and login methods

Ankit Kumar — Fri, 20 Oct 2023 15:09:11 +0000

Django comes with a robust authentication system that handles both authentication and authorization. In this post let's talk about two of its methods authenticate() and login().

authenticate()

The authenticate method is used to verify the user's credentials against the authentication backends defined in the project. it takes the user's credentials as arguments and returns user object if the credentials are valid and if the credentials are invalid then it returns None

login()

The login() function is used to create user sessions and log them in. It takes a HttpRequest object and a User object saves the user's ID in the session using Django’s session framework and sets a session cookie in the user's browser, allowing them to remain authenticated across different pages and requests.

Example to create a login_view using both methods

from django.contrib.auth import authenticate, login
from django.http import HttpResponse
from django.shortcuts import render
from django.contrib.auth.models import User

def login_view(request):
    if request.method == 'POST':
        username = request.POST['username']
        password = request.POST['password']
        user = authenticate(request, username=username, password=password)
        if user is not None:
            login(request, user)
            return HttpResponse("Logged in successfully")
        else:
            return HttpResponse("Authentication failed. Please try again.")

    return render(request, 'login.html')

Working with Python Dictionary

Ankit Kumar — Fri, 13 Oct 2023 17:08:39 +0000

A dictionary is one of the many built-in datatypes of Python, A dictionary allows us to store data in key-value pairs, where the key must be unique. it is also known as “associative memories” or “associative arrays” in some other programming languages. A dictionary contains comma-separated key:value pairs enclosed within {}. In a dictionary, the different keys can have the same values but the key must be unique.

Creating Dictionary

Using Curly Braces {}:

To create a dictionary in Python we use a pair of curly brackets {} and store comma-separated key-value pairs in it.

# empty dictionary
my_dict = {}
print(type(my_dict)) # <class 'dict'>

# storing value in dictionary
my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
print(my_dict) # my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

Note:

Dictionaries in Python must have unique keys. When the same key is provided multiple times, the last one overwrites the previous one.

user = {
    'name': 'John',
    'age': 25,
    'email': 'john.doe@example.com',
    "name": "James" # using the same key
}
print(user) # {'name': 'James', 'age': 25, 'email': 'john.doe@example.com'}

Using dict() Constructor:

We can also use dict() constructor to create a dictionary, and to store some data in it. We can pass key-value pairs as arguments or as a list of tuples. Take a look at the examples below.

my_dict = dict()
print(type(my_dict)) # <class 'dict'>

# stroing data as arguments
my_dict = dict(key1='value1', key2='value2', key3='value3')
print(my_dict) # {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

# stroring data as list of tuples
my_dict = dict([('key1', 'value1'), ('key2', 'value2'), ('key3', 'value3')])
print(my_dict) # {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

Accessing Data from Dictionary

Using Square Brackets:

We can use square brackets with keys to access its corresponding values. If the key is not present in the dictionary a KeyError will be raised.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}

print(user['name']) # John Doe
print(user['age']) # 25
print(user['email']) # john.doe@example.com

print(user['phone']) # KeyError

Using `get()` method:

The get() method allows us to retrieve the value associated with the key, if the key is not present in the dictionary then it returns None or the default_value if it is specified.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}

print(user.get('name')) # John Doe
print(user.get('age')) # 25
print(user.get('email')) # john.doe@example.com

print(user.get('phone')) # None
print(user.get('phone','No Phone Number')) # No Phone Number

Accessing keys of the dictionary:

To get all the keys of a dictionary we use dict.keys() method. It returns a view object that contains all the keys of the dictionary. This view object is a dynamic view, meaning it reflects any changes made to the dictionary, If we add or remove an item to the dictionary, the view will automatically update. we can also use dict.keys() method to iterate over the keys of a dictionary using a for loop or we can use it to test the membership of any key in the dictionary. Take a look at the example below to learn about different actions we can perform using the dict.keys() method.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}
print(user.keys()) # dict_keys(['name', 'age', 'email'])

# adding a new key to the dictionary
user['phone'] = '9898989898'
print(user.keys())  # dict_keys(['name', 'age', 'email', 'phone'])

# Iterating over the keys of a dictionary
for i in user.keys():
  print(i)

# Testing membership
if 'phone' in user.keys():
  print("True")
else:
  print("False")

# converting the view object to a static list
static_list = list(user.keys())
print(static_list)  # ['name', 'age', 'email', 'phone']

Accessing Values of the dictionary.

To access all the values of the dictionary we use the dict.values() method. It returns a view object that contains all the values of the dictionary. This view object is a dynamic view, meaning it reflects any changes made to the dictionary, If we add or remove an item to the dictionary, the view will automatically update. The view object can be iterated and it also supports membership testing, which means we can use dict.values() the method to iterate over the values of the dictionary or to test the membership of some value in the dictionary. Take a look at the example below.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}
print(user.values())  # dict_values(['John Doe', 25, 'john.doe@example.com'])

# adding a new item to the dictionary
user['phone'] = '9898989898'
print(user.values())  # dict_values(['John Doe', 25, 'john.doe@example.com', '9898989898'])

# Iterating over the keys of a dictionary
for i in user.values():
  print(i)

# Testing membership
if 25 in user.values():
  print("True")
else:
  print("False")

# converting the view object to a static list
static_list = list(user.values())
print(static_list)  # ['name', 'age', 'email', 'phone']

Accessing items from the dictionary

we use dict.items method to access all the items from the dictionary. It returns a view object that contains a list of tuples with key-value pairs of the dictionary. The view object is the same as we learned in dict.keys() or dict.values() methods. Take a look at the example below.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}
print(user.items())  # dict_items([('name', 'John Doe'), ('age', 25), ('email', 'john.doe@example.com')])

# adding a new item to the dictionary
user['phone'] = '9898989898'
print(user.items())  # dict_items([('name', 'John Doe'), ('age', 25), ('email', 'john.doe@example.com'), ('phone', '9898989898')])

# Iterating over the keys of a dictionary
for key, value in user.items():
  print(key, value)

# Testing membership
if ('age', 25) in user.items():
  print("True")
else:
  print("False")

# conveting the object view to static list
static_list = list(user.items())
print(static_list)  # [('name', 'John Doe'), ('age', 25), ('email', 'john.doe@example.com'), ('phone', '9898989898')]

Modifying Dictionary

While working with a dictionary, we will need to add new data, delete existing data, or update the existing data from the dictionary, in this section of the article we will learn about this.

Adding new data

We can add new key-value pairs to the dictionary either by using square brackets or by using dict.update() method let's take a look at them one by one. Any new key:value pair added to the dictionary will be added at the end of the dictionary since the dictionary maintains the order of its items.

Using Square Brackets:

Syntax :-

dict[key] = value

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}

# adding new key value pair
user['phone'] ='9898989898'
user['username'] = 'john'

print(user) # {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com', 'phone': '9898989898', 'username': 'john'}

Using the update method:

The update() method is used to update a dictionary with elements from another dictionary or from an iterable of key-value pairs (as tuples or other iterable of length two) or keyword arguments. This method modifies the dictionary in place, adding new key-value pairs or if the key already exits it updates the value of it.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}

# updating with another dictionary 
extra_data = {"phone": "989898989", "username": "john"}
user.update(extra_data)
print(user)  # {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com', 'phone': '989898989', 'username': 'john'}

# updating with list of tuples
extra_data = [("phone", "989898989"), ("username", "john")]
user.update(extra_data)
print(user)  # {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com', 'phone': '989898989', 'username': 'john'}

# updating with keyword arguments
user.update(phone="989898989", username="john")
print(user)  # {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com', 'phone': '989898989', 'username': 'john'}

# updating values of a key 
user.update(phone="989898989", username="john",age=30)
print(user)  # {'name': 'John Doe', 'age': 30, 'email': 'john.doe@example.com', 'phone': '989898989', 'username': 'john'}

Removing data from the dictionary

Using del statement

del statement is used to remove key-value pairs from the dictionary. It takes a key and removes the key and its corresponding value from the list. if the key is not present in the dictionary it raises KeyError. We can even delete the complete dictionary using the del statement.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}

# removing item with del statement
del user['name']
print(user) # {'age': 25, 'email': 'john.doe@example.com'}

# trying to delete item that doesn't exists in the dictionary
del user['phone'] # KeyError: 'phone'

# removing the complete dictionary
del user

Using the pop() method:

pop() methods accept a key and optional default value, it removes the specified key from the dictionary and returns its value. If the key is not in the dictionary it returns the default value if it is specified else it raises a key error.

Syntax:

dict.pop(key,default_value)

key: The key whose associated value is to be retrieved and removed.

default (optional): If the key is not found, the default value is returned (if provided). If not provided and the key is not found, a KeyError is raised.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}

# using pop method to remove item from the list
returned_value = user.pop('name')
print(returned_value) # John Doe

# using default value
returned_value = user.pop('phone',"Invalid key")
print(returned_value) # invalid key

# using invalid key without default value
returned_value = user.pop('username')
print(returned_value) # KeyError

print(user) # {'age': 25, 'email': 'john.doe@example.com'}

Using dict.clear() method:

dict.clear() method is used to remove all the key-value pairs from the dictionary and returns None.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}

# using clear method
returned_value = user.clear()
print(returned_value) # None
print(user) # {}

Using Loops with Dictionary

Note:

The dictionary preserves the insertion order, which means the order in which items are added to a dictionary will be maintained, when we iterate through the items of a dictionary, they will be in the same order in which they were inserted. However, we can't access the items in the dictionary using their position because items in the dictionary are key-indexed not position-indexed.

Using for loop with dictionary:

When we loop over the dictionary it implicitly loops over its keys.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}

for val in user:
  print(val)

# Output
'''
name
age
email
'''

but we can use these keys to access their corresponding values.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}

for val in user:
  print(user[val])

# Output
'''
John Doe
25
john.doe@example.com
'''

Looping through keys or values.

As we have seen in this article earlier we can user dict.values() to get values of the list and dict.keys() to get list of keys.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}

# looping through keys
for key in user.keys():
  print(key)

# looping through values
for val in user.values():
  print(val)

Looping through key-value pairs

We can use dict.items() to loop through the key-value pairs of the dictionary. dict.items() method returns tuples of key-value pairs of a dictionary.

user = {'name': 'John Doe', 'age': 25, 'email': 'john.doe@example.com'}

# looping through key-value pairs
for key,value in user.items():
  print(f"Key: {key}, Value: {value}")

Dictionary Comprehension

Comprehensions:

Comprehension in Python is syntactic sugar, it allows us compact and shorter syntax to create new sequences (set, list, dictionary). Take a look at a simple example below.

Syntax:

dict = {key: value for i in iterable}

# Create a dictionary with squares of numbers from 1 to 5
my_dict = {num: num**2 for num in range(1, 6)}
print(my_dict) # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Choosing the correct key

We know that keys in the dictionary must be unique, but what are the possible candidates for keys?

Any immutable type can serve as a key, such as a number, string, or tuple. If you use a tuple as a key, it must only contain immutable types such as a number, string, or another tuple.

As another way to put it, keys need to be hashable to be used in dictionaries. Hashable means that the value should have a fixed hash value that doesn't change during its lifetime.

# Using numbers as keys
number_dict = {1: 'One', 2: 'Two', 3: 'Three'}

# Using strings as keys
string_dict = {'apple': 1, 'banana': 2, 'orange': 3}

# Using a tuple with immutable elements as a key
tuple_dict = {('John', 25): 'Student', ('Alice', 30): 'Teacher', ('Bob', 22): 'Engineer'}

Dictionary methods

Method	Description
`dict.keys()`	Returns keys view
`dict.values()`	Returns values view
`dict.items()`	Returns key-value pairs view
`dict.get(key, default)`	Returns value for key, or default if key not found
`dict.pop(key, default)`	Removes and returns value for key
`dict.popitem()`	Removes and returns the last key-value pair
`dict.update(other_dict)`	Updates the dictionary with another dictionary
`dict.clear()`	Removes all items from the dictionary

Summary:-

Python dictionaries are collections that store data in key-value pairs, enclosed in curly braces {}.
Keys in a dictionary must be unique, and dictionaries are mutable (modifiable).
Creating dictionaries can be done using curly braces {} or the dict() constructor.
Accessing data in a dictionary is possible through square brackets or the get() method.
Modifying dictionaries involves adding, removing, or updating key-value pairs.
Keys in dictionaries must be hashable, and any immutable type can be used as a key.
Loops can be used with dictionaries, implicitly iterating over keys or explicitly using methods like keys(), values(), or items().
Dictionary comprehension provides a concise syntax for creating dictionaries in a single line.
The dictionary preserves the insertion order, which means the order in which items are added to a dictionary will be maintained, when we iterate through the items of a dictionary, they will be in the same order in which they were inserted. However, we can't access the items in the dictionary using their position because items in the dictionary are key-indexed not position-indexed.
using len(dict) function with a dictionary will return the number of key:value pairs in the dictionary.
using sorted(dict) function will return a sorted list of keys.
using max(dict) function will return the maximum key in the dictionary.
using min(dict) function will return the minimum key in the dictionary.
using sum(dict) function will return the sum of all the keys if the keys are numbers.

Note: This article is not written by AI.

Introducing TypeTales

Ankit Kumar — Thu, 18 May 2023 00:38:40 +0000

What I built

I built a social media application where users can share stories in up to 500 characters. The application includes features such as story listing, liking stories, nested comments, following and unfollowing other users, trending stories and many more.

Category Submission:

Wacky Wildcard

App Link

https://type-tales.vercel.app/

Screenshots

Home Page

User Profile

Story Details

Description

This is a microblogging social media app, it's called TypeTales and it lets you share stories with the world in up to 500 characters. You can browse through different stories, like the ones you enjoy, leave comments and join the conversation and even follow or unfollow the authors. You can also see which stories are trending and get inspired by them. I built this application using React, Node.js, MongoDB, and Express. It was a fun and challenging experience, and I learned a lot along the way. I hope you enjoy using it as much as I enjoyed making it.

Link to Source Code

https://github.com/ankitdevelops/type-tales

Permissive License

MIT license

Background (What made you decide to build this particular app? What inspired you?)

Currently I am learning MERN stack, so after learning the basics of it, I wanted to build something on my own. That's how I came up with this project idea. Then I saw the hackathon announcement blog and I felt really inspired to finish it. I'm proud of what I've built with this project.

How I built it (How did you utilize GitHub Actions or GitHub Codespaces? Did you learn something new along the way? Pick up a new skill?)

I built this app using Expressjs for the backend and MongoDB with Mongoose ODM for the database. I deployed the backend and database on railway.app, which is a great platform for hosting Node.js applications. I deployed the frontend on vercel, which is another awesome service for web development. This app taught me a lot about writing controllers and complex queries in MongoDB using Mongoose ODM. I enjoyed working on this project. During the development of this application, I have not utilized GitHub actions but both railway and vercel support continuous deployment, so the app automatically gets deployed when new changes is made.

Some of the Challenges I faced

One of the most difficult challenges of developing this project was implementing the comment system with replies.
Building the follow/unfollow systems and writing queries for trending section was also quite challenging for me.

Additional Resources/Info

Tech Stack

MongoDB
ReactJs
ExpressJs
NodeJs

Conclusion

In conclusion, the development of TypeTales, my microblogging social media application, has been a rewarding and exciting journey that has allowed me to showcase my skills as a developer. Throughout this project, I faced challenges and learned valuable lessons that have further enhanced my knowledge and experience in web development and the MERN stack. Building TypeTales has provided me with a deeper understanding of React, Node.js, MongoDB, and Express. I have honed my skills in writing controllers, implementing complex queries with Mongoose ODM, and handling user interactions in a social media context. This project has given me the opportunity to apply my knowledge and creativity to create a unique and engaging platform for sharing stories.

Links

GitHub: https://github.com/ankitdevelops/type-tales
Live Web Page: https://type-tales.vercel.app/

Credentials

email: ankit@gmail.com
password: testing321

Getting started with Express: Building your first app

Ankit Kumar — Sun, 02 Apr 2023 12:53:35 +0000

In this article, we are going to create our first express app, to get started with this article make sure the following tools are installed in your system.

NodeJs -
- To verify whether nodejs is installed or not, open your terminal and run the command node -v and npm -v this should give any version number.
Vscode
postman

Step 1: Basic Setup

First, we will create a project folder, we can do that using the GUI, but let's try to create that by using the terminal.

mkdir helloExpress - mkdir command is used to create a new directory. so this command will create a new directory helloExpress
cd helloExpress/ - cd is used to change the directory. So this command will change the current directory to the helloExpress directory.
code . this command will open vscode in the current directory.

Now the next step is to create our package.json file. package.json file is a simple JSON file located in the project root directory. This file contains important information about the project like name, version, dependencies, and other configuration options. Every nodejs project contains a package.json file.

To create the package.json file open the in-built terminal of vs code, you can use ctrl + ` . Now we are going to write the command npm init . This will initialize a new node js project and ask you to fill in a bunch of information about the project. You can give that information or keep pressing enter to either keep them empty or default, and if you don't want to keep pressing enter then you can use npm init -y this will skip all the question prompts and set them to default.

This is how our package.json file looks currently.

{
  "name": "helloexpress",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC"
}

Now the next step is to create an entry point for our application, we will create a new index.js file in the project root directory.

// index.js file
console.log("Hello Express");

Currently, We only have a simple console message in our index.js file.

Now we will add script in our package.json file.

{
  "name": "helloexpress",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "start": "node index.js"
  },
  "author": "",
  "license": "ISC"
}

Now when we run the command npm start then it should display Hello Express message in the console.

Step 2: Express and nodemon Installation.

In this section of the article, we are going to install Express and nodemon and do a basic setup of express and nodemon.

installing Express

Express is a popular and widely-used web application framework for Node.js. It provides a set of features and tools for building web applications and APIs.

To install Express run command npm install express in the vscode in-built terminal.

Installing nodemon

Nodemon is a command-line tool that monitosr for any changes in your source and automatically restart your server.

To install nodemon run the command npm i nodemon -D . nodemon is used for development and testing purposes, that's why we install it as devDependencies for installing any package as devDependencies we use -D flag.

Now nodemon is installed, let's modify the script in package.json file.

{
  "name": "helloexpress",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "start": "nodemon index.js"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "express": "^4.18.2"
  },
  "devDependencies": {
    "nodemon": "^2.0.22"
  }
}

Now try doing any changes in index.js file and save it, and your server will start automatically.

Step 3: Express Setup

Let's move to index.js file and start setting up our app. Let's add the following code to your index.js file and then I will try to explain you each and every line.

const express = require("express");
const app = express();
const port = 3000;

app.get("/", (req, res) => {
  res.send("Hello Express");
});

app.listen(port, () => {
  console.log(`listening on port ${port}`);
});

const express = require("express");

This line imports the Express module and assigns it to express variable. This allows us to use the functionality provided by the Express framework.

const app = express();

This creates an instance of the Express application and assigns it to app variable. This is the main object that we will use to configure and interact with our application.

const port = 3000;

This line sets our port to 3000, our server will listen for any incoming request on this port only.

app.get("/", (req, res) => {
  res.send("Hello Express");
});

The above line sets up a GET route on the root URL ("/") of our server. It accepts two arguments PATH and a Handler function. When a user makes a request to the root URL, the function passed as the second argument will be executed. In this case, the function sends the string "Hello World!" as the response.

app.listen(port, () => {
  console.log(`listening on port ${port}`);
});

This line starts the server and listens for incoming requests on the specified port. When the server starts listening for any incoming request, the function passed as the second argument will be executed, which logs a message to the console indicating that the server is listening on the specified port.

Now if you open localhost:3000 in your browser, it will show you Hello Express message.

While working with Express we usually don't send this type of one-line message usually we send JSON data which might be coming from the database, but currently, we don't have that type of knowledge so let's create some static JSON data and try to send that as a response. This is the data we are going to send as response.

const data = [
  {
    id: 1,
    first_name: "Leonid",
    last_name: "Bardsley",
    email: "lbardsley0@yahoo.co.jp",
    gender: "Male",
  },
  {
    id: 2,
    first_name: "Tybalt",
    last_name: "Antushev",
    email: "tantushev1@storify.com",
    gender: "Male",
  },
  {
    id: 3,
    first_name: "Bethena",
    last_name: "Worgen",
    email: "bworgen2@virginia.edu",
    gender: "Female",
  },
  {
    id: 4,
    first_name: "Bartram",
    last_name: "Matts",
    email: "bmatts3@myspace.com",
    gender: "Non-binary",
  },
  {
    id: 5,
    first_name: "Marice",
    last_name: "Pavlenkov",
    email: "mpavlenkov4@tmall.com",
    gender: "Bigender",
  },
];

Next, we need to add a new GET Route and add the following line.

app.get("/users", (req, res) => {
  res.status(200).json(data);
});

The above line sets up a new GET route on the root URL ("/users") of our server. It accepts two arguments PATH and a Handler function. When a user makes a request to the URL, the function passed as the second argument will be executed. In this case, the function sends a JSON string as the response. The status() method sets the HTTP status code to 200, indicating that the request was successful, and the json() method converts the data variable into a JSON string and sends it as the response body.

Now if you go to [localhost:3000/users](http://localhost:3000/users)\ in your browser or postman you can see the data as result and in postman, you can also see the status code.

That's it you have successfully created your first express app.

Github Repo

Introducing DEVBlogs - Linode + DEV Hackathon

Ankit Kumar — Sat, 18 Feb 2023 04:25:10 +0000

What I built

I built a clone of dev.to that incorporates the majority of its features. The site I built functions similarly to dev.to, allowing users to create profiles, publish articles, interact with other users through comments and reactions.

Category Submission:

Wacky Wildcard

App Link

https://django-devblogs.vercel.app/

Screenshots

Homepage

Page to Write an Article

User Profile

Description

This is a dev.to clone, that incorporates the majority of its features. The site I built functions similarly to dev.to, allowing users to create profiles, publish articles, interact with other users through comments and reactions and many more. The Backend is built with Django and DjangoRestFrameword and for the frontend I have used ReactJs.

Link to Source Code

Source Code:- Github

Permissive License

GPL-3.0 license

Background

Recently, I learned DjangoRestFramework and ReactJs, and I wanted to explore both technologies and come up with ideas for a new project. Ultimately, I decided to create a dev.to clone, as it would allow me to apply my newly acquired knowledge in a practical way while also replicating the functionality of a popular platform for software developers.

How I built it

I used Django and DjangoRestFramework to build the API, and Deployed it on Linode Server, Thanks to $100 credit. I learned how to setup a Linux server this article was very helpful. I am using Apache + mod_wsgi for my application, so I also learned how to configure Apache, I also learned how to setup custom domain name for my server and many more. I also; learned how to use lets necrypt and certbot for ssl certification and how it can be auto generated after 90 days.

Some of the Challenges I faced

I am very new to reactjs, so managing context was very challenging to me, there are still some components in the project where context is not managed properly.
The deployment of the backend API proved to be the second most challenging aspect of the project, but the Linode documentation and YouTube Vides helped me alot.
One of the other challenges I encountered during the project was configuring Apache and mod_wsgi. For example, when I deployed the project, I faced an issue where users were unable to authenticate with their token. It took me several hours of troubleshooting to resolve the issue.

Additional Resources/Info

Tech Stack

Django
DjangoRestFramework
ReactJs
Linode(for backend Deployment)
Vercel(for frontend Deployment)

Conclusion

In conclusion, the development of a dev.to clone has been a rewarding and challenging project that has allowed me to showcase my skills as a developer. Through this project, I have gained valuable experience and knowledge that I can apply to future endeavors, and I look forward to continuing to innovate and explore new possibilities in the field of software development.

Operators In JavaScript

Ankit Kumar — Fri, 10 Feb 2023 02:54:27 +0000

The operator is a symbol that performs a specific operation on one or more operands (values or variables) and produces a result. Operators are an essential part of any programming language and are used to manipulate data and variables. These are the different types of operators we are going to talk about in this article.

Assignment Operator
Arithmetic Operator
Comparison Operator
Logical Operator
Ternary Operator

An operand is a value or variable on which an operator performs an operation.

Assignment Operator

The assignment operator = is used to assign value to a variable. The value of the right operand is assigned to the left operand.

let age = 36 // here 36 will be assigned to variable age.
let fruits = ['Banana',"grapes","guava"]

Arithmetic Operator

We can perform standard arithmetic operations on numbers using the arithmetic operators in JavaScript. Following are some of the many arithmetic operators in JavaScript.

Addition +
Subtraction -
Multiplication *
Division /
Modulus % (also known as remainder)
Increment ++
Decrement --

Addition

The addition operator is used when we want to find the sum of two or more numbers.

console.log(5 + 5); // 10

We can also use the Addition operator to join two or more strings together, This is known as string concatenation.

let firstName = "John ";
let lastName = "Kumar";
console.log(firstName + lastName); // John Kumar

Subtraction

The subtraction operator is used to find the difference between numbers.

console.log(55 - 2); //53
console.log(55.235 - 23.87); //31.365
console.log(10 - 2 + 5); // 13 This is definitely wrong answer according to bodmas rule.

In the above example, line 3 is giving us the wrong answer because of the order of precedence. Both addition and subtraction have the same order of precedence so they are evaluated Right to the left that's why subtraction is being evaluated first. Here is how we can correct that.

console.log(10 - (2 + 5)); // 3

Now the expression inside the parenthesis will be evaluated first because of the order of precedence.

Division (/)

The division operator is used to find the quotient.

console.log(55 / 5);  // 11

Modulus(%)

The modulus operator is used to find the remainder.

console.log(56 % 5); // 1

Increment (++)

The JavaScript increment operator (++) is used to increment (add 1 to) a variable's value. It can be used in both postfix and prefix notation. In postfix notation (i++), the current value of the variable is returned, and then the value is incremented. In prefix notation (++i), the value is incremented first, and then the new value is returned. It's important to note that the increment operator (++) only works on numbers and will result in a NaN if used on a non-numeric value.

let x = 5;
console.log(x++); // Output: 5
console.log(x); // Output: 6

let y = 5;
console.log(++y); // Output: 6
console.log(y); // Output: 6

Decrement (--)

The JavaScript decrement operator (--) is used to decrement (subtract 1 from) a variable's value. It can be used in both postfix and prefix notation. In postfix notation (i--), the current value of the variable is returned, and then the value is decremented. In prefix notation (--i), the value is decremented first, and then the new value is returned.

let x = 5;
console.log(x--); // Output: 5
console.log(x); // Output: 4

let y = 5;
console.log(--y); // Output: 4
console.log(y); // Output: 4

Comparison Operator

A comparison Operator is used to compare two or more operands. These are the different types of comparison operators.

Equal (==)

The equal operator returns ture if both the operands are the same, it does not check the type of the operands.

const var1 = 10;
const var2 = 20;
const var3 = "10";
const var4 = 10;
console.log(var1 == var2); // false
console.log(var1 == var3); // true both variable have same value but they are of different type
console.log(var1 == var4); //true

Strict equal (===)

This operator is the same as the equal operator, but it also checks the type of operands.

const var1 = 10;
const var2 = 20;
const var3 = "10";
const var4 = 10;
console.log(var1 === var2); // false --different value
console.log(var1 === var3); // false --because both value is of different type
console.log(var1 === var4); //true --same value same type

Not Equal (!=)

This operator returns true if the operands are not equal and return false if they are equal.

const var1 = 10;
const var2 = 20;
const var3 = "10";
const var4 = 10;
console.log(var1 != var2); // true -- different value
console.log(var1 != var3); // false -- same value
console.log(var1 != var4); //false -- same value

Strict Not Equal (!==)

This operator returns true if the operands are not equal and of the same type, else it returns false.

const var1 = 10;
const var2 = 20;
const var3 = "10";
const var4 = 10;
console.log(var1 !== var2); // true -- different values
console.log(var1 !== var3); // true -- same value, different type
console.log(var1 !== var4); // false -- same value, same type

Few More (>,>=,<,<=)

const var1 = 10;
const var2 = 20;
const var3 = 10;

// Greater than
console.log(var1 > var2); // false
console.log(var2 > var1); //true

// Less than
console.log(var1 < var2); // true
console.log(var2 < var1); // false

// Greater than or equal 
console.log(var1 >= var2); // false
console.log(var2 >= var1); // true
console.log(var1 >= var3); // true

// Less than or equal
console.log(var1 <= var2); // true
console.log(var2 <= var1); // false
console.log(var1 <= var3); // true

Operator	Description	Example
Greater Than (>)	Return `true` if the left operand is greater than the right operand	see the above code example.
Less Than(<)	Returns `true` if the left operand is less than the right operand	see the above code example.
Greater Than or Equal (>=)	Evaluates to `true` if the value on the left is greater than or equal to the value on the right.	see the above code example.
Less Than or Equal(<=)	Evaluates to `true` if the value on the left is less than or equal to the value on the right.	see the above code example.

Logical Operator

A logical operator evaluates expressions and returns a boolean value indicating whether a specific condition is true or false. When used with boolean operands, these operators will return a boolean result; when used with non-boolean values, they will produce a non-boolean result. There are three different types of logical operators in JavaScript.

OR (||)
AND (&&)
NOT(!)

OR

The OR the operator is represented by a double vertical line || . OR The operator returns true if any of its expressions evaluates to true otherwise, it returns false. If the OR operator is used with non-boolean values then it returns non-boolean values.

Syntax:

expression1 || expression2

if expression 1 is evaluated to true then it returns expession 1 otherwise exprssion2

logical OR expression is evaluated left to right, so if the first expression is evaluated to true, then it doesnot check the next expression.

if all the expression evaluates to false then it reaturn false.

const var1 = 10;
const var2 = 20;
const var3 = 10;

console.log(var1 > var2 || var2 > var1);// true
console.log(true || true); // true
console.log(false || true); // true
console.log(true || false); // true
console.log(false || false); // false

AND (&&)

The AND operator is represented by two ampersands && sign. The AND operator return true if all of its conditions evaluates to true if any of its conditions evaluates to false it returns false.

Syntax:

expression 1 && expression 2

returns true if both the conditions if true otherwise it returns false

AND operator is evaluated from left to right, so if any expression evaluates to false it doesn't evaluates any expression after that.

it returns last last operand if all the expression evalutes to 'true`

`javascript
const var1 = 10;
const var2 = 20;
const var3 = 10;

console.log(var1 > var2 && var2 > var1); // false && true
console.log(true && true); // true
console.log(false && true); // false
console.log(true && false); // false
console.log(false && false); // false
`

NOT (!)

The NOT the operator is represented by an explanation ! sign. The ! operator can be applied to boolean and non-boolean values. When used with a boolean value, it returns the opposite of that value, i.e. if the value is false it returns true, and if the value is true it returns false.

javascript console.log(!true); //false console.log(!false); //true console.log(!0); //true console.log(!"Hello"); // false

Ternary Operator

Ternary Operator takes three operands and returns values based on the condition.

Syntax:

condition ? expression 1 : expression2

if the condition is true then it returns expression1 and if the expression if false it returns expression2

`javascript
const var1 = 10;
const var2 = 20;

console.log(var2 > var1 ? "true" : "false"); // true
console.log(var1 > var2 ? "true" : "false"); // false
`

Conclusion

In this article I have only talked about the operators which are used most, there are a few more operators, and if you want to explore more then you can read about them here.

Click Here

Values & Variables In JavaScript

Ankit Kumar — Wed, 08 Feb 2023 12:38:16 +0000

While working with computers we work with data only, Every Programming language work with some type of values, In this article, we are going to talk about values we can work with in JavaScript. These values are also known as datatypes.Let's explore them one by one.

Number

In JavaScript, every numeric value is a floating-point number, there is no separate integer type. Values like 23, and 23.534 are all considered as one value i.e number. We can perform arithmetic operations using numbers in JavaScript.

console.log(5 + 3);
console.log(234.23 - 230);
console.log(55 / 5);
console.log(55 % 5);

String

Everything Inside single quotes, double quotes, or backticks is considered a string in JavaScript. The string is used to represent text or a sequence of characters. Make sure you are using the same quotes at the beginning and end of the string.

// Valid String in javaSCript
"Hello World"
'Hello World'
`Hello World` // backticks are below your esc key

// Invalid Strings in JavaScript
"Hello World'
"Hello World'
`Hello World"

Boolean

Boolean has only two values true and false. Either it's going to be true or false.

console.log(89 > 23);
console.log(103 < 23);

Empty Values

There are two special values, null and undefined, that are used to represent the absence of a meaningful value. Although they are values, they do not carry any information or content. null represents the absence of any value, whereas "Undefined" refers to a value that has not been assigned or defined by the compiler. It represents the absence of a defined value.

let name; // the value has not been defined
console.log(name); // -> undefined
let name2 = null;
console.log(name); // -> null

Arrays

Arrays in JavaScript are written using square brackets. The array starts with an opening square bracket[ and array ends with a closing square bracket ] . In an array, we store multiple values separating them with , . In an array, we can store values of any type we talked till now. Let's see some examples of an array.

Each element inside an array is given a unique position known as an index. The index starts from 0 and goes up to a length of the array -1. In the given example "hello" is at index 0 and true is at index 4. We use this index to get elements at specific positions, we will learn more about this in coming articles.

["hello", "there", 3, 3.4, true]

Objects

Objects are written using {} curly braces. JavaScript object mimics the behavior of a physical object, Just like a physical object has some properties JavScript objects also have properties, these properties are written in key-value pair separated by a comma. Here is an example of a person object.

const person = {
  name: "Rahul",
  age: 34,
  address: "Delhi",
  designation: "Full Stack Developer",
};

Now we have learned about different types of values we can use in JavaScript, now let's learn how we can store these values in variables.

Variables.

A Variable is a named label for a memory location where some values are stored. In other words, a Variable is like a container where we can store some values. There are three different ways to declare a variable in JavaScript. var let and const . This would be too early to talk about differences between them so just keep this in mind.

var - don't use this
let - value can be changed later
const - once defined value can't be changed

We use the assignment operator = to assign value to a variable, a variable is only created once you assign value to it. Let's create a value to store a message.

let message = "Hello World!";

console.log(message);

in the above example, we use let to declare the variable, so we can change the message, let's do that.

in the above example in line 4 I have used the same message variable to assign a new value. console.log function from line 2 is displaying the old message and console.log function from line 5 is displaying the new message. Now let's see an example of const.

In the above example, I have replaced let with const , Notice in the console console.log function from line 2 is displaying the message, but when I tried to assign a new message in line 4 it's giving me an error in the console.

Rules for naming a variable.

The first character of a variable must be a letter
JavaScript is a case-sensitive language so Uppercase letters and lowercase letters are different. E.g variable age and Age will be treated as two different variables.
JavaScript reserved keywords can not be used as a variable name.

In the next article, we are going to talk about Operators in JavaScript.

Getting Started With JavaScript.

Ankit Kumar — Tue, 07 Feb 2023 10:46:36 +0000

JavaScript is one of the most popular programming languages. JavaScript allows us to add dynamic content to our web pages, and it allows us to make our web pages more interactive eg. You must have used dropdown menus, alerts, and other dynamic content on the web pages, it might be possible that they all are achieved using JavaScript. It has been the most popular programming language for more than 5 to 6 years in a row.

Why JavaScript?

As I have already mentioned that JavaScript is one of the most popular programming languages. In today's internet, almost more than 90% of website uses JavaScript, so there are always requirements for JavaScript Developers. In the early days, JavaScript was used on the client-side only but with help of runtime environments like node we can now run JavaScript also on the server-side.

client-side:code is downloaded as plain text and is executed on the user's computer only.

server-side: code is executed on the server, and only results are downloaded and displayed on the screen.

Now JavaScript has evolved so much that with help of JavaScript only you can develop webpages, Single Page Applications, mobile apps, desktop apps, backend applications, Game development and even now you can do machine learning with JavaScript, you can say that possibilities are endless.

A pinch of history.

During the browser war between Microsoft (Internet Explorer) and Netscape (Netscape Navigator). In 1995 Netscape's engineer named Brendan Eich developed a new lightweight scripting language called Mocha , and later it was renamed to JavaScript. Soon after that in 1996 Microsoft also developed its own version of JavaScript and this brought compatibility issues to the website. To develop JavaScript, Netscape and Brendan Eich took it to the ECMA international standards organization in 1996. In 1997 the language specification called ECMAScript as a ECMA-262 standard was published. This specification could be used by other browser vendors to prepare their implementations.

Getting Started

Now, let's get started and write our first program in JavaScript, but where, we can run JavaScript directly in the browser console but we are not going to do that. For executing the JavaScript code we are going to use nodejs which is a runtime environment based on the chrome v8 engine, we will learn about the runtime environment and engine later and for writing the codes we are going to use vs code. Download these tools from their official website and install them in your system.

Hello World

Create a directory and open that directory in vs code, and create a new file in that directory hello.js notice the .js extension all JavaScript code files have .js extension. Write the following line in that file.

console.log("Hello World!"); 
// console.log is used to dislplay message in the console

Open vs code inbuilt terminal by pressing cltl + ` together, and writenode hello.js and press enter. This will display Hello World! message in your terminal. That's it we have written our first program in JavaScript. In the next article, we are going to learn about the values we can use in JavaScript.

JavaScript Array

Ankit Kumar — Mon, 19 Dec 2022 17:41:52 +0000

The array is the most used data structure of any programming language, so then what is Array? The array is a collection of items or elements. It is like a container where you can store multiple values. in JavaScript Array is denoted by square brackets [] , opening square brackets indicate the start of the array and closing square brackets indicate the end of the array. Inside the square brackets, we can store multiple values separating them with comma , . This is how an array in JavaScript looks like let fruits = ["apple", "grapes", "banana", "orange", "guava"]; Here we have a list of fruits and we are storing them in a fruits variable.

In an Array, all the items of an array are known as elements, and elements in an Array are given a unique position known as an index we will talk more about the index later, so in the above example, the names of fruit are elements of the fruit array. In JavaScript Array, we can store values of any type, values can be anything e.g string, boolean, number, etc we can even store an array inside an array. Here are a few more examples of JavaScript Array.

let arr1 = []
let fruits = ['apple', 'grapes', 'banana', 'orange', 'guava'] // array of strings
let even_numbers = [2,4,6,8,10] // array of numbers
let vowels = ['a','e','i','o','u'] // array of characters
let arr2 = ['hello', "2", 76, 8.23] // array of mixed values
let arr3 = ["How are You", ["hi", 4.5, 9], 98] // array of mixed values

How to create an Array in JavaScript

We can create an array by just assigning a pair of square brackets to a variable let's look at this example let fruits = []; This fruit array has no element inside it, so it is known as an empty array. There is also another way to create an array in JavaScript but it's not used much.let fruits = new Array(); this is also an empty array. take a look at the below code and you will know how we add elements to this Array.

let fruits = []; // empty array
let fruits = ['apple', 'grapes', 'banana', 'orange', 'guava']

let fruits = new Array(); .// not used much
let fruits = new Array("apple", "grapes", "banana", "orange", "guava");

More on Index

An Array is an ordered collection of elements and an element in an array is given a unique position known as an Index, we use this index to access individual elements from the array. The index starts from 0 and goes up the length of the array - 1. The length of the array is the number of elements in the array. let's look at our fruits array let fruits = ['apple', 'grapes', 'banana', 'orange', 'guava'] in this fruits array, there are five elements so the length of the array is 5. So the index of the array of fruits starts from 0 and goes up to 4, apple is at an index of 0, and guava is at the index of 4. Take a look at the below picture you will get a more clear picture of how the index works.

Access Element of an Array Using Index.

We have already learned that we can access an individual element using the index, to access individual elements from an array we use this syntax.

arrayName[index]

Take a look at the example below it will make more sense.

let fruits = ["apple", "grapes", "banana", "orange", "guava"];

// get first element from the fruits array
console.log(fruits[0]); // first element is always at index 0

// get second element from the fruits array
console.log(fruits[1]);

// get third element from the array
console.log(fruits[2]);

// get last element from the fruits array
console.log(fruits[4]); // not recommended

Getting the Last element of an Array

Getting the last element from an array is the same as getting the element at any other position in an array, take a look at the example below.

let fruits = ["apple", "grapes", "banana", "orange", "guava"];

// get last element from the fruits array
console.log(fruits[4]); // not recommended

In the above example, you can see that guava at index 4 is the last element from the fruits array and we are able to access it just like any other element on any position, yes but think of a situation when you don't have any idea about the length of the array, you don't know at what index the last element of the array is going to be, this method works only when the array is short. Let's learn about the other method.

Remember I mentioned that the index starts from 0 and goes up to the length of the array -1, so if the length of the array is 10 then the index will start from 0 and will go up to 9, if we can somehow find the length of the array then it will be easy to find the last index of the array.

length of the array:-

lenght of the array is number of elemement in the array. I f there are 5 elements in the array then lenght of the array is 5.

JavaScript comes with inbuilt property to find length of the array, this is the syntax we use to find the lenght of the array.

arrayName.length

this return us the lenght of the array.
let fruits = ["apple", "grapes", "banana", "orange", "guava"];

console.log(fruits.length); // output -> 5

Now we know how to find the length of the array so to access the last element of the array we can use fruits.length - 1 it will give us the last index of the array.

let fruits = ["apple", "grapes", "banana", "orange", "guava"];

// just for example gives us last index of any array
console.log(fruits.length - 1); // output -> 4

// get the last element from the fruits array
console.log(fruits[fruits.length - 1]); // output -> 4

Modifying Element of An Array Using Index.

We can access elements of an array using the index, we can also use the index to modify an array, take a look at the below syntax.

arrayName[index] = "value"

Here are a few more examples.

let fruits = ["apple", "grapes", "banana", "orange", "guava"];

// Remove banana from index 2 and add Papaya at index 2
fruits[2] = "Papaya"; // this will replace banana with papaya
console.log(fruits); // o/p->[ 'apple', 'grapes', 'Papaya', 'orange', 'guava' ]

let newList = [];

// Add element to the newList

newList[0] = "Pear";
newList[1] = "Strawberry";
newList[2] = "Watermelon";
console.log(newList); // o/p -> [ 'Pear', 'Strawberry', 'Watermelon' ]

Array Methods

JavaScript comes with lots of array methods, we can use this method to make perform different tasks and make our work easy. In this section of the article, we will talk about some of the most used array methods.

push()

push() method is to add one or more elements at the end of the array, it also returns us the new length of the array after adding new elements.

arrayName.push("element") when adding single element

arrayName.push("element","element2") adding multiple element

let fruits = ["apple", "grapes", "banana", "orange", "guava"];
let newArrayLength = fruits.push("Pear"); // this will return new array length 
console.log(fruits); // o/p -> [ 'apple', 'grapes', 'banana', 'orange', 'guava', 'Pear' ]

pop()

pop() method removes the last element from the array and also returns the removed element. We use this method when we want to remove the last element from the array and use the returned element later.

Syntax:

arrayName.pop()

let fruits = ["apple", "grapes", "banana", "orange", "guava"];
let poppedElement = fruits.pop(); // last element removed from the fruits array will be stored in poppedElement Variable
console.log(poppedElement); // o/p -> guava
console.log(fruits); // o/p [ 'apple', 'grapes', 'banana', 'orange' ]

shift()

shift() method removes the first element i.e element at index 0, from the array and returns the removed element.

Syntax:

arrayName.shit()

let fruits = ["apple", "grapes", "banana", "orange", "guava"];
// fruits.shift(); // use this when you don't want to store the removed element
let removedElement = fruits.shift(); // removes the first element from the fruits array and store the removed element
// fruits.shift();
console.log(removedElement); // o/p -> apple i.e first element of fruits array
console.log(fruits); // o/p -> [ 'grapes', 'banana', 'orange', 'guava' ]

unshift()

unshift() method is used to add one or more elements at the start of the array, it also returns the new length of the array after adding the element.

Syntax:

arrayName.unshift("element") // single element

arrayName.unshift("element1","element2") // multilple element

let fruits = ["apple", "grapes", "banana", "orange", "guava"];

// Add "Pear" at the start of the array
fruits.unshift("Pear"); // adding one element
console.log(fruits); // o/p -> [ 'Pear', 'apple', 'grapes', 'banana', 'orange', 'guava' ]

// Add "Strawberry" and "Papaya" at the beginning  of the array
fruits.unshift("Strawberry", "Papaya"); // adding multiple element at the beginning of the array
console.log(fruits); // o/p [ 'Strawberry',  'Papaya','Pear', 'apple', 'grapes', 'banana', 'orange', 'guava' ]

// Add "PineApple at the start of the array  and store the new length of the array in  newLength variable"
let newLength = fruits.unshift("PineApple");
console.log(newLength); // o/p ->    9

sort()

sort() method is used to sort the elements of the array. It sorts the strings in alphabetical order and numbers in ascending order. sort() the method doesn't use any extra space or use another array for sorting, it overwrites the original array and returns it.

Syntax:

arrayName.sort()

let fruits = ["apple", "grapes", "banana", "orange", "guava"];
fruits.sort();
console.log(fruits); // o/p -> [ 'apple', 'banana', 'grapes', 'guava', 'orange' ]

let marks = [23, 66, 22, 96.4, 84.3];
// displaying the returned array
console.log(marks.sort()); // o/p -> [ 22, 23, 66, 84.3, 96.4 ]

reverse()

reverse() method is used when we want to reverse the original order of the array. reverse() method also doesn't use any extra space or use another array for sorting, it overwrites the original array and returns it.

Syntax:

arrayName.reverse()

let fruits = ["apple", "grapes", "banana", "orange", "guava"];
fruits.reverse();
console.log(fruits); // o/p -> [ 'guava', 'orange', 'banana', 'grapes', 'apple' ]

let marks = [23, 66, 22, 96.4, 84.3];

// displaying the returned value.
console.log(marks.reverse()); // o/p -> [ 84.3, 96.4, 22, 66, 23 ]

splice()

splice() method is used to remove, replace or add elements to the array. It returns an array of removed items.

Syntax:

arrayName.splice(startIndex,deleteCount, item1, item2, n_item)

startIndex-> The index from where you want to modify the array

deleteCount(optional) -> It is the number of element you want to delete.

item1,item2,n_item(optional) ->Elements you want to add to the start index. if this is not specfied,splice() wll only remove elements from the array.

let fruits = ["apple", "grapes", "banana", "orange", "guava"];

// Add PineApple at index 1
fruits.splice(1, 0, "PineApple"); // no items is being removed so it will remove empty array.
console.log(removedFruits); // o/p ->[]
console.log(fruits); // o/p -> [ 'apple', 'PineApple', 'grapes', 'banana', 'orange', 'guava' ]

// now our fruits array contains following elements [ 'apple', 'PineApple', 'grapes', 'banana', 'orange', 'guava' ]

// Add 2 Elements "Watermelon" and "Strawberry"  starting at index 2
fruits.splice(2, 0, "Watermelon", "Strawberry");
console.log(fruits);

// Remove all the newly added elements from the array and store the removed element in a variable.
let removedFruits = fruits.splice(1, 3);
console.log(removedFruits); // 0/p -> [ 'PineApple', 'Watermelon', 'Strawberry' ]
console.log(fruits);  // o/p ->[ 'apple', 'grapes', 'banana', 'orange', 'guava' ]

slice()

slice() method is used when we want a copy of an array's portion. It returns a copy of a small portion of the array from the original array without modifying the original array.

Syntax:-

arrayName.slice(startIndex,stopIndex)

startIndex(optional) -> Index from where you want to start the slicing.

stopIndex(optional) -> Index at where you want to stop slicing. Rembember stopIndex is always exclusive element at this index is not included in the returned array.

let fruits = ["apple", "grapes", "banana", "orange", "guava"];

// get a new array of "grapes", "banana" and "orange"
let newSlicedList = fruits.slice(1, 4); // stop index is 4 instead of 3 because stop index is exclusive.
console.log(newSlicedList); // o/p ->[ 'grapes', 'banana', 'orange' ]
console.log(fruits); // o/p -> [ 'apple', 'grapes', 'banana', 'orange', 'guava' ]

console.log(fruits.slice()); // if no parameter is passed it slice the array from start to end

concat()

concat() method is used to join two or more arrays or values. It does not modify the original array instead it returns a new array with the values from both the array.

Syntax:

arrayName.concat(array/value,array/value)

array/value: can be a single value or an array.

let fruits = ["apple", "grapes", "banana", "orange", "guava"];
let anotherFruitsArray = ["PineApple", "Watermelon", "Strawberry"];

// create a new array which has all the elements from both the array.
let newJoinedArray = fruits.concat(anotherFruitsArray);
console.log(newJoinedArray); // ["apple","grapes", "banana", "orange","guava", "PineApple","Watermelon","Strawberry",];

join()

join() method returns a new string by concatenating all of the elements of an array, separated by a comma or by the specified separator.

Syntax:

arrayName.join(seprator)

seprator(optional) :- optional seprator string

let fruits = ["apple", "grapes", "banana", "orange", "guava"];

console.log(fruits.join()); // apple,grapes,banana,orange,guava
console.log(fruits.join("-")); // apple-grapes-banana-orange-guava

includes()

includes() method is used to check whether an element is in the array or not. It returns true if the element is in the array else it returns false.

Syntax:

arrayName.includes(element)

element :- element you want to check for

let fruits = ["apple", "grapes", "banana", "orange", "guava"];

// check if grapes is in the fruits array
console.log(fruits.includes("grapes")); // o/p-> true

// check if "PineApple" in in the fruits array
console.log(fruits.includes("PineApple")); // o/p -> false

fill()

fill() method fills the array with the specified value and returns the new modified array. It modifies the original array.

Syntax:-

arrayName.fill(value,startIndex,stopIndex)

value -> value you want to fill with

startIndex(optional) -> strarting index from where you want to start filling the value. The default value for this is 0.

stopIndex(optional) -> index where you want to stop the filling.rembember stopIndex is always exclusive. the default value for this is the length of the array.

let fruits = ["apple", "grapes", "banana", "orange", "guava"];

// fill "PineApple" from index 1 to index 3
let returnedArray = fruits.fill("PineApple", 1, 4);
console.log(returnedArray); // [ 'apple', 'PineApple', 'PineApple', 'PineApple', 'guava' ]
console.log(fruits); //[ 'apple', 'PineApple', 'PineApple', 'PineApple', 'guava' ]

// fill fruits array with "Watermelon"
let returnedArray2 = fruits.fill("Watermelon");
console.log(returnedArray); // ["Watermelon", "Watermelon", "Watermelon", "Watermelon", "Watermelon"];
console.log(fruits); // ["Watermelon", "Watermelon", "Watermelon", "Watermelon", "Watermelon"];

indexOf()

indexOf method returns the index of the given element, if there are duplicate elements in the array then it returns the index of elements that occur first and if the element is not present in the array then it returns -1.

Syntax:-

arrayName.indexOf(element)

let fruits = ["apple", "grapes", "banana", "orange", "guava", "apple"];
// find the index of "grapes"
console.log(fruits.indexOf("grapes")); // 1

// find the index of "apple"

// apple can be found at index 0 and at index 5, but this method only return index of element which occur first.
console.log(fruits.indexOf("apple")); // 0

// find the index of "PineApple"
console.log(fruits.indexOf("PineApple")); // -1 because "PineApple is not present in the array."

isArray()

isArray() method checks if the object is an array. We know that everything in JavaScript is an object. If the object is an array then it returns true and if not then it returns false.

Syntax:-

Array.isArray(arrayName)

let fruits = ["apple", "grapes", "banana", "orange", "guava", "apple"];

console.log(Array.isArray(fruits)); // true

keys()

The keys() method returns an Array Iterator object that contains the keys for each index in the array.

Syntax:-

arrayName.keys()

let fruits = ["apple", "grapes", "banana", "orange", "guava", "apple"];

let KeyIterator = fruits.keys();

for (let key of iterator) {
  console.log(key);
}

// output
/*
0
1
2
3
4
5
*/

values()

The values() method creates a new iterator object that allows you to access the values of each index in the array. This iterator can be used to iterate through the values of the array in a loop.

Syntax :-

arrayName.values()

let fruits = ["apple", "grapes", "banana", "orange", "guava", "apple"];

let valueIterator = fruits.values();

for (let value of valueIterator) {
  console.log(value);
}

// Output
/*
apple
grapes
banana
orange
guava
apple
*/

Not the End ^😒

That's it, for now, there are many more array methods that are left to cover in this article, I will be updating this article as I learn and explore more. Write your feedback in the comment section.

An overview of Flexbox

Ankit Kumar — Mon, 21 Nov 2022 13:48:07 +0000

What is Flexbox ?

Flexbox is used for designing the one-dimensional layout, at a time you can either design your layout in columns or rows. Everything in flexbox depends on these two terms main axis and cross-axis they are perpendicular to each other. The main axis is determined by the flex-direction property.

Flexbox works with the concept of containers and items, every element which is to be layout needs to be inside a container, this container is known as a flex container and the element is known as a flex-items. Let’s try to understand this with an example.

This is the HTML file we are going to use for this article, in this HTML document we have a div element with the class as container and it has five div child elements.

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Positioning</title>
  </head>
  <style>
    .container {
      width: 90vw;
      height: 80vh;
      border: 2px solid #242b2e;
      padding: 10px;

      /* changes below this*/
    }
    .box {
      background-color: #242b2e;
      height: 100px;
      width: 100px;
            margin: 10px;
      font-size: 40px;
      text-align: center;
      color: #ffffff;
    }
  </style>
  <body>
    <div class="container">
      <div class="box box-1">1</div>
      <div class="box box-2">2</div>
      <div class="box box-3">3</div>
      <div class="box box-4">4</div>
      <div class="box box-5">5</div>
    </div>
  </body>
</html>

As you can see all five boxes are stacked one after another, let’s add display: flex to the container.

.container {
      width: 600px;
      height: 500px;
      border: 2px solid #242b2e;
      padding: 10px;

      /* changes below this*/
      display: flex;
    }
    .box {
      background-color: #242b2e;
      height: 100px;
      width: 100px;
      margin: 10px;
      font-size: 40px;
      text-align: center;
      color: #ffffff;
    }

Adding display: flex to the container element will define it as a flex container and all the flex items will be layout according to their main axis depending on the flex-direction by default the flex: direction is set to row so horizontal is our main axis, so the item will layout in a row.

Now let’s change the flex-direction to a column and see the changes.

.container {
      width: 600px;
      height: 500px;
      border: 2px solid #242b2e;
      padding: 10px;

      /* changes below this*/
      display: flex;
      flex-direction: column;
    }
    .box {
      background-color: #242b2e;
      height: 100px;
      width: 100px;
      margin: 10px;
      font-size: 40px;
      text-align: center;
      color: #ffffff;
    }

As you can see when we change the flex-direction to the column, the column becomes the main axis and the horizontal becomes the cross axis.

Flex direction

The flex-direction property is used to establish the main axis. flex-direction takes 4 values row column row-reverse and column-reverse. On webpages, the default value of `flex-direction is set to row.

flex-direction: column

This property set’s the column as the main axis, so items are arranged from top to bottom.

flex-direction:row-reverse

This property reverses the items from left to right to right to left and moves the element toward the end of the container.

flex-direction: column-reverse

This property reverses the items from top to bottom to bottom to top and moves the item toward the end of the container.

flex-wrap

Flexbox is a one-dimensional layout system, so by default, all the items will try to fit in one line, but we can allow items to wrap and move to the next line, just like word wrap in vs code. We can pass three values to flex-wrap nowrap wrap wrap-reverse By default, flex-wrap is set to no-wrap flex-wrap: nowrap.

`flex-wrap: wrap`

When we change the size of the container items move to the next line.

`flex-wrap:wrap-reverse`

Applying wrap-reverse will wrap items to the next line but from bottom to top.

justify-content

justify-content is used to align the items along the main axis. This is generally used to distribute the space between the items. justify-content takes many values but we are going to discuss the values that are used most.

`justify-content: center`

the justify-content center is used to move the items to the center of the main axis.

`justify-content: flex-start`

This is used to move the items to the start of the main axis. This is also the default value.

`justify-content: flex-end`

This property is used to move the items to the end of the main axis.

`justify-content:space-between`

This property moves the first item to the start of the main axis and the last item to the last of the main axis and leftover space is event distributed between the items.

`justify-content: space-around`

This property is used to evenly distributes the items, with equal space around them.

`justify-content: space-evenly`

This property is used to distribute equal space around the items.

align-items

align-items is used to control the alignment of items along the cross-axis. align-items takes the following values flex-start flex-end center stretch baseline.

`align-items: center`

This property is used to align items to the center along the cross-axis.

`align-items: flex-start`

This property is used to align and move the items to the start of the container along the cross-axis.

`align-items: flex-end`

This property is used to align and move the items to the end of the container along the cross-axis.

`align-items:stretch`

This property is used to stretch and fill the items along the cross-axis.

align-content

align-content is very similar to justify-content property. This is also used to distribute the space between the items but along the cross-axis. align-content takes the following values. flex-start flex-end center stretch space-between and space-around

Now let’s discuss some properties which can be applied only to the items themselves.

order

order property is used to control the order of the items. By default, all the flex items have an order value of 0. The order of items is controlled by the order property.

`css
.container {
width: 50%;
height: 500px;
border: 2px solid #242b2e;
padding: 10px;

  /* changes below this*/
  display: flex;
}
.box {
  background-color: #242b2e;
  height: 100px;
  width: 100px;
  margin: 10px;
  font-size: 40px;
  text-align: center;
  color: #ffffff;
}

.box-1 {
  order: 3;
}
.box-4 {
  order: -1;
}

flex-grow

It specifies the amount by which an item will grow relative to the rest of the flexible items in the same container.

Conclusion

The article only discusses the most commonly used flexbox properties. If you want to learn more about flexbox, CSS Tricks has a great article on it. That's all for this article, let me know what you think in the comments.

CSS Positioning - A quick guide

Ankit Kumar — Mon, 21 Nov 2022 13:44:50 +0000

To make our web pages look good we have to position elements in our web pages in specific ways. To control the position of an element we use the position property in CSS. In this article, we are going to talk about different position properties in CSS.

Position property controls the location of an element in the document, and the final position is determined by the top left right left and z-index properties. position property takes five different values static relative absolute fixed sticky, we are going talk about them one by one.

position: static

This is the default position of every element in the document. If you set the top left right left and z-index properties, on an element with a position set as static there would be no changes in the position of the element. Let’s have a look at the example below.

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Positioning</title>
  </head>
  <style>
    .box {
      background-color: #242b2e;
      height: 100px;
      width: 100px;
      font-size: 20px;
      text-align: center;
      color: #ffffff;
      display: inline-block;
    }
    .box-1 {
      top: 40px;
    }
  </style>
  <body>
    <div class="box box-1">1</div>
    <div class="box box-2">2</div>
    <div class="box box-3">3</div>
    <div class="box box-4">4</div>
    <div class="box box-5">5</div>
  </body>
</html>

In the above code as you can I have 5 div elements, and I didn’t apply position property to the box class so by default all five boxes are positioned as static, so applying top:40px on box-1 would not show any changes.

position: relative

position: relative is similar to position: static, The element is positioned the same as the flow of the document, but we can change the position of the element by using the top left right left, and z-index properties. Let’s have a look at an example.

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Positioning</title>
  </head>
  <style>
    .box {
      background-color: #242b2e;
      height: 100px;
      width: 100px;
      font-size: 20px;
      text-align: center;
      color: #ffffff;
      display: inline-block;
    }
    .box-1,
    .box-3,
    .box-5 {
      position: relative;
      top: 40px;
    }
  </style>
  <body>
    <div class="box box-1">1</div>
    <div class="box box-2">2</div>
    <div class="box box-3">3</div>
    <div class="box box-4">4</div>
    <div class="box box-5">5</div>
  </body>
</html>

in the above example, I have applied position: relative and top:40px to the div element with class box-1, box-3, and box-5, and these three elements moved 40px downward from their original position.

position: absolute

Element with position: absolute is completely removed from the original document flow. With the help of top left right left, and z-index properties, we can position this element anywhere relative to its closest parent. When an absolute positioned element has no positioned parent element, it uses the document body, Let’s try to get this clear with an example.

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Positioning</title>
  </head>
  <style>
    .box {
      background-color: #242b2e;
      height: 100px;
      width: 100px;
      font-size: 20px;
      text-align: center;
      color: #ffffff;
      display: inline-block;
    }

    .box-3 {
      position: absolute;
      bottom: 10px;
      right: 10px;
    }
  </style>
  <body>
    <div class="box box-1">1</div>
    <div class="box box-2">2</div>
    <div class="box box-3">3</div>
    <div class="box box-4">4</div>
    <div class="box box-5">5</div>
  </body>
</html>

In the above example, I have applied an absolute position to the 3rd box
.box-3{position: absolute;bottom:10px;right:10px} and as you can see 3rd box has been removed from the original document flow and has been positioned according to the bottom:10px;right:10px properties. in our example, there is no parent element to the box elements so the box is positioned relative to the document body.

position: fixed

Element with position: fixed is completely removed from the document flow just like the position: absolute. When we apply position: fixed to the element is positioned relative to the document body not to the parent element. Element with fixed position is also not affected by the scrolling effect.

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Positioning</title>
  </head>
  <style>
    .box {
      background-color: #242b2e;
      height: 100px;
      width: 100px;
      font-size: 20px;
      text-align: center;
      color: #ffffff;
      display: inline-block;
    }

    .box-3 {
      position: fixed;
      top: 200px;

    }
  </style>
  <body>
    <div class="box box-1">1</div>
    <div class="box box-2">2</div>
    <div class="box box-3">3</div>
    <div class="box box-4">4</div>
    <div class="box box-5">5</div>
    <p>
     very very long text content, so that we can have a scroll.
    </p>

  </body>
</html>

in the above example, I have given .box-3{position:sticky;top:0} to box3 and it’s position does not change on scroll.

position: sticky

Element with position: sticky is like position: relative it remains in the original document flow until the user scroll when the user scrolls the element with position sticky get fixed based on any of the top left right left, and z-index properties.

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Positioning</title>
  </head>
  <style>
    .box {
      background-color: #242b2e;
      height: 100px;
      width: 100px;
      font-size: 20px;
      text-align: center;
      color: #ffffff;
      display: inline-block;
    }

    .box-3 {
      position: sticky;
      top: 0;
    }
  </style>
  <body>
    <div class="box box-1">1</div>
    <div class="box box-2">2</div>
    <div class="box box-3">3</div>
    <div class="box box-4">4</div>
    <div class="box box-5">5</div>
        <p>
     very very long text content, so that we can have a scroll.
    </p>
  </body>
</html>

In the above example, I have applied .box-3{position: sticky;top:0}, As you can see in the above example box3 sticks to the top when we scroll, you must have seen these types of the navbar on any website.

Conclusion

That’s it for this article, write your feedback in the comment section.

Introduction to CSS Selectors

Ankit Kumar — Mon, 21 Nov 2022 13:41:03 +0000

We have already learned that HTML determines the structure of the website, but to make our website look good and appealing we use CSS. In this article, I am going to give you a basic introduction to CSS.

What is CSS?

CSS stands for Cascading Style Sheets. It is used to style HTML elements and make them more presentable. The fancy good looking pages we see on the internet are styled with CSS. Nowadays CSS is also used to design the layout of the webpage.

How to Write CSS?

The basic idea of writing CSS is that we select an element or group of elements with the help of a selector (we will learn more about selectors in the later part of this article) and write a bunch of CSS properties with values to style that element. Here is the syntax to write CSS.

But we first need to know where to write CSS, we can write CSS at three different places, let’s first learn about them.

Inline CSS

We can write CSS as an attribute within the HTML element only. This type of CSS is known as Inline CSS. Inline CSS is used when we want to style any specific element only.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Learning CSS</title>
</head>
<body>
    <p>Paragraph 1</p>
    <p style="color: #2827CC;">paragraph 2</p> 
    <p>Paragraph 3</p>
</body>
</html>

As you can see in the above example in paragraph 2 we have used style attribute to change the color of the paragraph.

Internal CSS

We can write CSS using element inside our
<head></head>. CSS written using the <style></style> element is page-specific, for each new page we will have to write a new stylesheet.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Learning CSS</title>
    <style>
        h1{
            color:#2827CC;
        }
    </style>
</head>
<body>
    <h1>Heading 1</h1>
    <p>Paragraph 1</p>

</body>
</html>

As you can see in the above example, I have used
<style></style> element inside the <head></head> element to change the color of our heading.

External CSS

This is the most used and recommended way to write our stylesheet, in this method we write CSS in a separate file with a .css extension, and then we link this stylesheet in our HTML document using <link></link> element. With this method, we can even link stylesheets written by other people on the internet.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <!-- new line to link css -->
    <link rel="stylesheet" href="./css/style.css">
    <!-- new line to link css end-->
    <title>Learning CSS</title>

</head>
<body>
    <h1>Heading 1</h1>
    <p>Paragraph 1</p>
</body>
</html>



/* style.css */

h1{
    color:#03203C;
    background-color: #23C4ED;
    background-color: #23C4ED;
    padding: 10px 20px;
}

p{
    color:#ffffff;
    background-color: #242B2E;
    padding: 10px 20px;
}

I have created a new CSS directory and a new file style.css and written all my styles in this file using <link></link> element I have linked this CSS file to my HTML document. I have used two attributes in <link></link> element rel="stylesheet" and href="./css/style.css" rel attribute is used to define the relationship between the HTML document and the linked document here rel="stylesheet" means import this file as a stylesheet and the href attribute is used to define the location of the stylesheet.

Selectors

CSS selectors are used to selecting the HTML elements we want to style. In this section of the article, we are going to learn about different selectors.

Universal Selector `*`

Universal selector is denoted by * . A universal selector is used when we want to apply styles to each and every element of our HTML document. Syntax: *{property: value}.

Here in the below example, I have used the universal selector to change the color of the text in an HTML document, and the color of each and every text got changed.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Learning CSS</title>
    <style>
        /*Universal Selector*/
        *{
            color:#383CC1;
        }
    </style>

</head>
<body>
    <h1>Heading Level 1</h1>
    <h2>Heading Level 2</h2>
    <h3>Heading Level 3</h3>
    <h4>Heading Level 4</h4>
    <h5>Heading Level 5</h5>
    <h6>Heading Level 6</h6>

    <p>1. Lorem ipsum dolor sit amet consectetur adipisicing elit. Id, inventore.</p>
    <p>2. Lorem ipsum dolor sit amet consectetur adipisicing elit. Non, ab.</p>
    <p>3. Lorem ipsum dolor, sit amet consectetur adipisicing elit. Dolores, cupiditate?</p>
    <p>4. Lorem ipsum dolor sit, amet consectetur adipisicing elit. Ipsam, cum?</p>

    <ul>
        <li>item 1</li>
        <li>item 2</li>
        <li>item 3</li>
        <li>item 4</li>
        <li>item 5 </li>
    </ul>

    <button>Button Test Hover Effect</button>

</body>
</html>

Type Selector

Type Selector is used when we want to select HTML elements by their name. Type selectors select all elements of a given type from an HTML document and apply styles to them. This is the syntax to use type selector element{property: value;}. Let’s See an example of a type selector.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Learning CSS</title>
    <style>
        /*Universal Selector*/
        /*
        *{
            color:#383CC1;
        }
        */

         /*new code */
         /*Type Selector*/
         p{
            color:#383CC1;
         }
    </style>

</head>
<body>
    <h1>Heading Level 1</h1>
    <h2>Heading Level 2</h2>
    <h3>Heading Level 3</h3>
    <h4>Heading Level 4</h4>
    <h5>Heading Level 5</h5>
    <h6>Heading Level 6</h6>

    <p>1. Lorem ipsum dolor sit amet consectetur adipisicing elit. Id, inventore.</p>
    <p>2. Lorem ipsum dolor sit amet consectetur adipisicing elit. Non, ab.</p>
    <p>3. Lorem ipsum dolor, sit amet consectetur adipisicing elit. Dolores, cupiditate?</p>
    <p>4. Lorem ipsum dolor sit, amet consectetur adipisicing elit. Ipsam, cum?</p>

    <ul>
        <li>item 1</li>
        <li>item 2</li>
        <li>item 3</li>
        <li>item 4</li>
        <li>item 5 </li>
    </ul>

    <button>Button Test Hover Effect</button>


</body>
</html>

in the above HTML document, I have five paragraph elements and I want to change the color of all the paragraph elements on my webpage, so I have used a type selector to do the same. p{color:#383CC1;} selects all the paragraph tag from the HTML document and change their color.

Class Selector

This is the most used CSS selector. For using a class selector we first add a class attribute to our HTML document, and then we select that class name in our CSS and apply some styles, and styles are applied to all the HTML elements with that class attribute. This is the syntax of using the class selector. class_name{property: value}.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Learning CSS</title>
    <style>

         /*new code */
        /*Class Selector*/
        .primary-heading{
            color:#3B71CA
        }

        .secondary-heading{
            color:#9FA6B2;
        }

        .primary-text{
            color:#3B71CA
        }

        .secondary-text{
            color:#9FA6B2;
        }

    </style>

</head>
<body>
    <h1 class="primary-heading">Heading Level 1</h1>
    <h2 class="secondary-heading">Heading Level 2</h2>
    <h3>Heading Level 3</h3>
    <h4>Heading Level 4</h4>
    <h5>Heading Level 5</h5>
    <h6>Heading Level 6</h6>

    <p class="primary-text">1. Lorem ipsum dolor sit amet consectetur adipisicing elit. Id, inventore.</p>
    <p class="secondary-text">2. Lorem ipsum dolor sit amet consectetur adipisicing elit. Non, ab.</p>
    <p class="primary-text">3. Lorem ipsum dolor, sit amet consectetur adipisicing elit. Dolores, cupiditate?</p>
    <p class="secondary-text">4. Lorem ipsum dolor sit, amet consectetur adipisicing elit. Ipsam, cum?</p>

    <ul>
        <li>item 1</li>
        <li>item 2</li>
        <li>item 3</li>
        <li>item 4</li>
        <li>item 5 </li>
    </ul>

    <button>Button Test Hover Effect</button>


</body>
</html>

As you can see in the above HTML document I have used class attributes in some of the HTML elements and used the same class name in the CSS to apply styles. you can also see that I have used the same class name in multiple HTML elements. So When we use a class selector we can apply the same styles on any number of elements you just only need to add that class to the element.

ID Selector

id select selects all the elements with the matching id attribute. For using Id Selector we add the id attribute to the element in our HTML document. But remember that there should be only one element with a given ID in a document.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Learning CSS</title>
    <style>
       /*ID Selector*/

         #btn-primary{
            background-color: #3B71CA;
            padding: 10px 20px;
            font-size: 20px;
            color: #fff;
         }
    </style>

</head>
<body>
    <h1 class="primary-heading">Heading Level 1</h1>
    <h2 class="secondary-heading">Heading Level 2</h2>
    <h3>Heading Level 3</h3>
    <h4>Heading Level 4</h4>
    <h5>Heading Level 5</h5>
    <h6>Heading Level 6</h6>

    <p class="primary-text">1. Lorem ipsum dolor sit amet consectetur adipisicing elit. Id, inventore.</p>
    <p class="secondary-text">2. Lorem ipsum dolor sit amet consectetur adipisicing elit. Non, ab.</p>
    <p class="primary-text">3. Lorem ipsum dolor, sit amet consectetur adipisicing elit. Dolores, cupiditate?</p>
    <p class="secondary-text">4. Lorem ipsum dolor sit, amet consectetur adipisicing elit. Ipsam, cum?</p>

    <ul>
        <li>item 1</li>
        <li>item 2</li>
        <li>item 3</li>
        <li>item 4</li>
        <li>item 5 </li>
    </ul>

    <button id="btn-primary">Button Test Hover Effect</button>


</body>
</html>

In the above example, I have added an id attribute to the HTML document and used the same id name to add some styles to it.

List Selector

list selector is used when want to apply the same styles on multiple elements. This is the syntax to use list selector
element_one,element_two {property: value;}.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Learning CSS</title>
    <style>      
        /*List Selector*/

        /*Without using list selector*/
         /*
        .primary-heading{
            color:#3B71CA
        }
        .primary-text{
            color:#3B71CA
        }
        */
          /*With  list selector*/
        .primary-heading, .primary-text {
            color:#3B71CA
        }

    </style>

</head>
<body>
    <h1 class="primary-heading">Heading Level 1</h1>
    <h2 class="secondary-heading">Heading Level 2</h2>
    <h3>Heading Level 3</h3>
    <h4>Heading Level 4</h4>
    <h5>Heading Level 5</h5>
    <h6>Heading Level 6</h6>

    <p class="primary-text">1. Lorem ipsum dolor sit amet consectetur adipisicing elit. Id, inventore.</p>
    <p class="secondary-text">2. Lorem ipsum dolor sit amet consectetur adipisicing elit. Non, ab.</p>
    <p class="primary-text">3. Lorem ipsum dolor, sit amet consectetur adipisicing elit. Dolores, cupiditate?</p>
    <p class="secondary-text">4. Lorem ipsum dolor sit, amet consectetur adipisicing elit. Ipsam, cum?</p>

    <ul>
        <li>item 1</li>
        <li>item 2</li>
        <li>item 3</li>
        <li>item 4</li>
        <li>item 5 </li>
    </ul>
    <button id="btn-primary">Button Test Hover Effect</button>
</body>
</html>

Descendant Selector

The descendant selector is represented by two selectors, separated by a blank spaceselectror1 selector2 {property: value}. It selects all the element that is descendant of the first element.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Learning CSS</title>
    <style>
         /*Descendent Selector*/
        .primary-div p{
            color:#3B71CA
        }
    </style>

</head>
<body>
    <h1 class="primary-heading">Heading Level 1</h1>
    <h2 class="secondary-heading">Heading Level 2</h2>
    <h3>Heading Level 3</h3>


    <div class="primary-div">
        <p class="primary-text">1. Lorem ipsum dolor sit amet consectetur adipisicing elit. Id, inventore.</p>
        <p class="secondary-text">2. Lorem ipsum dolor sit amet consectetur adipisicing elit. Non, ab.</p>
        <p class="primary-text">3. Lorem ipsum dolor, sit amet consectetur adipisicing elit. Dolores, cupiditate?</p>
        <p class="secondary-text">4. Lorem ipsum dolor sit, amet consectetur adipisicing elit. Ipsam, cum?</p>

        <h4>Heading Level 4</h4>
        <h5>Heading Level 5</h5>
        <h6>Heading Level 6</h6>

        <a href="">Click Here</a>
        <div>
            <p>
                Paragraph inside the div
            </p>
        </div>

    </div>
    <ul>
        <li>item 1</li>
        <li>item 2</li>
        <li>item 3</li>
        <li>item 4</li>
        <li>item 5 </li>
    </ul>

    <button id="btn-primary">Button Test Hover Effect</button>
</body>
</html>

In the above example, I have a div element with the class name primary-div and inside that element, we have paragraph heading and anchor element as a child element in the CSS I am using the descendent sector to select all the paragram elements which are descendent of the primary-div.

Direct Child Selector `>`

Direct child selector is similar to the descendent selector, in this we also use two selectors, but instead of using blank space to separate them we use > selectror1 > selector2 {property: value}. The direct child selector selects the direct child of the first selector.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Learning CSS</title>
    <style>

         /*Direct Child Selector*/
         .primary-div > p{
            color:#3B71CA
        }

    </style>

</head>
<body>
    <h1 class="primary-heading">Heading Level 1</h1>
    <h2 class="secondary-heading">Heading Level 2</h2>
    <h3>Heading Level 3</h3>


    <div class="primary-div">
        <p class="primary-text">1. Lorem ipsum dolor sit amet consectetur adipisicing elit. Id, inventore.</p>
        <p class="secondary-text">2. Lorem ipsum dolor sit amet consectetur adipisicing elit. Non, ab.</p>
        <p class="primary-text">3. Lorem ipsum dolor, sit amet consectetur adipisicing elit. Dolores, cupiditate?</p>
        <p class="secondary-text">4. Lorem ipsum dolor sit, amet consectetur adipisicing elit. Ipsam, cum?</p>

        <h4>Heading Level 4</h4>
        <h5>Heading Level 5</h5>
        <h6>Heading Level 6</h6>

        <a href="">Click Here</a>
        <div>
            <p>
                Paragraph inside the div
            </p>
        </div>

    </div>
    <ul>
        <li>item 1</li>
        <li>item 2</li>
        <li>item 3</li>
        <li>item 4</li>
        <li>item 5 </li>
    </ul>

    <button id="btn-primary">Button Test Hover Effect</button>
</body>
</html>

As you can see paragraph element which is only the direct child of the primary-div element is getting styled. The descendent paragraph is not getting styled.

Sibling Selector

There are two types of Sibling selectors.

General Sibling Selector ~
Adjacent Sibling Selector +

General Sibling Selector `~`

The General Sibling Selector Selects all the elements that are next to the selected sibling but All siblings should have the same parent.

former_element ~ target_element { style properties }

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Learning CSS</title>
    <style>
       /*General Sibling Selector*/
        .selected-sibling-item ~ li{
            text-decoration: underline;
        }
    </style>

</head>
<body>
    <h1 class="primary-heading">Heading Level 1</h1>
    <h2 class="secondary-heading">Heading Level 2</h2>
    <h3>Heading Level 3</h3>


    <div class="primary-div">
        <p class="selected-sibling">1. Lorem ipsum dolor sit amet consectetur adipisicing elit. Id, inventore.</p>
        <p class="secondary-text">2. Lorem ipsum dolor sit amet consectetur adipisicing elit. Non, ab.</p>
        <p class="primary-text">3. Lorem ipsum dolor, sit amet consectetur adipisicing elit. Dolores, cupiditate?</p>
        <p class="secondary-text">4. Lorem ipsum dolor sit, amet consectetur adipisicing elit. Ipsam, cum?</p>

        <h4>Heading Level 4</h4>
        <h5>Heading Level 5</h5>
        <h6>Heading Level 6</h6>

        <a href="">Click Here</a>
        <div>
            <p>
                Paragraph inside the div
            </p>
        </div>

    </div>
    <ul>
        <li class="selected-sibling-item">item 1</li>
        <li>item 2</li>
        <li>item 3</li>
        <li>item 4</li>
        <li>item 5 </li>
    </ul>

    <button id="btn-primary">Button Test Hover Effect</button>
</body>
</html>

Adjacent sibling Selector `+`

The Adjacent Sibling Selector selects the element which is adjacent to the selected sibling. All siblings should have the same parent.

former_element + target_element { style properties }

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Learning CSS</title>
    <style>
         /*Adjacent Sibling Selector*/

        .selected-sibling + p {
            color:#3B71CA

        }
        .selected-sibling-item + li {
            text-decoration: underline;
        }

    </style>

</head>
<body>
    <h1 class="primary-heading">Heading Level 1</h1>
    <h2 class="secondary-heading">Heading Level 2</h2>
    <h3>Heading Level 3</h3>


    <div class="primary-div">
        <p class="selected-sibling">1. Lorem ipsum dolor sit amet consectetur adipisicing elit. Id, inventore.</p>
        <p class="secondary-text">2. Lorem ipsum dolor sit amet consectetur adipisicing elit. Non, ab.</p>
        <p class="primary-text">3. Lorem ipsum dolor, sit amet consectetur adipisicing elit. Dolores, cupiditate?</p>
        <p class="secondary-text">4. Lorem ipsum dolor sit, amet consectetur adipisicing elit. Ipsam, cum?</p>

        <h4>Heading Level 4</h4>
        <h5>Heading Level 5</h5>
        <h6>Heading Level 6</h6>

        <a href="">Click Here</a>
        <div>
            <p>
                Paragraph inside the div
            </p>
        </div>

    </div>
    <ul>
        <li class="selected-sibling-item">item 1</li>
        <li>item 2</li>
        <li>item 3</li>
        <li>item 4</li>
        <li>item 5 </li>
    </ul>

    <button id="btn-primary">Button Test Hover Effect</button>
</body>
</html>

Pseudo Class Selector `:`

Pseudo class is used to define the state of the selected element. There are many different types of Pseudo class selectors and it’s impossible to discuss all of them here, you can read more about them on mdn.
selector: pseudo_class_name: {property: value}.

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Learning CSS</title>
        <style>

            #btn-primary{
                padding: 10px 20px;
                font-size: 20px;

            }
            #btn-primary:hover{
                background-color:#3B71CA ;
                color: #fff;
                cursor: pointer;
            }



        </style>

    </head>
    <body>
        <h1 class="primary-heading">Heading Level 1</h1>
        <h2 class="secondary-heading">Heading Level 2</h2>
        <h3>Heading Level 3</h3>


        <div class="primary-div">
            <p class="selected-sibling">1. Lorem ipsum dolor sit amet consectetur adipisicing elit. Id, inventore.</p>
            <p class="secondary-text">2. Lorem ipsum dolor sit amet consectetur adipisicing elit. Non, ab.</p>
            <p class="primary-text">3. Lorem ipsum dolor, sit amet consectetur adipisicing elit. Dolores, cupiditate?</p>
            <p class="secondary-text">4. Lorem ipsum dolor sit, amet consectetur adipisicing elit. Ipsam, cum?</p>

            <h4>Heading Level 4</h4>
            <h5>Heading Level 5</h5>
            <h6>Heading Level 6</h6>

            <a href="">Click Here</a>
            <div>
                <p>
                    Paragraph inside the div
                </p>
            </div>

        </div>
        <ul>
            <li class="selected-sibling-item">item 1</li>
            <li>item 2</li>
            <li>item 3</li>
            <li>item 4</li>
            <li>item 5 </li>
        </ul>

        <button id="btn-primary">Button Test Hover Effect</button>

        <p class="pseudo-element-before">
            Paragraph to test '::before' pseudo element
        </p>
        <p class="pseudo-element-after">
            Paragraph to test '::after' pseudo element
        </p>

    </body>
    </html>

Pseudo Element Selector `::`

pseudo-element selector** allows you to style a specific part of an element. By using pseudo-elements, you can target or add an additional element to your HTML without adding extra code.

selector: pseudo_element: {property: value}

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Learning CSS</title>
        <style>

            /*Pseudo Element Selector*/

            .pseudo-element-after::after{
                content: ""; /*You can use any string as content - even an empty string*/
                display: block;
                height: 20px;
                width: 20px;
                background-color: #3B71CA;

            }

            .pseudo-element-before::before{
                content: ""; /*You can use any string as content - even an empty string*/
                display: block;
                height: 20px;
                width: 20px;
                background-color: #9FA6B2;
            }

        </style>

    </head>
    <body>
        <h1 class="primary-heading">Heading Level 1</h1>
        <h2 class="secondary-heading">Heading Level 2</h2>
        <h3>Heading Level 3</h3>


        <div class="primary-div">
            <p class="selected-sibling">1. Lorem ipsum dolor sit amet consectetur adipisicing elit. Id, inventore.</p>
            <p class="secondary-text">2. Lorem ipsum dolor sit amet consectetur adipisicing elit. Non, ab.</p>
            <p class="primary-text">3. Lorem ipsum dolor, sit amet consectetur adipisicing elit. Dolores, cupiditate?</p>
            <p class="secondary-text">4. Lorem ipsum dolor sit, amet consectetur adipisicing elit. Ipsam, cum?</p>

            <h4>Heading Level 4</h4>
            <h5>Heading Level 5</h5>
            <h6>Heading Level 6</h6>

            <a href="">Click Here</a>
            <div>
                <p>
                    Paragraph inside the div
                </p>
            </div>

        </div>
        <ul>
            <li class="selected-sibling-item">item 1</li>
            <li>item 2</li>
            <li>item 3</li>
            <li>item 4</li>
            <li>item 5 </li>
        </ul>

        <button id="btn-primary">Button Test Hover Effect</button>

        <p class="pseudo-element-before">
            Paragraph to test '::before' pseudo element
        </p>
        <p class="pseudo-element-after">
            Paragraph to test '::after' pseudo element
        </p>

    </body>
    </html>

Conclusion

That's it for this article I hope this was worth your reading. If you want to read more about selectors then Click Here

Complete Code

DEV Community: Ankit Kumar

Django authenticate and login methods

Working with Python Dictionary

Creating Dictionary

Accessing Data from Dictionary

Using Square Brackets:

Using get() method:

Accessing keys of the dictionary:

Accessing Values of the dictionary.

Accessing items from the dictionary

Modifying Dictionary

Adding new data

Removing data from the dictionary

Using Loops with Dictionary

Dictionary Comprehension

Choosing the correct key

Dictionary methods

Summary:-

Introducing TypeTales

What I built

Category Submission:

App Link

Screenshots

Description

Link to Source Code

Permissive License

Background (What made you decide to build this particular app? What inspired you?)

How I built it (How did you utilize GitHub Actions or GitHub Codespaces? Did you learn something new along the way? Pick up a new skill?)

Additional Resources/Info

Conclusion

Getting started with Express: Building your first app

Step 1: Basic Setup

Step 2: Express and nodemon Installation.

Step 3: Express Setup

Introducing DEVBlogs - Linode + DEV Hackathon

What I built

Category Submission:

App Link

Screenshots

Description

Link to Source Code

Permissive License

Background

How I built it

Additional Resources/Info

Conclusion

Operators In JavaScript

Assignment Operator

Arithmetic Operator

Addition

Subtraction

Division (/)

Modulus(%)

Increment (++)

Decrement (--)

Comparison Operator

Equal (==)

Strict equal (===)

Not Equal (!=)

Strict Not Equal (!==)

Few More (>,>=,<,<=)

Logical Operator

OR

AND (&&)

NOT (!)

Ternary Operator

Conclusion

Values & Variables In JavaScript

Number

String

Boolean

Empty Values

Arrays

Objects

Variables.

Rules for naming a variable.

Getting Started With JavaScript.

Why JavaScript?

A pinch of history.

Getting Started

Using `get()` method:

Not the End ^😒

`flex-wrap: wrap`

`flex-wrap:wrap-reverse`

`justify-content: center`

`justify-content: flex-start`

`justify-content: flex-end`

`justify-content:space-between`

`justify-content: space-around`

`justify-content: space-evenly`

`align-items: center`

`align-items: flex-start`

`align-items: flex-end`

`align-items:stretch`

Universal Selector `*`