repo stringlengths 8 123 | branch stringclasses 178 values | readme stringlengths 1 441k ⌀ | description stringlengths 1 350 ⌀ | topics stringlengths 10 237 | createdAt stringlengths 20 20 | lastCommitDate stringlengths 20 20 | lastReleaseDate stringlengths 20 20 ⌀ | contributors int64 0 10k | pulls int64 0 3.84k | commits int64 1 58.7k | issues int64 0 826 | forks int64 0 13.1k | stars int64 2 49.2k | diskUsage float64 | license stringclasses 24 values | language stringclasses 80 values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Bialu-Software/openpress | main | 
<h3 align="center">OpenPress</h3>
---
<p align="center"> ✨Fully open-source and customizable blog written in vuejs and nodejs
<br>
</p>
## 📝 Table of Contents
- [About](#about)
- [Getting Started](#getting_started)
- [Usage](#usage)
- [Deployment](#deployment)
- [Customization](#maintenance)
- [Maintenance](#maintenance)
- [Built Using](#built_using)
## 🧐 About <a name = "about"></a>
This project is open-source blog written using vuejs (frontend) and nodejs (backend). The blog has its own dashboard and sqlite3 database.
## 🏁 Getting Started <a name = "getting_started"></a>
In order to run the project we will first need to copy it onto your system. do that with the command `git clone https://github.com/Bialu-Software/openpress.git` (assuming that you have git installed).
### Prerequisites
To do anything with the project you will need to install Node.js from [this website](https://nodejs.org/en/download) or you can use some sort of node version manager. To check if you have installed Node.js, run this command:
```
node -v
```
Clone the repository
```
git clone https://github.com/Bialu-Software/openpress.git
```
### Installing
Now you need to go to the project directory and run this command so you have all of the needed packages.
```
npm install
```
Before we can run the web application, we might want to init the database for the backend using:
```
npm run syncdb
```
After is everything installed we can run it:
```
npm run start
```
Now if you go to `http://localhost:8080/` in your browser, you should see something like this:
## 🎈 Usage <a name="usage"></a>
This project is not intended for commercial use but nothing is stopping you :)
## 🚀 Deployment <a name = "deployment"></a>
To fully deploy your blog we suggest using a linux system. And to build and minify the project use:
```
npm run build
```
## ✨ Customization <a name = "customization"></a>
You can customize your blog in a variety of ways. The easiest way is to change change the css in `./src/assets/styles/main.scss`. By changing the things in the file you will change the appearance of your blog.
### Other ways to customize the project
- Changing the `./backend/routes.js` and adding some new routes you may want. This is the basic template for a route:
```js
router.get('/path-to-your-route', async (req, res) => {
if (true) {
res.send("Route is working")
} else {
return res.status(404).send("Page not found");
}
})
```
- Adding your own env variable. Just edit or create the `.env` file and add your secret key. (this change may cause logout of all users). See more parameters in `.env.example`
```
SECRET_KEY=your-secret-key
```
## ⚙ Maintenance <a name = "maintenance"></a>
If you want to update the database schema, you will afterwards need to run this command
```
npm run syncdb
```
## ⛏️ Built Using <a name = "built_using"></a>
- [SQLite](https://www.sqlite.org/index.html) - Database
- [VueJs](https://vuejs.org/) - Web Framework
- [NodeJs](https://nodejs.org/en/) - Server Environment
<a href="https://github.com/Bialu-Software/" ><img width="223" hspace="10" alt="Powered by Bialu Software" src="https://media.discordapp.net/attachments/1055532722304585765/1069690405425254420/blue-icon.png?width=602&height=80"> </a>
| ✨Fully open-source and customizable blog | blog,blog-theme,blogging,configuration,cutomization,javascript,typescript,vue,vue3,vuejs | 2023-04-08T18:59:37Z | 2023-10-28T20:43:07Z | null | 5 | 20 | 175 | 5 | 2 | 4 | null | MIT | Vue |
sumit9235/WoW.com | main | 💻Unique Project Name & logo :- WoW.com - 
---
WoW.com is an e-commerce website designed using HTML, CSS and JavaScript. The server is built using NodeJs, ExpressJs and the database is made using MongoDB. It is a clone of Ebay.com and designed to be easy to use and provides users with an intuitive interface for purchasing products.This is an individual Project from Masai School in the Construct Week and able to compleate within 5 Days.
---
## 💫Tech Stack
**Client:** HTML | CSS | Javascript | External CSS library
**Server:** Node.js | Express.js | MongoDB | Bcrypt | cors | Redis | JWT
**github:** To maintain repository and collabration and version control.
**VS Code:** To write HTML,CSS and JavaScript code.
**Microsoft Edge,Google Chrome & Mozilla Firefox:** To check the functionality and run the code.
## Frontend Part
- Home page
- Login/Signup
- Product sections
- Cart section
- Admin section
## Backend Part
- Authentication using JWT
- Bcryting password
- Node.js
- Express.js
## Database
- MongoDB
- Redis
---
## Features ✨
- HomePage , Admin page , Navbar, Footer
- Adding in cart , Sorting , Filtering
- Intuitive and easy-to-use interface
- Cart Page
- Authentication, Authorization
- Secure user authentication and data encryption
- Sign Up , Login
---
## Screenshots 📷
---
# HomePage
# Signup | Login
# Products page
# Admin page
---
---
⭐Deployed Link:- https://sage-biscotti-b2b0b5.netlify.app/
----
<h1 align="center">✨Thank You✨</h1>
| About WoW.com is an e-commerce website designed using HTML, CSS and JavaScript. The server is built using NodeJs, ExpressJs and the database is made using MongoDB | css3,express-js,htmls5,javascript,login-page,mongodb-database,nodejs-server,responsive-design,signup | 2023-03-28T12:26:00Z | 2023-05-15T14:17:10Z | null | 2 | 5 | 24 | 0 | 0 | 4 | null | null | HTML |
your-moon/BolorToli | main | <h1 align="center">｡･:*˚:✧｡BolorТoli｡✧:˚*:･｡</h1>
##
Oрчуулахыг хүссэн үгээ **ганцхан товшилтоор** орчуулах, Мөн өөр хуудасруу шилжин орох шаардлагагүйгээр орчуулах боломжтой болсон. Хүссэн тэкстээ select хийхэд л орчуулсан үгсийн жагсаалт гарж ирэх болно.
##
Жич: Энэ extension нь BolorSoft-oос **албан ёсоор гаргасан extension биш** болно.
## 🌟 Онцлог
- [x] Уншиж буй хуудаснаас өөр хуудас руу шилжих шаардлагагүйгээр орчуулах боломжтой.
- [x] Маш хөнгөн бөгөөн хурдан ажиллана.
## 🚀 Суулгах заавар
1. `git clone` хийх мөн `zip` файлаар татаж авж болно.(zip-ээс татаж авсан бол extract хийнэ).
2. Chrome-ийн Extensions цэс руу орж баруун дээр байрлах developer mode-ийг асаана.
3. Зүүн талд нь Load Unpacked гэх товч гарч ирсэн байх бөгөөд түүн дээр дарж татаж авсан фолдэр-ийг сонгоно.
4. Ашиглахад бэлэн.
## 📙 Хэрэглээ
1. Mouse 1-ээр товшиж select хийсний дараа үгийн доор pop-up гарж ирнэ.
2. Үүн дээр дарснаар орчуулсан үгсийн жагсаалт гарж ирнэ.
<img width="450" alt="Screenshot 2023-06-26 at 11 28 35 AM" src="https://github.com/Hollowloki/bolor_toli-extension/assets/104183502/b3fd3b2b-c3e9-4f8f-a08f-85fe15b481ab">
<img width="450" alt="Screenshot 2023-06-26 at 11 29 06 AM" src="https://github.com/Hollowloki/bolor_toli-extension/assets/104183502/b7eaba26-67dc-4ac6-8766-55c64bbc8154">
## 🛠️ Хөгжүүлэлт
1. Clone the repository:
```
git clone https://github.com/Hollowloki/bolor_toli-extension.git
```
2. Navigate to the project directory:
```
cd bolor_toli-extension
```
3. Ready for changes
| BolorToli Translation extension | chrome-api,javascript,pop-up,translation,bolor-toli | 2023-03-28T05:50:22Z | 2024-04-01T17:14:17Z | 2023-09-19T05:51:01Z | 3 | 1 | 29 | 3 | 2 | 4 | null | MIT | TypeScript |
moaazelsayed1/Koplin | master | # Koplin
Koplin is a kanban application built using React, Nodejs, Expressjs, and Postgres. The application allows users to create and manage topics, boards, and tasks, as well as invite friends and collaborate on projects.
https://github.com/Hazemmahdyx/Koplin/assets/88671390/b8d8af8a-80c7-4dff-b9f0-dcaa02bd8ebf
## Features
- Users can create an account and log in to manage their own topics and boards
- Create and manage topics and boards
- Create and manage tasks within boards
- Assign tasks to team members
- Edit tasks and move them between different stages (todo, in progress, review, completed)
- Invite friends and collaborate on projects
- Edit profile information including username, email, and profile image
- Notify users when they are added to a board
## Tech Stack
### Frontend
- React
- Vite
- Tailwind CSS
- react-beautiful-dnd
- axios
- primereact
- quill
### Backend
- Node.js and Express.js for building the backend API
- Sequelize for database management
- JWT for user authentication and authorization
- bcrypt for password hashing and authentication
- SendGrid and Nodemailer for sending email notifications
- Cloudinary and Sharp for image management
- Multer for handling file uploads
- Canvas for generating and manipulating images in Node.js
- Cors for enabling Cross-Origin Resource Sharing (CORS)
- Socket.IO for real-time notifications
### Installation
To get started with Koplin, follow these steps:
1. Clone the repository: `git clone https://github.com/moaazelsayed1/Koplin`
2. Install dependencies:
- For the frontend, navigate to the client folder and run `npm install`
- For the backend, navigate to the `server` folder and run `npm install`
3. Install dependencies:
- For the frontend, navigate to the client folder and run `npm run dev`
- For the backend, navigate to the `server` folder and run `npm run start:dev`
## Contributors
- Moaaz Elsayed: [GitHub](https://github.com/moaazelsayed1) (BackEnd)
- Hazem Mahdy: [GitHub](https://github.com/Hazemmahdyx) (FrontEnd)
| kanban application built using React, Nodejs, Express, and Postgres. | api-rest,nodejs,react,kanban,pern-stack,javascript,jwt-authentication | 2023-04-08T12:20:47Z | 2023-07-16T08:24:36Z | null | 2 | 36 | 201 | 0 | 1 | 4 | null | null | JavaScript |
whjin/canvas-utils | main | # canvas-utils
canvas utils
| canvas utils | canvas,javascript,webpack,ecmascript,pixijs | 2023-03-26T14:29:03Z | 2023-06-05T11:32:41Z | null | 1 | 0 | 29 | 0 | 0 | 4 | null | MIT | JavaScript |
jethliya-balaji/Django-Chat-App | main | # Django Chat App
Django Chat App is a real-time chat application built using Python, Django, Tailwind CSS, Django-channels, WebSocket, and Redis as the channels layer. This app allows users to create public and private chat rooms, and communicate with other users in real-time.
## What I Learned
During the development of this project, I learned how to:
- Integrate Websocket and Django to build real-time chat applications.
- Use Django Channels and Redis as the channels layer to handle WebSocket - requests and push messages to the clients in real-time.
- Build responsive and modern user interfaces using Tailwind CSS. (Yay! I know that not good. not a Frontend guy.)
- Implement user authentication and authorization using Django's built-in - authentication system.
- Use Django ORM to implement CRUD operations for the chat rooms.
- Build a feature to create public and private chat rooms.
## Features
- Sign-up, sign-in, and sign-out functionality
- Create and join public and private chat rooms
- Real-time communication using Websocket and Redis
- Edit and delete rooms
- View a list of all public and private rooms
- Responsive design using Tailwind CSS
## Requirements
- Python 3.x (I used 3.10.9)
- Django 3.x (I used 3.2.18)
- Channels(I used 3.0.5)
- Tweak(I used 1.4.12)
## :exclamation: This is very important
NOTE: Before running the app, please ensure the following steps:
If you are running the app on a development server, please comment out the Postgres database
setting and Redis channel layer in the settings.py file and uncomment the In-Memory Channel
Layer and SQLite3 database settings.
If you are using a .env file, please ensure that you provide important environment variables
such as SECRET_KEY, DEBUG, and ALLOWED_HOSTS. If you want to use the environment variables
directly, please comment out all the os.environ.get functions in the settings.py file and
provide all the environment variables directly.
By following these steps, you will be able to run the app smoothly without any errors related
to database or environment variables.
## Support
If you need any help or have any questions, please feel free to contact me.
## Conclusion
In conclusion, the chat application is a useful tool for facilitating communication between users in real-time. The application makes use of various technologies such as Django, Channels, and Redis to provide a seamless experience for users. The different components of the application, such as the URL patterns and HTML templates, work together to create a functional and aesthetically pleasing user interface. However, before running the application, it is important to ensure that the necessary environment variables are properly configured, especially if using a .env file. By following the instructions and best practices provided, developers can create a reliable and secure chat application that meets the needs of their users.
## Fun Section
The demo web site is up and running at [here](https://jethliyabalaji-chat.up.railway.app/) but it may be temporarily down because the developer needs a coffee break. If you find the app helpful, feel free to buy the developer a coffee! [here]()
## Authors
Balaji Jethliya - Initial work - [GitHub](https://github.com/jethliya-balaji), [Twitter](https://twitter.com/jethliyabalaji)
| This is a real-time chat application built with Python, Django, Django Channels, Websocket and Redis as the channels layer. The frontend design was created using Tailwind CSS. | css,django,django-channels,html,python,railway-app,redis,websocket,javascript,learning | 2023-03-27T16:18:44Z | 2023-04-19T16:15:02Z | null | 1 | 0 | 18 | 0 | 0 | 4 | null | null | Python |
TeoSean00/Vendor_Form_Management_System_Backend | master | # GoForm (Backend)
## Youtube Demo of the Application
- [Youtube Link](https://youtu.be/mXnO4Y1JEVU)
## Getting Started
- [Install Maven](https://www.baeldung.com/install-maven-on-windows-linux-mac)
- To install project packages with maven <br />
```mvn clean install```
### Install Docker Desktop
- [Install Docker](https://www.docker.com/products/docker-desktop/)
### Check that your docker desktop/daemon is running <br />
Build the Images <br />
```docker compose build```<br />
Run the docker container <br />
```docker compose up```
If you want to build and run the container at the same time <br />
```docker compose up --build```
### Default user credentials
- For admin account
Username : admin
Password : 12345678
- For approver account
Username : approver
Password : 87654321
### Frontend Repository
- https://github.com/TeoSean00/Vendor_Form_Management_System_Frontend
| A one-stop Vendor & Form Management System that provides CRUD features for vendors, forms & for the interactions between them, with other features such as a form page design & creation from scratch, an automated email reminder service, coupled with curated dashboards that highlight key, calculated business insights throughout the business process. | bootstrap,chartjs,css,dashboards,docker,email-service,form-management,java,javascript,jwt-authentication | 2023-04-02T10:15:17Z | 2023-12-20T10:32:24Z | null | 1 | 0 | 165 | 0 | 1 | 4 | null | null | Java |
jess-andrade/costs | main | # Getting Started with Create React App
This project was bootstrapped with [Create React App](https://github.com/facebook/create-react-app).
## Available Scripts
In the project directory, you can run:
### `npm start`
Runs the app in the development mode.\
Open [http://localhost:3000](http://localhost:3000) to view it in your browser.
The page will reload when you make changes.\
You may also see any lint errors in the console.
### `npm test`
Launches the test runner in the interactive watch mode.\
See the section about [running tests](https://facebook.github.io/create-react-app/docs/running-tests) for more information.
### `npm run build`
Builds the app for production to the `build` folder.\
It correctly bundles React in production mode and optimizes the build for the best performance.
The build is minified and the filenames include the hashes.\
Your app is ready to be deployed!
See the section about [deployment](https://facebook.github.io/create-react-app/docs/deployment) for more information.
### `npm run eject`
**Note: this is a one-way operation. Once you `eject`, you can't go back!**
If you aren't satisfied with the build tool and configuration choices, you can `eject` at any time. This command will remove the single build dependency from your project.
Instead, it will copy all the configuration files and the transitive dependencies (webpack, Babel, ESLint, etc) right into your project so you have full control over them. All of the commands except `eject` will still work, but they will point to the copied scripts so you can tweak them. At this point you're on your own.
You don't have to ever use `eject`. The curated feature set is suitable for small and middle deployments, and you shouldn't feel obligated to use this feature. However we understand that this tool wouldn't be useful if you couldn't customize it when you are ready for it.
## Learn More
You can learn more in the [Create React App documentation](https://facebook.github.io/create-react-app/docs/getting-started).
To learn React, check out the [React documentation](https://reactjs.org/).
### Code Splitting
This section has moved here: [https://facebook.github.io/create-react-app/docs/code-splitting](https://facebook.github.io/create-react-app/docs/code-splitting)
### Analyzing the Bundle Size
This section has moved here: [https://facebook.github.io/create-react-app/docs/analyzing-the-bundle-size](https://facebook.github.io/create-react-app/docs/analyzing-the-bundle-size)
### Making a Progressive Web App
This section has moved here: [https://facebook.github.io/create-react-app/docs/making-a-progressive-web-app](https://facebook.github.io/create-react-app/docs/making-a-progressive-web-app)
### Advanced Configuration
This section has moved here: [https://facebook.github.io/create-react-app/docs/advanced-configuration](https://facebook.github.io/create-react-app/docs/advanced-configuration)
### Deployment
This section has moved here: [https://facebook.github.io/create-react-app/docs/deployment](https://facebook.github.io/create-react-app/docs/deployment)
### `npm run build` fails to minify
This section has moved here: [https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify](https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify)
| 💸 • Hey human, with this application you can manage the costs of your project :: | css,html,javascript,nodejs,react | 2023-03-28T17:04:20Z | 2023-03-28T17:08:58Z | null | 2 | 0 | 3 | 0 | 0 | 4 | null | null | JavaScript |
prititi/fun-note-365- | main | # Easy Polls
Easy polls is the ultimate Q&A and polling platform for live and virtual meetings and events.
## Deployment
This project is deployed on vercel here - [Easy Polls](https://fun-note-365-fsps.vercel.app/)
---
# Welcome 👋
---
## About this project: 🙌
Easy polls is the ultimate Q&A and polling platform for live and virtual meetings and events.
---
## Our Team Members ❤️
- [Priti Tiwari](https://www.linkedin.com/in/priti-tiwari-5149b8255/)
- [Anandhu P A](https://www.linkedin.com/in/anandhu-p-a-953a30231/)
- [Prashant Verma](https://www.linkedin.com/in/prashant-verma-b44738178/)
- [Harshit Sahu]()
- [Swapnil Solanki]()
### Pages & Features 👇
- `Home Page`: Nav Bar with dropdowns, sliding banners & slider for offer.
- `Sign-Up`: User details are stored in mongo DB.
- `Sign-In`: User authentication to check whether the user's phone number and password match with details existing in the database.
- `Events` : User can create an events.
- `Pricing` : If user want to by the plan for one moths you can easy buy.
- `Quiz` : User can create multiple Quiz.
- `Ranking`: According to ans user can create the rank.
- `Rating` : It is as like voting application you can give rate at a perticular person or which topic you want.
- `Q&A` : User can ask the questions to the perticular student or employee in this Q&A thing.
- `Admin Page` : In this page we can get all the users data,quiz data and many things.
### Technology we used....🔧
- `HTML`
- `CSS`
- `JavaScript`
- `Node JS`
- `Express JS`
- `MongoDB`
- `socket.io`
- `ws`
- `JWT authentication`
- `bcrypt`
# 0) USER FLOW:
# 1) Landing Page:
# 2) Signup Page :
# 3) Login page :
# 4) Products Tour Page:
# 5) Events:
# 6) Quiz :
# 7) Rating :
# 8) Open text :
# 9) Ranking :
# 10) Pricing :
# 11) Checkout :
# 12) Admin :
Thanks you for Checking our Project
| Easy polls is the ultimate Q&A and polling platform for live and virtual meetings and events and it is a clone of slido. | bcyrpt,css,expressjs,html,javascript,jwt-authentication,mongodb,nodejs,socket-io,ws | 2023-03-28T07:39:01Z | 2023-04-20T06:38:20Z | null | 6 | 52 | 177 | 0 | 1 | 4 | null | null | HTML |
sjsouvik/react-components-hooks | main | # React components & custom hooks
This is to keep some react components & custom hooks that could be used in day to day frontend development.
- [React components](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components)
- [Accordion](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/AccordionImproved)
- [Autocomplete](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/AutoComplete)
- [Carousel](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/Carousel)
- [Star rating](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/StartRating)
- [Tabs](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/TabsImproved)
- [Tag input box](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/TagInput)
- [Modal](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/Modal)
- [Nested comment](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/Comment)
- [File explorer](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/FileExplorer)
- [Memory game](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/MemoryGame)
- [Tic tac toe](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/TicTacToe)
- [Country capital game](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/CountryCapitalGame)
- [OTP input](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/OtpInput)
- [Stepper](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/Stepper)
- [Timer](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/Timer)
- [Stopwatch](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/Stopwatch)
- [Phone number input box](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/PhoneNumberInput)
- [Progress bar](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/ProgressBar)
- [Progress bar II](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/ProgressBars%20II)
- [Progress bar III](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/ProgressBars%20III)
- [Progress bar IV](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/ProgressBars%20IV)
- [Transfer list](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/TransferList)
- [Masonry layout](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/MasonryLayout)
- [Traffic light](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/TrafficLight)
- Forms
- [Contact form](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/ContactForm)
- [Sign up](https://github.com/sjsouvik/JavaScript-Projects/tree/main/Signup-Form)
- [Flight booker](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/FlightBooker)
- [Generate table](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/GenerateTable)
- [Like button](https://github.com/sjsouvik/react-components-hooks/tree/main/src/components/LikeButton)
- [Custom hooks](https://github.com/sjsouvik/react-components-hooks/tree/main/src/hooks)
- [useClickOutside()](https://github.com/sjsouvik/react-components-hooks/blob/main/src/hooks/useClickOutside.js)
- [useDebounce()](https://github.com/sjsouvik/react-components-hooks/blob/main/src/hooks/useDebounce.js)
- [useSWR()](https://github.com/sjsouvik/react-components-hooks/blob/main/src/hooks/useSWR.js)
- [useHover()](https://github.com/sjsouvik/react-components-hooks/blob/main/src/hooks/useHover.js)
- [useFocus()](https://github.com/sjsouvik/react-components-hooks/blob/main/src/hooks/useFocus.js)
- [usePrevious()](https://github.com/sjsouvik/react-components-hooks/blob/main/src/hooks/usePrevious.js)
- [useToggle()](https://github.com/sjsouvik/react-components-hooks/blob/main/src/hooks/useToggle.js)
- [useArray()](https://github.com/sjsouvik/react-components-hooks/blob/main/src/hooks/useArray.js)
- [useEffectOnce()](https://github.com/sjsouvik/react-components-hooks/blob/main/src/hooks/useEffectOnce.js)
- [useIsFirstRender()](https://github.com/sjsouvik/react-components-hooks/blob/main/src/hooks/useIsFirstRender.js)
- [useIsMounted()](https://github.com/sjsouvik/react-components-hooks/blob/main/src/hooks/useIsMounted.js)
- [useTimeout()](https://github.com/sjsouvik/react-components-hooks/blob/main/src/hooks/useTimeout.js)
## Run Locally
Clone the project
```bash
git clone https://github.com/sjsouvik/react-components-hooks.git
```
Install dependencies
```bash
npm install
```
Start the server
```bash
npm run dev
```
Now, you can visit `http://localhost:5173/` to see the project running locally
## License
This repository is [MIT licensed](https://github.com/sjsouvik/react-components-hooks/blob/main/LICENSE)
## Support
Give it a ⭐ if you like it.
| To keep react components & custom hooks | css3,html5,javascript,react-hooks,reactjs,vitejs | 2023-04-08T14:53:34Z | 2024-03-14T17:13:07Z | null | 1 | 0 | 80 | 0 | 1 | 4 | null | MIT | JavaScript |
hegdepavankumar/websites-a-programmer-should-visit | master | # websites-a-programmer-should-visit
The objective of this blog is to reveal the features offered by each of the free code-learning resources to encourage you to start coding on your own.
## Some useful websites for programmers.
- When learning CS, there are some useful sites you must know to get always informed to do your technologies even better and learn new things. Here is a non-exhaustive list of some sites you should visit. This list will get updated as soon as I can get another link, but you can also contribute by adding those you know 😉
- In this article, we take a closer look at the amazing resources to learn to code for free all you will need is **access to an internet connection** and a **laptop**.
## 1. [Codeacademy](https://www.codecademy.com/)
<font color="blue"></font>
[Codeacademy](https://www.codecademy.com/) is an American online interactive platform that offers free coding classes in 12 different programming languages including Python, Java, Go, JavaScript, Ruby, SQL, C++, C#, and Swift, as well as markup languages HTML and CSS.
- [Wikipedia](https://en.wikipedia.org/wiki/Codecademy)
## 2. [Coursera](https://www.coursera.org/)
[Coursera](https://www.coursera.org/) Inc. is a U.S.-based massive open online course provider founded in 2012 by Stanford University computer science professors Andrew Ng and Daphne Koller. Coursera works with universities and other organizations to offer online courses, certifications, and degrees in a variety of subjects.
This is a huge online library for various types of coding-based courses which are taught by an **assortment of professors from different universities**.
- [Wikipedia](https://en.wikipedia.org/wiki/Coursera)
## 3. [edX](https://www.edx.org/)
[EdX](https://www.edx.org/) is another leading online learning platform that is open source instead of for-profit. It was founded by **Harvard University and MIT in 2012**, so you know that you’ll learn about cutting-edge technologies and theories.
Through this learning platform, you can get exposure to ```C#, Java, jQuery, C++, Python, machine learning, R programming, SQL, mobile application design or development,``` and so on.
- [Wikipedia](https://en.wikipedia.org/wiki/EdX)
## 4. [Udemy](https://www.udemy.com/)
Founded in 2010, [Udemy](https://www.udemy.com/) is an online learning platform that can be used as a way to improve or learn job skills.
The topics covered by Udemy include personal development, lifestyle, health and fitness, and development.
As a coder, it also offers you tonnes of development courses under different sections, such as mobile applications, programming languages, web development, game development, databases, and e-commerce.
- [Wikipedia](https://en.wikipedia.org/wiki/Udemy)
## 5. [Khan Academy](https://www.khanacademy.org/)
Khan Academy is an American non-profit educational organization created in 2008 by Sal Khan. Its goal is to create a set of online tools that help educate students. The organization produces short lessons in the form of videos. Its website also includes supplementary practice exercises and materials for educators.
- [Wikipedia](https://en.wikipedia.org/wiki/Khan_Academy)
## 6. [FreeCodeCamp](https://www.freecodecamp.org/)
[FreeCodeCamp](https://www.freecodecamp.org/) is a non-profit organization that consists of an interactive learning web platform, an online community forum, chat rooms, online publications and local organizations that intend to make learning web development accessible to anyone.
- [Wikipedia](https://en.wikipedia.org/wiki/FreeCodeCamp)
## 7. [CodeWars](https://www.codewars.com/)
[CodeWars](https://www.codewars.com/) is an educational community for computer programming. On the platform, software developers train on programming challenges known as kata. These discrete programming exercises train a range of skills in a variety of programming languages and are completed within an online integrated development environment. Some typical programming languages taught by Codewars include JavaScript, CoffeeScript, Java, Ruby, Python, C#, and Clojure.
- [Wikipedia](https://en.wikipedia.org/wiki/Codewars)
## 8. [GA Dash](https://dash.generalassemb.ly/)
[GA Dash](https://dash.generalassemb.ly/) introduces a fun way to learn how to make attractive websites from your browser.
It enables you to learn different web-based programming languages, such as JavaScript, HTML, and CSS.
The fun part is that you will be helped in learning how to make websites in the form of projects.
## 9. [Udacity](https://www.udacity.com/)
[Udacity](https://www.udacity.com/), Inc. is an American for-profit educational organization founded by Sebastian Thrun, David Stavens, and Mike Sokolsky offering massive open online courses. According to Thrun, the origin of the name Udacity comes from the company's desire to be "audacious for you, the student".
- [Wikipedia](https://en.wikipedia.org/wiki/Udacity)
## 10. [Code Conquest](http://www.codeconquest.com/)
[Code Conquest](http://www.codeconquest.com/) can give you a helping hand when you are about to enter the world of coding. Even if you have no idea about what programming or coding is, the Code Conquest platform can help you learn the basics and improve thereon.
The various programming languages taught by Code Conquest include PHP, JavaScript, Ruby, Python, C++, HTML, and CSS.
## 11. [Google Android Training](https://developer.android.com/training/index.html)
If you are interested in learning the nuances of Android application development from scratch, then [Google Android Training](https://developer.android.com/training/index.html) can be greatly useful to you.
## 12. [Pluralsight](https://www.pluralsight.com/)
[Pluralsight](https://www.pluralsight.com/) is another good online code learning platform, offering free and paid courses.
The different courses are organized in the form of paths, specific to technology and programming skills.
## 13. [Code Player](http://thecodeplayer.com/)
The unique thing about this [online code learning platform](http://thecodeplayer.com/) is that it exposes you to videos or presentation walk-throughs about code created by others from scratch.
By going through such real case studies, you will have a better idea about how to use the particular programming language, based on different requirements.
## 14. [The Odin Project](http://www.theodinproject.com/)
This [project aims](http://www.theodinproject.com/) to help you learn web development online for free. As part of their learning process, you participate in several small projects to help you build your own portfolio of work.
It also offers a flexible curriculum, to which you and other students can contribute, to your learning.
## 15. [HTML5 Rocks](http://www.html5rocks.com/en/)
As the name suggests, this platform is mainly focused on learning the nuances of [HTML5](http://www.html5rocks.com/en/) which is widely used for website development and mobile application development.
## 16. [SitePoint](http://www.sitepoint.com/)
This is another highly useful [blog](http://www.sitepoint.com/) if you want quality material related to different programming languages.
SitePoint contains well-detailed information on all such topics that could aid your programming journey.
## 17. [After Hours Programming]((http://www.afterhoursprogramming.com/))
[After Hours Programming](http://www.afterhoursprogramming.com/) has been around for the past few years and has lots of different tutorials for learning the basic concepts of Python, PHP, and much more.
## 18. [CodeEasy](https://codeasy.net/)
Codeasy is probably the newest one from the whole list. It is quite an interesting educational course because it drives a new concept in computer science.
You start learning thereby **reading an adventure story** about fighting machines in the future. On your way, you’ll meet challenges that require real coding to solve.
The final goal is to save the world from machine invasion. And as a very important side effect – becoming a software developer.
## 19. [Code Avengers](https://www.codeavengers.com/)
Code Avengers is aimed at kids from 5 to 14 and gives them a fun and interactive programming learning environment.
It’s also a great resource for school teachers who want to help their students code.
Because its target is at a younger age group it makes it ideal for adults to understand also who aren’t that tech-minded.
## 20. [MIT Open Courseware](https://ocw.mit.edu/)
If you’ve already learned the basics, and want to get into something a bit heavier -- such as exploring the theory behind coding -- you can take advantage of [MIT’s free courseware site (https://ocw.mit.edu/), which includes classes such as Introduction to Computer Science and Programming in Python, and language-specific courses like Java, MatLab and C, and C++.
## 21. [Github](https://github.com/EbookFoundation/free-programming-books/)
Sometimes, you need to recall a reference book when you’re stuck on a problem. That's [GitHub](https://github.com/EbookFoundation/free-programming-books/), where the site says, over 31 million developers collaborate to host and review code, manage projects, and build [software together](https://github.com/freeCodeCamp/freeCodeCamp).
## 22. [Hackr.io](https://hackr.io/)
This isn't a learn-to-code platform itself, but it's a great list of community-curated programming resources.
Simply search for the language you want to learn and you’ll get a list of the best online courses, tutorials, and books recommended by coders.
## 23. [W3Schools](https://www.w3schools.com/)
Perfect for beginner coders, W3Schools is the world’s largest web developer site, offering free coding tutorials and reference materials for learning just about every aspect of web programming.
What free coding tutorials they offer: **HTML, CSS, JavaScript, SQL, PHP, jQuery, and more**
## 24. [CoderByte](https://coderbyte.com/)
Learn to code by doing it! Coderbyte teaches you the basics of popular programming languages and lets you build up your new skills using their library of 300+ coding challenges and solutions.
## 25. [Microsoft Virtual Academy](https://mva.microsoft.com/)
Microsoft Virtual Academy’s Learning Paths are curated free coding courses designed to help you build valuable skills through video tutorials, demos, assessments, and more.
You’ll also get access to free e-books, helpful downloads, and a community support forum.
## 26. [Edabit](https://edabit.com/)
Edabit is “like **Duolingo for learning to code**,” offering bite-sized coding challenges that simulate what programming is like in the real world.
## 27. [Launch School Open Book Shelf](https://learntocodewith.me/launch-school-books)
Written to supplement Launch School’s software engineering curriculum, these free coding books will help you learn the basic foundational building blocks of popular languages.
## 28. [CodeGym](https://codegym.cc/)
This learn-to-code resource focuses on online Java programming courses that are 80% based on practice.
You’ll start writing code almost immediately once you begin the lessons, completing 1200+ programming tasks, and getting immediate results for your solutions.
## 29. [Sololearn](https://www.sololearn.com/)
While this platform offers advanced and intermediate courses, it doesn't offer in-depth programming skills. Because of this, Sololearn is an excellent place to start your development learning journey
## 30. [Educative.io](https://www.educative.io/)
Leading online learning platform made by developers, created for developers. Free Trial. Text-based courses with embedded coding environments help you learn without the fluff. In-browser exercises. No setup is required. Free Sign-Up. Learn at your own pace.
## 31. [GeeksforGeeks](https://practice.geeksforgeeks.org/)
A Computer Science portal for geeks. It contains well-written, well thought and well-explained computer science and programming articles
## 32. [Javatpoint](https://www.javatpoint.com/)
Tutorials, Free Online Tutorials, Javatpoint provides tutorials and interview questions of all technology like java tutorial, android, java frameworks, ...
## 33. [Tutorialspoint](https://www.tutorialspoint.com/)
Tutorials Point is a leading Ed-Tech company striving to provide the best learning material on technical and non-technical subjects.
## 34. [CodeChef](https://www.codechef.com/)
CodeChef is an online educational platform and competitive programming community of global programmers. CodeChef started as an educational initiative in 2009 by Directi, an Indian software company. In 2020, it became owned by Unacademy.
- [Wikipedia](https://en.wikipedia.org/wiki/CodeChef)
## 35. [HackerRank](https://www.hackerrank.com/)
HackerRank is the market-leading technical assessment and remote interview solution for hiring developers. Start hiring at the pace of innovation!
## 36. [LeetCode](https://leetcode.com/)
LeetCode is the best platform to help you enhance your skills, expand your knowledge, and prepare for technical interviews.
## 37. [HackerEarth ](https://www.hackerearth.com/)
HackerEarth is an Indian software company headquartered in San Francisco, US, that provides enterprise software that assists organizations with technical hiring. HackerEarth is used by organizations for technical skill assessments and remote video interviewing.
- [Wikipedia](https://en.wikipedia.org/wiki/HackerEarth)
## 38. [Codeforces](https://codeforces.com/)
Codeforces is a website that hosts competitive programming contests. It is maintained by a group of competitive programmers from ITMO University led by Mikhail Mirzayanov. Since 2013, Codeforces claims to surpass Topcoder in terms of active contestants. As of 2018, it has over 600,000 registered users.
- [Wikipedia](https://en.wikipedia.org/wiki/Codeforces)
## 39. [Topcoder](https://www.topcoder.com/)
Topcoder is a crowdsourcing company with an open global community of designers, developers, data scientists, and competitive programmers. Topcoder pays community members for their work on the projects and sells community services to corporate, mid-size, and small-business clients.
- [Wikipedia](https://en.wikipedia.org/wiki/Topcoder)
## 40. [Kaggle](http://www.kaggle.com/)
Kaggle, a subsidiary of Google LLC, is an online community of data scientists and machine learning practitioners.
- [Wikipedia](https://en.wikipedia.org/wiki/Kaggle)
## 41. [Coding Ninjas](https://www.codingninjas.com/)
Coding Ninjas is a place that trains passionate people in various technologies. Our core programs are intensive, immersive training that transforms people into outstanding developers. The training is provided by expert faculties who have graduated from esteemed Universities such as Stanford, IITs, and IITs. They have valuable teaching experience and extensive knowledge which they share with students to guide them in becoming a great programmer or a developer.
## 42. [DataCamp](http://www.datacamp.com/)
Meet DataCamp, the first online learning platform that focuses on building the best learning experience specifically for Data Science.
## 43. [Programiz](https://www.programiz.com/)
Learn to code in Python, C/C++, Java, and other popular programming languages with our easy-to-follow tutorials, examples, online compilers, and references.
## 44. [Guru99](https://www.guru99.com/)
Guru99 is a provider of education software. It offers selenium web driver tutorials, ethical hacking, cloud computing, compiler design, embedded systems, and other courses.
# Additional
One of the best sources of tutorials is **YouTube** – it offers an abundance of channels aimed at those who want to learn about coding.
However, not all of these programming channels are created equal. Some are excellent for beginners and full of useful tips and tricks while others may not be quite as valuable.
Below I have added some top 10 resources and recommended by Top Industry Expert.
## 1. [Programmin Knowledge](https://goo.gl/rYLwrS)
Here you will find a variety of videos aimed at new programmers. The tutorials here range from an Android tutorial for beginners to Java, Python, and C++ tutorials.
Among the resources is a C programming tutorial that is considered the most comprehensive course in that language that you will find anywhere.
## 2. [TreeHouse](https://goo.gl/ti7FUL)
Team Treehouse is a learning resource established with the mission of providing affordable education in technology.
Teamtreehouse offers lessons on numerous topics including coding in Python and C#.
## 3. [DevTips](https://goo.gl/oBjoh8)
DevTips will be of interest to you if you are a web designer who wants to improve your skills and if you need to learn more about coding CSS, HTML5, and other relevant topics.
## 4. [Mike Locke](https://goo.gl/7woxQk)
Mike Locke is an instructor and designer with over 17 years of experience. He specializes in front-end development (XHTML and CSS) among other areas.
On YouTube, he offers a range of tutorials on topics like Adobe Illustrator as well as UX design.
## 5. [Learncode Aacademy](https://goo.gl/wQqBOH)
Will Stern’s clear and simple tutorials are focused on programming as it relates to web development.
At Learncode. academy, you will be walked through topics like JavaScript and jQuery in Stern’s efficient and thorough style.
## 6. [Derek Banas](https://goo.gl/5to7EY)
Banas is the creator of the hugely popular Learn JavaScript in 30 Minutes playlist. As the title of that playlist implies, Banas specializes in compact lessons for fast learning.
Among the content, you will find videos like Learn the Ruby Programming Language in One Video.
## 7. [TheNewBoston](https://goo.gl/cRjU6F)
On thenewboston, you will find more than 4,200 videos that are followed by over a million subscribers. The NewBoston is arguably the single best resource for anyone who wants to become a software developer.
The tutorials cover a range of different programming topics including developing for android and design.
### Resources
1. [Places to learn code for free in 2023](https://makeawebsitehub.com/learn-to-code-for-free/)
2. [12 Sites That Will Teach You Coding at a Low Cost, Even Free](https://www.entrepreneur.com/article/250323)
3. [Best Places to code for free](https://learntocodewith.me/posts/code-for-free/)
4. [Free Youtube Resources(English)](https://ayokasystems.com/news/top-10-youtube-channels-to-learn-programming/)
5. [Best free YouTube Channels to Learn Programming in Hindi.](https://www.blogstek.com/2021/06/6-best-hindi-youtube-channels-to-learn-programming.html)
## Instructions
1). Fork this repository <br>
2). Clone the forked repository <br>
3). Add your contributions (code or documentation) <br>
4). Commit and push <br>
5). Wait for the pull request to be merged <br>
## Creator [🔝](# best-free-sites-to-learn-code)
(https://github.com/hegdepavankumar). This Project is Created by:-
| [<img src="https://github.com/hegdepavankumar.png?size=115" width="115"><br><sub>@hegdepavankumar</sub>](https://github.com/hegdepavankumar) |
<br>
<h3 align="center">Show some ❤️ by starring some of the repositories!</h3>
<br>
<!-- Support Me -->
if you like what I do, maybe consider buying me a coffee 🥺👉👈
<a href="https://www.buymeacoffee.com/hegdepavankumar" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-red.png" alt="Buy Me A Coffee" width="150" ></a>
| The objective of this blog is to reveal the features offered by each of the free code learning resources to encourage you to start coding on your own. | coding,codingplatform,learn-to-code,programming,websites,websites-programming,computer-science,curriculum,javascript,python | 2023-04-08T14:20:57Z | 2024-01-26T04:56:36Z | null | 1 | 4 | 34 | 0 | 3 | 4 | null | Apache-2.0 | null |
cokitoki/portfolio-website | main | # Portfolio Website
This is a personal portfolio website built using HTML, CSS, and JavaScript. The website showcases my skills, projects, and contact information.
## Prerequisites
- A web browser such as Chrome, Firefox, or Safari.
## Installation and Demo
1. Clone the repository: `git clone https://github.com/cokitoki/portfolio-website.git`
2. Open the `index.html` file in your web browser.
Alternatively, you can view the live version of the website at [https://cokitoki.github.io/portfolio-website/](https://cokitoki.github.io/portfolio-website/).
## Usage
The website contains the following sections:
- Home: A brief introduction and welcome message.
- About: Information about my skills, education, and work experience.
- Projects: A showcase of my projects with links to their GitHub repositories and live versions (if available).
- Contact: A form for users to send me a message.
## Contributing
Contributions are welcome! Please follow these guidelines:
1. Fork the repository.
2. Create a branch: `git checkout -b your-feature`
3. Make your changes and commit them: `git commit -m 'Add your feature'`
4. Push to the branch: `git push origin your-feature`
5. Create a pull request.
## License
This project is licensed under the [MIT License](https://github.com/cokitoki/portfolio-website/blob/main/LICENSE).
## Acknowledgements
- The website design is based on [Start Bootstrap's Freelancer theme](https://startbootstrap.com/theme/freelancer).
- The form submission is powered by [Formspree](https://formspree.io/).
## Contact
Feel free to contact me at `mateo_telleria@yahoo.com` if you have any questions or feedback.
| Source code for my personal portfolio website, built with HTML, CSS, and JavaScript. Features a modern and minimalist design, showcasing my skills, projects, and work experience. Open-source and available for others to use as a template. | css,html5,javascript,open-source,portfolio,web-development | 2023-04-06T22:31:51Z | 2024-04-02T22:22:02Z | null | 2 | 0 | 15 | 0 | 1 | 4 | null | null | HTML |
daredevilevi/portfolios | master | null | Portfolio Website Created using HTML CSS JS by following tutorial of https://github.com/codewithsadee Youtube tutorial | css,css-flexbox,css-grid,css3,html,html-css,html-template,html5,javascript,js | 2023-04-02T15:36:27Z | 2023-04-02T15:44:25Z | null | 1 | 0 | 1 | 0 | 1 | 4 | null | null | HTML |
rahul241172/racial-squirrel-7776 | main | ### 
# [ChitChat](https://whatsapplikeclone.netlify.app/)
ChitChat.com is basic Chat application inspired from Whatsapp which provide private chat and group chat with other users.
# Tech Stack
Frontend-> HTML, CSS, JavaScript
Backend-> NodeJS, Express, Nodemon, Mongoose, Socket.io, dotenv, passport, passport-google-oauth20
DataBase-> MongoDB
# Features
Google OAuth Authentication
Status
Private Chat
Group Chat
[Admin Side](https://whatsapplikeclone.netlify.app/admin/adminpage.html)
# Features of Admin Side
Admin can see all the users and block the users as well
# HomePage
# Contact
# Status
# Admin
# How to use
Vistit on messagepage and click on your and for the other person do the same they can chat with each other.
# API Endpoints
### User Routes
- User Register :- /user/register
- Method : POST
- Body : name, email, password
- User Login :- /user/login
- Method : POST
- Body : email, password
### Admin Routes
- Get All Users :- /user/all
- Method : GET
- Get User by their ID :- /user/id (Pass ID in params)
- Method : GET
- Delete a User by their ID :- /user/id (Pass ID in params)
- Method : DELETE
| Whatsapp clone application which is basically used for private chat and group chat | css,express,html,javascript,mongodb,nodejs,oauth2,socket-io | 2023-03-28T05:51:15Z | 2023-05-15T07:00:45Z | null | 6 | 31 | 185 | 0 | 3 | 4 | null | null | HTML |
BIYUEHU/hulitool | master | # HULITOOL
[](https://wakatime.com/badge/user/018dc603-712a-4205-a226-d4c9ccd0d02b/project/018dd9da-bcec-4cc8-86fc-bb8b4cace75d)
该项目是本人的第一个 Vue + TypeScript + Vite + Pinia 项目实践，主要用于 Vue 练手。
- HULITOOL 完全为纯前端项目无后端（但用到了不少 [HotaruApi](https://api.hotaru.icu) 接口），因此网站部署于 GithubPages 服务
- 目前仅有少部分功能仍未实现，稍后也会时不时添加新功能具体查看 [TODO](./TODO.md)
- [更新日志](./CHANGELOG.md)
## 技术栈&依赖包
---
[vue](https://www.npmjs.com/package/vue) [vue-clipboard2](https://www.npmjs.com/package/vue-clipboard2) [vue-codemirror](https://www.npmjs.com/package/vue-codemirror) [vue-router](https://www.npmjs.com/package/vue-router) [axios](https://www.npmjs.com/package/axios) [codemirror](https://www.npmjs.com/package/codemirror) [crypto-js](https://www.npmjs.com/package/crypto-js) [js-base64](https://www.npmjs.com/package/js-base64) [js-beautify](https://www.npmjs.com/package/js-beautify) [mdui](https://www.npmjs.com/package/mdui) [pinia](https://www.npmjs.com/package/pinia) [pinia-plugin-persistedstate](https://www.npmjs.com/package/pinia-plugin-persistedstate) [png2icons](https://www.npmjs.com/package/png2icons) [qrcode.vue](https://www.npmjs.com/package/qrcode.vue) [ua-parser-js](https://www.npmjs.com/package/ua-parser-js) [file-saver](https://www.npmjs.com/package/file-saver) [dayjs](https://www.npmjs.com/package/dayjs) [element-plus](https://www.npmjs.com/package/element-plus)
## 关于
---
- 博客: [HotaruBlog](https://hotaru.icu)
| The Vue+TypeScript+Vite+Pinia project is mainly for practicing Vue framework development | axios,codemirror,javascript,js,mdui,pinia,tool,tools,ts,typescript | 2023-04-05T09:22:12Z | 2024-02-24T07:58:20Z | null | 1 | 0 | 26 | 0 | 0 | 4 | null | MIT | Vue |
IshaanShettigar/iDG10-GUI-Hackathon | master | null | Building an interactive GUI to help design subsea field layouts using JointJS with plain HTML,CSS and JS | diagram,javascript,joint,jointjs,css,html | 2023-03-27T06:01:42Z | 2023-11-05T04:45:23Z | 2023-06-29T17:57:57Z | 2 | 8 | 198 | 10 | 0 | 4 | null | null | JavaScript |
zunairkhan811/Awesome-booksES6-using-modules | main | <!-- TABLE OF CONTENTS -->
# 📗 Table of Contents
- [📖 About the Project](#about-project)
- [🛠 Built With](#built-with)
- [Tech Stack](#tech-stack)
- [Key Features](#key-features)
- [🚀 Live Demo](#live-demo)
- [💻 Getting Started](#getting-started)
- [Setup](#setup)
- [Prerequisites](#prerequisites)
- [Install](#install)
- [Usage](#usage)
- [Run tests](#run-tests)
- [Deployment](#triangular_flag_on_post-deployment)
- [👥 Authors](#authors)
- [🔭 Future Features](#future-features)
- [🤝 Contributing](#contributing)
- [⭐️ Show your support](#support)
- [🙏 Acknowledgements](#acknowledgements)
- [📝 License](#license)
<!-- PROJECT DESCRIPTION -->
# 📖 [Add-Books-javascript-Project] <a name="about-project"></a>
**[Add-Books-javascript-Project]** is a project of Adding and Removing Books from website using javascript Classes and using modules and libraries to showcase my javascript skills to employers.
## 🛠 Built With <a name="built-with"></a>
### Tech Stack <a name="tech-stack"></a>
This project has been made using html, css, and javascript according to project requirements.
<details>
<summary>Client</summary>
<ul>
<li><a href="https://html.com/">html.com</a></li>
<li><a href="https://www.w3.org/TR/html401/present/styles.html">w3.org</a></li>
</ul>
</details>
<!-- Features -->
### Key Features <a name="key-features"></a>
- **[Home_Page_is_Designed]**
- **[BooksList_Section_is_Designed_using_javascript]**
- **[BooksAdd_Section_is_Designed_using_javascript]**
- **[Contact_Section_is_Designed]**
- **[Module_Section_is_Added]**
- **[Luxon_Library_is_Added]**
- **[Javascript_classes_has_been_used]**
- **[Responsive_version_is_Made]**
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- LIVE DEMO -->
## 🚀 Live Demo <a name="live-demo"></a>
- [Live Demo Link] <a href="https://zunairkhan811.github.io/Awesome-booksES6-using-modules/#"><button type="button" color:red background: white>Visit Site</button></a>
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- GETTING STARTED -->
## 💻 Getting Started <a name="getting-started"></a>
A new developer could make use of this project by cloning the repository and could make adjustments
in the code accordingly.
To get a local copy up and running, follow these steps.
### Prerequisites
In order to run this project you need:
1- Install Visual Studio Code<br>
2- Install Live server Extension in Visual studio code
### Setup
Clone this repository to your desired folder:
Example commands:
```sh
cd my-folder
git clone git@github.com:/zunairkhan811/Add-books-javascript-Project.git
```
### Install
Install this project with:
--> Visual Studio Code
### Usage
To run the project, execute the following command:
--> Click on live Link or Click on live server in Vs Studio.
### Run tests
To run tests, run the following command:
<!--
In order to run for linter errors, you will have to create a pull request
--->
### Deployment
You can deploy this project using:
--> By purchasing domain and hosting
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- AUTHOR -->
## 👥 Author <a name="author"></a>
👤 **Author**
- GitHub: [@zunairkhan811](https://github.com/zunairkhan811)
- Twitter: [@zunairkhan811](https://twitter.com/zunairkhan811)
- LinkedIn: [zunairkhan811](https://linkedin.com/in/zunairkhan811)
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- FUTURE FEATURES -->
## 🔭 Future Features <a name="future-features"></a>
- [ ] **[Will_try_update_html_file]**
- [ ] **[Will_try_to_update_css_file]**
- [ ] **[will_try_to_update_javascript_file]**
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- CONTRIBUTING -->
## 🤝 Contributing <a name="contributing"></a>
Contributions, issues, and feature requests are welcome!
Feel free to check the [issues page](../../issues/).
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- SUPPORT -->
## ⭐️ Show your support <a name="support"></a>
If you like this project kindly follow us and give rating by clicking on star button to this repository.
Thanks!
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- ACKNOWLEDGEMENTS -->
## 🙏 Acknowledgments <a name="acknowledgements"></a>
I would like to give credit to Microverse for inspiring me enough to make this project.
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- LICENSE -->
## 📝 License <a name="license"></a>
This project is [MIT](./license.md) licensed.
<p align="right">(<a href="#readme-top">back to top</a>)</p>
| Hi! In this project Book lovers can keep a record of their books in their browser. | css,html,javascript | 2023-03-27T08:00:10Z | 2023-03-28T07:59:06Z | null | 1 | 1 | 17 | 0 | 0 | 4 | null | MIT | JavaScript |
daredevilevi/Dev-Detective-Project | master | null | Dev Detective Project Created by following @loveBabbar Bhaiya's Codehelp Dot Batch MERN STACK COURSE | app,development,github,html,html-css,html-css-javascript,html5,javascript,js,project | 2023-04-01T16:47:33Z | 2023-04-01T16:48:19Z | null | 1 | 0 | 1 | 0 | 0 | 4 | null | null | CSS |
AaronFabian/orange-juice | main | # Orange Juice
A simple anime streaming website, built with react.js and laravel. Aiming for every user and user experience.
## Techologies
- Axios
- HTML
- CSS
- JavaScript
- Inertia.js
- Laravel
- MySQL
- React.js
- React Icons
- React Hot Toast
- PHP
- Tailwind.css
- Video.js
- Vite
## Link Website
https://ice-chocolate.com
## Screenshot
| Main Page |
| --------------------------------------- |
|  |
| Login Page |
| ------------------------------------ |
|  |
| Register Page |
| ---------------------------------------- |
|  |
| Streaming Page |
| ------------------------------------- |
|  |
| Streaming Page (comment section) |
| ------------------------------------ |
|  |
| Favorite Page |
| --------------------------------------- |
|  |
## Installation
Clone and move to the repository
# important
don't forget to setup your mysql and .env
```bash
git clone https://github.com/AaronFabian/orange-juice.git;
cd orange-juice;
```
# install packages
```bash
composer install;
npm i;
```
# create the database
```bash
php artisan migrate:fresh;
```
# run the server
backend
```bash
php artisan serve;
```
frontend
```bash
npm run dev;
```
| Simple anime streaming website | anime,inertiajs,laravel,streaming-video,javascript,php,tailwindcss,reactjs,videojs | 2023-03-29T05:44:31Z | 2024-02-15T06:16:19Z | null | 2 | 0 | 51 | 0 | 0 | 4 | null | null | JavaScript |
DonGuillotine/django-3js-game | main | A Number Guessing game with Python and Three JS
===========================================
Welcome to my Number Guessing Game built using the Django Framework. This game randomly chooses a number between 0 and 999 and allows the user to make guesses until they guess the correct number. With each incorrect guess, the program gives a hint whether the number is greater or smaller than the guessed number.
How to Play
-----------
- Clone the repository to your local machine using the command: `git clone https://github.com/your_username/number-guessing-game-django.git`
- Install the required packages by running the following command: `pip install -r requirements.txt`
- Start the Django server by running the following command: `python manage.py runserver`
- Open your web browser and go to `http://localhost:8000/` to play the game.
User Interface
--------------
The user interface was built using Three.js, a lightweight and easy-to-use 3D library.
Technologies Used
-----------------
- Django Framework
- Three.js
- HTML
- CSS
- JavaScript
Contributions
-------------
Contributions to this project are always welcome. If you find a bug or have a feature request, please open an issue on the repository.
| I Built a Number Guessing Game with the Django Framework! | django,javascript,python,threejs | 2023-03-27T13:26:06Z | 2023-05-09T22:42:01Z | null | 1 | 0 | 109 | 0 | 0 | 4 | null | null | Python |
zendrael/create_pas2js_app | main | # Pas2JS Template/Boilerplate
## Step 1: Download pas2js
- https://getpas2js.freepascal.org/
Current build __3.0.1__.
## Step 2: Prepare your environment
### On Windows
- Unpack zip on __Downloads__ folder and keep the folder name
- At the time of this version, the folder should be named ```pas2js-windows-23.0.1```
### On Linux (or Windows WSL or ChromeOS Linux container)
- Unpack zip on __Downloads__ folder and keep the folder name
- At the time of this version, the folder should be named ```pas2js-linux-x86_64-3.0.1```
### On macOS
- Unpack zip on __Downloads__ folder and keep the folder name
- At the time of this version, the folder should be named ```pas2js-macos-3.0.1```
## Step 3: Clone this repo
- Clone this repo or just download it, you can change the folder name after you downloaded
## Step 4: Open project folder on VScode
- open project folder with VSCode
- open the terminal inside VSCode
- __on Windows__ compile dev with ```scripts\buildDev.ps1``` (you must have rights to execute PoweShell scripts)
- __on Linux or macOS__ compile dev with ```./scripts/buildDev.sh```
- access dev project in your browser on address ```http://localhost:8080```
- __check your browser console to see if the project works__
- CTRL+C on VScode terminal to stop the server
## Building a release
- open terminal inside VScode
- __on Windows__ compile with ```.\scripts\buildDist.ps1```
- __on Linux or macOS__ compile with ```./scripts/buildDist.sh```
- access project on ```dist``` folder and upload to your server
## Dependencies
- In order to start the local webserver called by the dev script, __on Linux or macOS__, you must have Python installed on your machine
| Pas2JS project template for creating frontend, backend and games with Free Pascal transpiler to JavaScript | html5,javascript,objectpascal,pas2js,pascal,template,transpiler,webdevelopment | 2023-03-27T13:27:30Z | 2024-05-23T16:12:50Z | null | 1 | 0 | 32 | 0 | 2 | 4 | null | null | Shell |
Gaurav1745/chat-gpt-clone | main | # MernStack AI-chatbot
## A chatbot inspired by chatGPT , but with improved features.
<br>
Some features of the AI-chatbot are:
<br>
- Paragraph generator
- <br>
- Chatgpt<br>
- Sci-fi image generator <br>
- javascript convertor <br>
## Demo of the project :)
<br>
# Screenshot of how the web application looks
<br>
<br>
<br>
| null | reactjs,javascript,mongodb,nodejs | 2023-03-29T21:36:20Z | 2023-07-12T02:44:45Z | null | 1 | 0 | 75 | 0 | 0 | 4 | null | null | JavaScript |
Todd-Owen-Mpeli/DBMX-Racing | main | ## Project Description
1. All images are in 4K resolution, click to enlarge for better viewing.
<img src="public/img/screenshots/DBMX-Racing-Motocross-Accessories-Parts.jpg" width="1080px" height="550px">
<img src="public/img/screenshots/DBMX-Racing-Motocross-Accessories-Parts (5).jpg" width="1080px" height="550px">
# Project Context
This is a Next.js 13 project website I've built for a Motocross accessories and parts local business. A Typescript based project using nextjs 13 static side rendering. This projects is developed solely with Next.js 13 - featuring, Typescript, Javascript, React 18, Tailwind, and a Headless Wordpress CMS API
1. Develop a website using Next.js framework.
2. Show my ability to develope a headless-CMS, jamstack, Server Side Rendering & Firebase backend web application.
# My Objective
To further learn Firebase backen, fire cloud storage and Next.js 13 framework.
# Deployment
Deployed with vercel here:
a). https://dbmx-racing.vercel.app/
# Image Galley
<img src="public/img/screenshots/DBMX-Racing-Motocross-Accessories-Parts.jpg" width="1080px" height="550px">
<img src="public/img/screenshots/DBMX-Racing-Motocross-Accessories-Parts (2).jpg" width="1080px" height="550px">
<img src="public/img/screenshots/DBMX-Racing-Motocross-Accessories-Parts (3).jpg" width="1080px" height="550px">
<img src="public/img/screenshots/DBMX-Racing-Motocross-Accessories-Parts (4).jpg" width="1080px" height="550px">
<img src="public/img/screenshots/DBMX-Racing-Motocross-Accessories-Parts (5).jpg" width="1080px" height="550px">
<img src="public/img/screenshots/DBMX-Racing-Motocross-Accessories-Parts (6).jpg" width="1080px" height="850px">
<img src="public/img/screenshots/DBMX-Racing-Motocross-Accessories-Parts (7).jpg" width="1080px" height="850px">
| This is a Next.js 13 project website I've built for a Motocross accessories and parts local business. A Typescript based project using nextjs 13 static side rendering. This projects is developed solely with Next.js 13 - featuring, Typescript, Javascript, React 18, Tailwind, and a Headless Wordpress CMS API | apollo-client,apollographql,cms-backend,css3,framer-motion,git,github,graphql,headless-cms,html5 | 2023-03-31T20:06:01Z | 2023-11-02T15:36:17Z | null | 1 | 0 | 110 | 0 | 0 | 4 | null | null | TypeScript |
broxus/locklift-deploy | master | # Locklift-deploy
<p align="center">
<a href="https://github.com/venom-blockchain/developer-program">
<img src="https://raw.githubusercontent.com/venom-blockchain/developer-program/main/vf-dev-program.png" alt="Logo" width="366.8" height="146.4">
</a>
</p>
<p align="center">
<p align="center">
<a href="/LICENSE">
<img alt="GitHub" src="https://img.shields.io/badge/license-Apache--2.0-orange" />
</a>
<a href="https://www.npmjs.com/package/@broxus/locklift-deploy">
<img alt="npm" src="https://img.shields.io/npm/v/@broxus/locklift-deploy">
</a>
</p>
</p>
[Locklift](https://github.com/broxus/locklift) plugin for deployments management and better testing.
- [Installation](#installation)
- [Quickstart](#quickstart)
- [Configuration](#configuration)
- [**Extra locklift.config networks' options**](#extra-lockliftconfig-networks-options)
- [`deploy`](#deploy)
- [How to Deploy Contracts](#how-to-deploy-accounts)
- [The `deploy` command](#the-deploy-command)
- [**Options**](#options)
- [Deploy scripts](#deploy-scripts)
- [Deploying contracts](#deploying-contracts)
- [Deploying accounts](#deploying-accounts)
- [Saving external contracts to deployments](#saving-external-contracts-to-deployments)
- [Testing Deployed Contracts](#testing-deployed-contracts)
- [Tags and Dependencies](#tags-and-dependencies)
### Installation
```bash
npm i @broxus/locklift-deploy
```
And add the following statement to your `locklift.config.ts`:
```typescript
import "@broxus/locklift-deploy";
import { Deployments } from "@broxus/locklift-deploy";
declare module "locklift" {
//@ts-ignore
export interface Locklift {
deployments: Deployments<FactorySource>;
}
}
```
### Quickstart
Before going into the details, let's look at the very basic functionality of **locklift-deploy.**
**locklift-deploy** allows you to write [`deploy scripts`](#deploy-scripts) in the `deploy` folder. Each of these files that look as follows will be executed in turn when you execute the following task: `locklift -n <networkName> deploy`
```typescript
// deploy/00-deploy-sample.ts
export default async () => {
const signer = await locklift.keystore.getSigner('0');
await locklift.deployments.deploy({
deployConfig: {
contract: "Sample",
publicKey: signer.publicKey,
initParams: { _nonce: locklift.utils.getRandomNonce() },
constructorParams: { _state: 123 },
value: locklift.utils.toNano(2)
},
deploymentName: "Sample1",// user-defined custom name
},
true // enable logs
);
};
export const tag = "sample1";
```
Furthermore you can also ensure these scripts are executed in test too by calling `await deployments.fixture({include: ['sample1']})` in your test.
This is a huge benefit for testing since you are not required to replicate the deployment procedure in your tests. The tag feature (as seen in the script above) and [dependencies](#tags-and-dependencies) will also make your life easier when writing complex deployment procedures.
You can even group deploy scripts in different sub folder and ensure they are executed in their logical order.
Furthermore locklift-deploy can also support a multi-chain settings with multiple deploy folder specific to each network.
### Configuration
#### Extra locklift.config networks' options
##### deploy
The deploy field override the deploy option and let you define a set of sub-folders containing the deploy scripts to be executed for exact network.
You can thus have one network that will be executing mainnet deployment and other networks deployments, etc.
You could also have a folder that deploy contracts that are live on mainnet but that you need to replicate for your test or local network.
```bash
{
networks: {
local: {
deploy: [ 'common/', 'deploy-local/']
},
test: {
deploy: ['common/', 'deploy-test/']
},
main: {
deploy: [ 'deploy-main/' ]
}
}
}
```
In this case, the project structure might look like this:
```
///
deploy
├── deploy-local
│ └── local-migration-1.ts
│ └── local-migration-2.ts
├── common
│ └── common-migration.ts
├── deploy-test
│ └── test-migration.ts
└── deploy-main
└── main-migration.ts
```
### How to Deploy Contracts
#### The `deploy` command
`locklift deploy --network <networkName> [options and flags]`
This is a new task that the `locklift-deploy` adds. As the name suggests it deploys contracts. To be exact it will look for files in the folder `deploy` or whatever was configured in `networks.<networkName>.deploy`, see [config](#deploy).
It will scan for files in alphabetical order and execute them in turn.
##### Options
`--tags <tags>`: only execute deploy scripts with the given tags (separated by whitespaces) and their dependencies (see more info [here](#tags-and-dependecies) about tags and dependencies)
#### Deploy scripts
The deploy scripts need to be of the following type :
```typescript
export default async () => {
// out deployment code
};
export const tag = "sample1";
// optional
export const dependencies = ["sample2", "sample3", "sample4"];
```
The tags is a list of string that when the *deploy* command is executed with, the script will be executed. In other word if the deploy command is executed with a tag that does not belong to that script, that script will not be executed unless it is a dependency of a script that does get executed.
The dependencies is a list of tag that will be executed if that script is executed. So if the script is executed, every script whose tag match any of the dependencies will be executed first.
These set of fields allow more flexibility to organize the scripts. You are not limited to alphabetical order and you can even organise deploy script in sub folders.
#### Deploying and retrieving contracts
Contracts could be easily deployed and saved for further usage via `locklift.deployments.deploy` function:
```typescript
// deploy/00-deploy-sample.ts
...
const signer = (await locklift.keystore.getSigner('0'))!;
await locklift.deployments.deploy({
// We use same config for regular locklift factory deployments
deployConfig: {
contract: "Sample",
publicKey: signer.publicKey,
initParams: { _nonce: locklift.utils.getRandomNonce() },
constructorParams: { _state: 123 },
value: locklift.utils.toNano(2)
},
deploymentName: "Sample1",// user-defined custom name
},
true // enable logs
);
...
```
All deploy artifacts are saved to disk now, so that you can get instance of deployed contract via `deployments.getContract<ContractAbi>(deploymentName)` in any other script:
```typescript
// 01-use-sample.ts
...
const sample = locklift.deployments.getContract<SampleAbi>("Sample1");
...
```
#### Deploying and retrieving accounts
Accounts could be easily deployed and saved for further usage via `locklift.deployments.deployAccounts` function:
```typescript
// deploy/02-deploy-account.ts
...
// multiple accounts could be deployed at once
await locklift.deployments.deployAccounts([
{
deploymentName: "Deployer", // user-defined custom account name
signerId: "0", // locklift.keystore.getSigner("0") <- id for getting access to the signer
accountSettings: {
type: WalletTypes.EverWallet,
value: locklift.utils.toNano(2),
},
},
],
true // enableLogs
);
...
```
All deploy artifacts are saved to disk now, so that you can get instance of deployed account via `deployments.getAccount(deploymentName)` in any other script:
```typescript
// 03-use-account.ts
...
const deployer = locklift.deployments.getAccount("Deployer").account;
...
```
#### Saving external contracts to deployments
Sometimes we want to use contract that was deployed outside of our scripts or was deployed by internal message, for example through some kind of "factory" contract. In such a case we can use low-level method for manual saving deployment artifact:
```typescript
// save arbitrary contract
locklift.deployments.saveContract({
deploymentName: "FarmingPool_WEVER-USDT",
contractName: "FarmingPool",
address: SOME_ADDRESS
});
// save account
locklift.deployments.saveAccount({
deploymentName: "Owner",
signerId: "0", // locklift.keystore.getSigner("0") <--
address: SOME_ADDRESS,
accountSettings: {
type: WalletTypes.EverWallet,
// mSigType: "SafeMultisig/multisig2" for multisig types
}
});
```
### Testing Deployed Contracts
You can continue using the usual test command:
```
locklift test
```
Tests can use the `locklift.deployments.fixture(config?: { include?: Array<string>; exclude?: Array<string> })` function to run the deployment. You can also choose what tags you want/don't want to execute if you want.
Here is an example of a test:
```typescript
describe('Token', () => {
it('testing 1 2 3', async function () {
// execute only 'token-deploy' tag
await locklift.deployments.fixture({include: ['token-deploy']});
const token = await locklift.deployments.getContract<TokenAbi>('Token'); // Token is available because the fixture was executed
console.log(token.address);
});
it('testing 4 5 6', async function () {
// execute all tags except 'token-deploy'
await locklift.deployments.fixture({exclude: ['token-deploy']});
...
});
});
```
### Tags and Dependencies
It is possible to execute only specific parts of the deployments with `locklift deploy --tags <tags>`
Tags represent what the deploy script acts on. In general it will be a single string value, the name of the contract it deploys or modifies.
Then if another deploy script has such tag as a dependency, then when this latter deploy script has a specific tag and that tag is requested, the dependency will be executed first.
Here is an example of two deploy scripts :
```typescript
export default async () => {
await locklift.deployments.deployAccounts([
{
deploymentName: "Deployer",
signerId: "0",
accountSettings: {
type: WalletTypes.EverWallet,
value: toNano(10),
},
},
],
true // enableLogs
);
};
export const tag = "create-account";
```
```typescript
export default async () => {
const deployer = locklift.deployments.getAccount("Deployer").account;
await locklift.deployments.deploy({
deployConfig: {
contract: "Sample",
publicKey: deployer.signer.publicKey,
initParams: { _nonce: locklift.utils.getRandomNonce() },
constructorParams: { _state: 123 },
value: locklift.utils.toNano(2)
},
deploymentName: "Sample1",// user-defined custom name
},
true // enable logs
);
};
export const tag = "sample1";
// this ensure the 'create-account' script above is executed first, so `deployments.getAccount('Deployer')` succeeds
export const dependencies = ["create-account"];
```
As you can see the second one depends on the first. This is because the second script depends on a tag that the first script registers as using.
| Locklift plugin for replicable deployments and easy testing | blockchain,everscale,javascript,locklift,locklift-plugin,smart-contract-tools,smart-contracts,solidity,tvm,typescript | 2023-03-28T10:54:52Z | 2023-06-28T13:31:04Z | null | 12 | 1 | 32 | 5 | 2 | 4 | null | Apache-2.0 | TypeScript |
Mohamed20a/Media-Downloader | main | # MAG Downloader
<img align="center" width="80%" src="https://github.com/Mohamed20a/My-Portfolio/blob/main/assets/img/portfolio/down1.png">
## What is MAG Downloader?
Media Downloader
A MAG downloader is a site that can download videos, audios, and images from the four popular platforms {Facebook, Youtube, Instagram, Twitter} of different quality.
## 🚀 About Me
I'm Mohamed Ahmed Frontend web developer...
## 🕵️ Skills
Javascript, HTML, CSS, Bootstrap ...
## Desciption
A MAG downloader is Media Downloader that can download videos, audios, and images from the four popular platforms {Facebook, Youtube, Instagram, Twitter} of different quality.
## 🔗 Links
- [](https://www.linkedin.com/in/mohamed-ahmed-bb358b239/)
- [](https://mag-downloader.netlify.app/)
| Media Downloader A MAG downloader is a site that can download videos, audios, and images from the four popular platforms {Facebook, Youtube, Instagram, Twitter} of different quality. | api,bootstrap,css,facebook-api,html,instagram-api,javascript,twitter-api,video-downloader,youtube-api | 2023-04-06T19:22:07Z | 2023-04-06T19:38:39Z | null | 1 | 0 | 2 | 0 | 3 | 4 | null | null | HTML |
cmprkr/metagenie | main | # metagenie
## Demonstration
Click [here](https://vimeo.com/814458911) for a video demonstrating the bot creation script.
## Introduction
This file is a JavaScript file that uses the Puppeteer library to automate the creation of an Instagram account using a Guerrilla Mail email address, a random name, and a random username. The purpose of this script is to create a test Instagram account for automation testing.
## Dependencies
This script requires the following dependencies:
- [Node.js](https://nodejs.org/)
- [Puppeteer](https://pptr.dev/)
## Installation
1. Install Node.js on your machine.
2. Clone this repository or copy the code into a new JavaScript file.
3. Open a terminal in the directory containing the file and run the following command to install the Puppeteer library:
```npm install puppeteer```
## Usage
To use this script, run the following command in your terminal:
```node index.js```
The script will then launch a Chromium instance using Puppeteer and automate the creation of a new Instagram account. The email address, name, username, and password of the new account will be output to the console at the end of the script.
## Note
This script is for educational and testing purposes only. Please do not use it for any illegal or unethical purposes.
| Utilizes puppeteer to automate the creation of a random AI-operated instagram account in under 30 seconds. | bot,instagram,javascript,puppeteer,web-scraping | 2023-04-03T03:18:49Z | 2023-04-05T15:04:18Z | 2023-04-05T13:39:49Z | 1 | 0 | 20 | 0 | 0 | 4 | null | MIT | JavaScript |
PHPDevsr/minifyku | dev | [](https://github.com/PHPDevsr/minifyku/actions/workflows/test-phpunit.yml)
[](https://github.com/PHPDevsr/minifyku/actions/workflows/test-phpstan.yml)
[](https://coveralls.io/github/PHPDevsr/minifyku?branch=dev)
[](https://packagist.org/packages/phpdevsr/minifyku)
[](https://packagist.org/packages/phpdevsr/minifyku)
[](https://packagist.org/packages/phpdevsr/minifyku)
[](https://github.com/PHPDevsr/minifyku/blob/dev/LICENSE)
# What is Minifyku?
Minifyku is helper versioning and minification your assets with Codeigniter 4, Can be automatically use ```base_url()```.
# Installation
install with composer
```bash
$ composer require phpdevsr/minifyku
```
# Configuration
```bash
$ php spark minifyku:publish
```
This command will copy a config file to your app namespace. Then you can adjust it to your needs. By default, file will be present in ```app/Config/Minifyku.php```.
```php
public array $js = [
'all.min.js' => [
'bootstrap.js', 'jquery.js', 'main.js'
],
];
public array $css = [
'all.min.css' => [
'bootstrap.css', 'font-awesome.css', 'main.css'
],
];
```
This configuration will be minify and combine file ```bootstrap.js```,```jquery.js```,```main.js``` to ```all.min.js```. Or minify and combine file ```bootstrap.css```,```font-awesome.css```,```main.css``` to ```all.min.css```.
Since `v2.0.0`, new option `autoMinify` for you need automated minify when loaded using helper `minifyku()` and can be replaced by `.env` with `minifyku.autoMinify = true`. Please dont use in ***production***, it will take more time.
```php
public bool $autoMinify = false;
```
# Usage
Run command for minification your all assets:
```bash
$ php spark minifyku:minify
```
or you want minify JS/CSS files:
```bash
$ php spark minifyku:minify-js
```
```bash
$ php spark minifyku:minify-css
```
This will prepare everything and will set up a versioning. Make sure to load a minifier helper in your controller, by calling:
```php
helper('minifyku');
```
Now to generate a proper tag with desired file to load, you have to make a simple call in your code:
```php
minifyku('all.min.js');
```
or
```php
minifyku('all.min.css');
```
Helper will be produce:
```html
<script defer type="text/javascript" src="http://example.com/assets/js/all.min.js?v=bc3d0dc779f1a0b521b69ed3a2b85de8"></script>
```
or
```html
<link rel="stylesheet" href="http://localhost/assets/css/all.min.css?v=ec8d57dd8de143d7ef822a90fca20957">
```
# License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
# Contrib
We does accept and encourage contributions from the community in any shape. It doesn't matter whether you can code, write documentation, or help find bugs, all contributions are welcome.
<a href="https://github.com/PHPDevsr/minifyku/graphs/contributors">
<img src="https://contrib.rocks/image?repo=PHPDevsr/minifyku" />
</a>
Made with [contrib.rocks](https://contrib.rocks).
| Helper versioning and minification your assets in Codeigniter 4 | codeigniter-library,codeigniter4,css,javascript,minification,minifier,minify | 2023-03-30T04:17:25Z | 2024-03-18T01:13:51Z | 2024-02-14T08:49:30Z | 1 | 55 | 100 | 0 | 1 | 4 | null | MIT | PHP |
MussieTeka/JavaScript-Jest-Testing | main | <div align="center">
<img src="mussie.png" alt="Logo" width="300">
</div>
# JavaScript Jest Testing
## 📝 Description
- [Objectives](#objectives)
- [Exercise](#exercise)
- [Getting Started](#getting-started)
- [How to Use](#how-to-use)
- [Contributing](#contributing)
- [License](#license)
- [Resources](#resources)
This repository contains exercises and examples for practicing testing in JavaScript using the Jest library. It includes practical tests for JavaScript functions and examples of how to use the AAA pattern and TDD approach. The repository also has a calculator class with methods for addition, subtraction, multiplication, and division, and includes tests grouped by method using the describe() method.
## Objectives
- Write unit tests for a JavaScript app
- Use the AAA pattern for unit tests
- Explain why testing code is important
## Exercise
In this exercise, you will write practical tests for JavaScript functions using the Jest library. You should follow the AAA pattern to make your tests easier to read and understand. You will also use the TDD approach in practice.
### Task 1
Write a function `stringLength(string)` that takes any string as an argument and returns its character count. Add tests for the function and expand it to check if the string is at least 1 character long and not longer than 10 characters. Throw errors if those conditions are not met. Add tests for the new functionality.
### Task 2
Write a function `reverseString(string)` that takes a string as an argument and returns it reversed. Add at least one test for this function.
### Task 3
Write a simple calculator class or object that has four methods: `add`, `subtract`, `divide`, and `multiply`. Write at least three tests for each of the calculator methods and group tests for each method using the `describe()` method.
### Task 4
Write a test for a `capitalize(string)` function that takes a string as an argument and returns that string with the first character capitalized. Make your tests green by implementing the function.
## Getting Started
To get started, clone this repository to your local machine and run `npm install` to install the necessary dependencies. Then, you can run `npm test` to run the test suite.
## 🔧 How to Use
Each exercise is located in its own file in the `exercises` directory. To practice a particular exercise, open the corresponding file and write your tests following the instructions in the file. The `calculator.js` file contains the calculator class and its methods for addition, subtraction, multiplication, and division.
## 🤝 Contributing
Contributions, issues, and feature requests are welcome! Feel free to check out the [issues page](https://github.com/MussieTeka/JavaScript-Jest-Testing/issues).
## 📝 License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
## Resources
- [Jest Documentation](https://jestjs.io/)
- [JavaScript Testing Best Practices](https://github.com/goldbergyoni/javascript-testing-best-practices)
| This repository for JavaScript testing with Jest library. Contains exercises to write and group tests for various functions, including implementing TDD approach. | javascript,testing | 2023-04-05T04:31:59Z | 2023-04-05T13:23:56Z | null | 1 | 0 | 10 | 0 | 1 | 4 | null | MIT | JavaScript |
Sodolsky/Steam-Comments-Scrapper | master | # Steam-Comments-Scrapper
Steam Comments Scrapper
If you want a working version just rollback to my first commit
| Steam Comments Scrapper | javascript,puppeteer,steam | 2023-03-28T15:10:19Z | 2023-05-12T13:39:32Z | null | 1 | 0 | 8 | 0 | 0 | 4 | null | null | JavaScript |
Gabriel-Dee/SustainCo | main | # SustainCo
SustainCo is a web-based platform that promotes sustainable and resilient communities by providing resources and tools to individuals, organizations, and local governments. The platform features a user-friendly interface for browsing information on green spaces, disaster preparedness training, and community events.Users can create profiles and interact with each other to share experiences and knowledge. SustainCo utilizes Google Maps API for location-based search and navigation. Built using React and Tailwind CSS, it offers a modern and responsive UI. The platform is open-source and welcomes contributions from developers and community members.
Visit us at: https://sustain-co.web.app
## To Run the Project, The available script are:
In the project directory, you can run:
### `npm install`
This is to install the neccesarry dependencies for the Application
### `npm i @react-google-maps/api`
This is to install the google maps api dependencies
### `npm i @reach/combobox`
This is to install the combobox dependencies
### `npm i react-router-dom`
This is to install the routing dependencies
### `npm i use-places-autocomplete`
This is to install the place locating dependencies.
### `npm start`
Runs the app in the development mode.\
Open [http://localhost:3000](http://localhost:3000) to view it in your browser.
| SustainCo is a web-based platform that promotes sustainable and resilient communities by providing resources and tools to individuals, organizations, and local governments. The platform features a user-friendly interface for browsing information on green spaces, disaster preparedness training, and community events. | css,javascript,maps,react,reactjs | 2023-03-29T08:25:13Z | 2023-04-30T08:42:49Z | null | 4 | 4 | 32 | 0 | 2 | 4 | null | null | JavaScript |
TeoSean00/Vendor_Form_Management_System_Frontend | master | # GoForm (Frontend)
## Youtube Demo of the Application
- [Youtube Link](https://youtu.be/mXnO4Y1JEVU)
## Backend Setup
- Ensure that the [Vendor_Form_Management_System_Backend](https://github.com/TeoSean00/Vendor_Form_Management_System_Backend) repository is up and running on your docker desktop concurrently as well
- Setup instructions in the README file <br/>
## Frontend Setup
```
npm install
```
### Compile and Hot-Reload for Development
```sh
npm run dev
```
### Compile and Minify for Production
```sh
npm run build
```
| A one-stop Vendor & Form Management System that provides CRUD features for vendors, forms & for the interactions between them, with other features such as a form page design & creation from scratch, an automated email reminder service, coupled with curated dashboards that highlight key, calculated business insights throughout the business process. | bootstrap,chartjs,dashboards,docker,form-management,java,javascript,maven,mvc-architecture,springboot | 2023-04-02T10:05:53Z | 2023-12-20T10:35:02Z | null | 1 | 0 | 554 | 0 | 1 | 4 | null | null | Vue |
sriramalavalapati3/Typo-Tales | main | # fabulous-vest-203
## Typo Tales
Typo Tales is a typing platform that allows users to take part in typing by creating groups with their friends and also practice alone. This project is a clone of TypoTales.com and was built within 5 days by a team of 4 members.
## Cloning of typeracer application
```
It is a collabrative project built by team of four members in 5 days.
This app allows users to enhance their typing skills and compitete among friends and family members and practice privetly real-time.
```
## Deployed Link
Frontend Link : https://cheerful-selkie-0b14c4.netlify.app/
<br/>
Backend Link : https://typotales-hchv.onrender.com/
## Features
Create groups with friends and compete against each other in real-time typing races
Practice typing alone with various typing exercises and improve your typing skills
View real-time progress of other users in your group during races
Leaderboards to view top performers in races and exercises
Authentication system to manage user accounts and sessions
Responsive design for optimal user experience on all devices
## Tech Stacks Used
<p align = "center">
<img src="https://github.com/PrinceCorwin/Useful-tech-icons/blob/main/images/HTML.png" alt="html" width="55" height="55"/>
<img src="https://user-images.githubusercontent.com/25181517/183898674-75a4a1b1-f960-4ea9-abcb-637170a00a75.png" alt="CSS" width="50" height="55"/>
<img src="https://user-images.githubusercontent.com/25181517/117447155-6a868a00-af3d-11eb-9cfe-245df15c9f3f.png" alt="js" width="50" height="50"/>
<img src="https://socket.io/images/logo.svg" alt="socket.io" width="50" height="50"/>
<img src="https://raw.githubusercontent.com/PrinceCorwin/Useful-tech-icons/main/images/nodejs.png" alt="nodejs" width="50" height="50"/>
<img src="https://res.cloudinary.com/kc-cloud/images/f_auto,q_auto/v1651772163/expressjslogo/expressjslogo.webp?_i=AA" alt="express" width="50" height="50"/>
<img src="https://raw.githubusercontent.com/PrinceCorwin/Useful-tech-icons/main/images/mongodb-leaf.png" alt="mongo" width="50" height="50"/>
<img src="https://user-images.githubusercontent.com/25181517/182884894-d3fa6ee0-f2b4-4960-9961-64740f533f2a.png" alt="redis" width="50" height="50"/>
<img src="https://user-images.githubusercontent.com/25181517/121401671-49102800-c959-11eb-9f6f-74d49a5e1774.png" alt="npm" width="50" height="50"/>
</p>
## NPM MODULES
```
{
"express": "^4.18.2",
"mongoose": "^7.0.3",
"nodemon": "^2.0.22",
"random-id": "^1.0.4",
"server": "^1.0.38",
"socket.io": "^4.6.1",
"dotenv": "^16.0.3",
REDIS
}
```
## NPM Packages
<p align = "center">
<img src="https://repository-images.githubusercontent.com/139898859/9617c480-81c2-11ea-94fc-322231ead1f0" alt="bcrypt.png" width="70" height="50"/>
<img src="https://github.com/faraz412/cozy-passenger-4798/blob/main/Frontend/Files/cors.png?raw=true" alt="cors" width="70" height="50"/>
<img src="https://github.com/faraz412/cozy-passenger-4798/blob/main/Frontend/Files/download.png?raw=true" alt="dotenv" width="60" height="50"/>
<img src="https://github.com/faraz412/cozy-passenger-4798/blob/main/Frontend/Files/JWT.png?raw=true" alt="jwt" width="70" height="50"/>
<img src="https://4008838.fs1.hubspotusercontent-na1.net/hubfs/4008838/mogoose-logo.png" alt="mongoose.png" width="70" height="70"/>
<img src="https://user-images.githubusercontent.com/13700/35731649-652807e8-080e-11e8-88fd-1b2f6d553b2d.png" alt="nodemon.png" width="50" height="50"/>
<img src="https://user-images.githubusercontent.com/25181517/182884894-d3fa6ee0-f2b4-4960-9961-64740f533f2a.png" alt="redis" width="50" height="50"/>
<img src="https://socket.io/images/logo.svg" alt="socket" width="70" height="50"/>
</p>
## Run Locally
### Clone this Project
```
https://github.com/sriramalavalapati3/fabulous-vest-203.git
```
### Install npm Packages
```javascript
npm i --global
```
### Go to Backend Folder
```
cd backend
cd index.js
```
### Run Server
```javascript
npm run server
```
```
### Runs the project in the development mode
[https://typotales-hchv.onrender.com](https://typotales-hchv.onrender.com)
```
### Environment Variables Required
`mongoURL`
`PORT`
`Redis Cloud Password + Host + Port`
`admin_tokenKey = adminToken`
`jwtnormalToken = yourToken`
`jwtrefreshToken = YourRefreshToken`
# Landing UI
# Game UI
# Register UI
# Login UI
<h1 align="center"><B>Authors<B></h1>
<div align="center">
<a align="center" href="https://github.com/sriramalavalapati3">Sriram Alavalapati</a> <br>
<a align="center" href="https://github.com/Ashik0101">Ashik Ansari</a><br>
<a align="center" href="https://github.com/vishalpadaswan3">Vishal Padaswan</a><br>
<a align="center" href="https://github.com/guptag0808">Saurabh Kumar Gupta</a><br>
</div>
| Typotales is a replica of typer racer website ,where you can sharpen your typing skills and you can play with your friends | bcrypt,css,html5,javascript,mongodb-atlas,nodejs,redis,socket-io,expressjs | 2023-03-27T14:00:46Z | 2023-06-05T19:05:41Z | null | 5 | 33 | 131 | 2 | 2 | 4 | null | null | CSS |
shivendra-somr/SastaVilla | main | # SastaVilla
## Description
SastaVilla is an e-commerce platform focused on promoting and selling various handmade, traditional, and ethnic products from different regions around the world. This project aims to create a web application that replicates the core features and functionalities of SastaVilla.
## Table of Contents
- [Description](#description)
- [Features](#features)
- [Installation](#installation)
- [Usage](#usage)
- [Technologies](#technologies)
- [Contributing](#contributing)
- [License](#license)
- [Contact](#contact)
## Features
- User registration and authentication
- Product browsing and filtering
- Product search functionality
- Product details page
- Shopping cart management
- Checkout and payment processing
- User profile and order history
## Installation
1. Clone the repository: `git clone https://github.com/shivendra-somr/SastaVilla.git`
2. Change into the project directory: `cd SastaVilla`
3. Install dependencies: `npm install`
## Usage
1. Run the development server: `npm start`
2. Open your web browser and navigate to: `http://localhost:3000`
## Technologies
- Front-end: HTML, CSS, JavaScript
- Hosting: Netlify
## Contributing
Contributions are welcome! If you find any issues or have suggestions, please feel free to create a pull request or submit an issue.
1. Fork the project
2. Create your feature branch: `git checkout -b feature/YourFeature`
3. Commit your changes: `git commit -m 'Add some feature'`
4. Push to the branch: `git push origin feature/YourFeature`
5. Open a pull request
## Contact
For any inquiries or questions, you can reach out to us via email at contact@craftsvilla.com.
---
| SastaVilla is an e-commerce platform focused on promoting and selling various handmade, traditional, and ethnic products from different regions around the world. This project aims to create a web application that replicates the core features and functionalities of SastaVilla. | css3,html5,javascript,netlify | 2023-03-28T11:54:50Z | 2023-09-13T03:40:50Z | null | 1 | 4 | 13 | 0 | 0 | 4 | null | null | HTML |
Anklet9/ASEN-Online-Shopping-Website | main | # ASEN Online Shopping Website
## Overview
Welcome to the ASEN Online Shopping Website repository! This project is an e-commerce website designed to offer a wide range of products, including both normal and luxury items. The website is built using HTML, CSS, and JavaScript to provide an interactive and user-friendly shopping experience.
You can access the deployed website here: [ASEN Online Shopping Website](https://polite-lily-0bd66e.netlify.app)
## Features
- Browse and search for a diverse selection of products.
- View detailed product descriptions, images, and prices.
- Add products to your shopping cart.
- Manage your shopping cart and update quantities.
- Proceed to the checkout process.
- Secure payment processing for a seamless shopping experience.
## Technologies Used
- **HTML**: Used for structuring the web pages.
- **CSS**: Responsible for styling and layout design.
- **JavaScript**: Implemented for interactivity and user experience enhancements.
## Getting Started
To run this project locally, follow these steps:
1. Clone the repository to your local machine:
2. Open the project directory in your code editor.
3. Launch a local development server or simply open the HTML file in your browser to start exploring the website.
## Usage
- Explore the website by navigating through product categories.
- Click on individual products to view their details.
- Add products to your shopping cart.
- Review the items in your cart and proceed to checkout.
- Complete the checkout process, including payment.
## Contributing
We welcome contributions from the community to enhance and improve the ASEN Online Shopping Website project. If you'd like to contribute, please follow these guidelines:
1. Fork the repository to your GitHub account.
2. Create a new branch for your feature or bug fix:
2. Open the project directory in your code editor.
3. Launch a local development server or simply open the HTML file in your browser to start exploring the website.
## Usage
- Explore the website by navigating through product categories.
- Click on individual products to view their details.
- Add products to your shopping cart.
- Review the items in your cart and proceed to checkout.
- Complete the checkout process, including payment.
## Contributing
We welcome contributions from the community to enhance and improve the ASEN Online Shopping Website project. If you'd like to contribute, please follow these guidelines:
1. Fork the repository to your GitHub account.
2. Create a new branch for your feature or bug fix:
3. Make your changes and commit them with clear and concise messages.
4. Push your changes to your forked repository:
5. Create a pull request to the main repository's `main` branch, describing your changes and their purpose.
## License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
## Acknowledgments
We would like to express our gratitude to the open-source community and the developers who contributed to the technologies and libraries used in this project.
---
Thank you for choosing ASEN Online Shopping Website! Happy shopping! 🛒🌟
| Welcome to ASEN Online Shopping – your destination for a diverse array of products, blending everyday necessities with luxury items. Experience seamless navigation and interactivity, all crafted with HTML, CSS, and JavaScript. Happy shopping! | css,html,javascript | 2023-03-28T16:07:38Z | 2023-09-12T11:21:48Z | null | 2 | 2 | 11 | 0 | 0 | 4 | null | null | HTML |
Investiway/investiway-front | master |
<p align="center">
<a href="https://investiway.vercel.app/">
<img width="1046" src="logo.png" alt="">
</a>
</p>
# @Investiway
##### Personal finance management.
## Description
**Investiway** is a web application that allows users to keep track of their monthly and weekly expenses, plan their spending for the next month, add new spending categories, and set monthly recurring expenses. The application also provides advice for spending based on user history and allows users to create notes with priorities.
## Technologies Used
* React: JavaScript library for building user interfaces
* Redux & Redux-toolkit: State management library
* Material-UI: React UI framework
* Tailwindcss: CSS framework packed with classes
* Highchartjs: JavaScript library for data visualization
* Firebase: Cloud-based database and authentication service
## Features
* View monthly and weekly expense statistics
* Plan spending for the next month
* Add new spending categories
* Set monthly recurring expenses
* Create notes with priorities
* Receive advice for spending based on user history
* View information on stock tickers
## Installation and Usage
1. Clone the repository
2. Install dependencies with npm install
3. Run the development server with **`npm run dev`** or **`yarn dev`**
4. Open the application in your web browser at http://localhost:3434
## Contributors
* Heyday Le (hugnthinh.ckc@gmail.com)
* Wawahuy (kakahuy99@gmail.com)
* lvthien0110 (lvthien0110@gmail.com)
## License
This project is licensed under the MIT License - see the LICENSE.md file for details.
| Personal finance management. Investiway is a web application that allows users to keep track of their monthly and weekly expenses, plan their spending for the next month, add new spending categories, and set monthly recurring expenses. | financial-analysis,management,javascript,react,reactjs,redux,typescript | 2023-03-27T05:50:06Z | 2023-04-24T14:00:50Z | null | 2 | 23 | 59 | 1 | 1 | 4 | null | MIT | TypeScript |
Kwaku28/To-do-list | main | <a name="readme-top"></a>
<div align="center">
<h3><b>To do list</b></h3>
</div>
<!-- TABLE OF CONTENTS -->
# 📗 Table of Contents
- [📗 Table of Contents](#-table-of-contents)
- [📖 \[Awesome Book\] ](#-awesome-book-)
- [🛠 Built With ](#-built-with-)
- [Tech Stack ](#tech-stack-)
- [Key Features ](#key-features-)
- [🚀 Live Demo ](#-live-demo-)
- [💻 Getting Started ](#-getting-started-)
- [Prerequisites](#prerequisites)
- [Setup](#setup)
- [Usage](#usage)
- [👥 Authors ](#-authors-)
- [🔭 Future Features ](#-future-features-)
- [🤝 Contributing ](#-contributing-)
- [⭐️ Show your support ](#️-show-your-support-)
- [🙏 Acknowledgments ](#-acknowledgments-)
- [📝 License ](#-license-)
<!-- PROJECT DESCRIPTION -->
# 📖 [To do list] <a name="about-project"></a>
**[To do list]** is a tool that helps to organize your day. It simply lists the things that you need to do and allows you to mark them as complete.
## 🛠 Built With <a name="built-with"></a>
### Tech Stack <a name="tech-stack"></a>
<details>
<summary>HTML</summary>
<ul>
<li><a href="https://en.wikipedia.org/wiki/HTML">HTML</a></li>
</ul>
</details>
<details>
<summary>CSS</summary>
<ul>
<li><a href="https://en.wikipedia.org/wiki/CSS">CSS</a></li>
</ul>
</details>
<details>
<summary>JavaScript</summary>
<ul>
<li><a href="https://en.wikipedia.org/wiki/JavaScript">JavaScript</a></li>
</ul>
</details>
<!-- Features -->
### Key Features <a name="key-features"></a>
- **[Add new items to list]**
- **[Check completed items]**
- **[Clear all completed items]**
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- LIVE DEMO -->
## 🚀 Live Demo <a name="live-demo"></a>
- [To-Do list](https://kwaku28.github.io/To-do-list/dist/)
<!-- GETTING STARTED -->
## 💻 Getting Started <a name="getting-started"></a>
To get a local copy up and running, follow these steps.
### Prerequisites
In order to run this project you need:
```sh
sudo apt install git-all
or
npm install
```
### Setup
Clone this repository to your desired folder:
```sh
cd my-folder
git clone https://github.com/Kwaku28/To-do-list.git
```
### Usage
To run the project, execute the following command:
```sh
Open index.html in browser
or
open with Live server in Vscode
```
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- AUTHORS -->
## 👥 Authors <a name="authors"></a>
👤 **Lawrence Amoafo**
- GitHub: [@Kwaku28](https://github.com/Kwaku28)
<!-- FUTURE FEATURES -->
## 🔭 Future Features <a name="future-features"></a>
- [ ] **[Rearrange lists]**
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- CONTRIBUTING -->
## 🤝 Contributing <a name="contributing"></a>
Contributions, issues, and feature requests are welcome!
Feel free to check the [issues page](https://github.com/Kwaku28/To-do-list/issues).
<!-- SUPPORT -->
## ⭐️ Show your support <a name="support"></a>
If you like this project show some love by commenting
<!-- ACKNOWLEDGEMENTS -->
## 🙏 Acknowledgments <a name="acknowledgements"></a>
I would like to thank Microverse staff for their support
<!-- LICENSE -->
## 📝 License <a name="license"></a>
This project is [MIT](https://github.com/Kwaku28/To-do-list/blob/main/LICENSE) licensed.
<p align="right">(<a href="#readme-top">back to top</a>)</p>
| "To-do list" is a tool that helps to organize your day. It simply lists the things that you need to do and allows you to mark them as complete. The website is built using ES6 and Webpack! | css,javascript | 2023-03-30T03:47:26Z | 2023-04-07T14:58:10Z | null | 2 | 7 | 38 | 0 | 0 | 4 | null | MIT | JavaScript |
Kwaku28/Awesome-book-ES6 | main | <a name="readme-top"></a>
<div align="center">
<h3><b>Awesome Book</b></h3>
</div>
<!-- TABLE OF CONTENTS -->
# 📗 Table of Contents
- [📗 Table of Contents](#-table-of-contents)
- [📖 \[Awesome Book\] ](#-awesome-book-)
- [🛠 Built With ](#-built-with-)
- [Tech Stack ](#tech-stack-)
- [Key Features ](#key-features-)
- [🚀 Live Demo ](#-live-demo-)
- [💻 Getting Started ](#-getting-started-)
- [Prerequisites](#prerequisites)
- [Setup](#setup)
- [Usage](#usage)
- [👥 Authors ](#-authors-)
- [🔭 Future Features ](#-future-features-)
- [🤝 Contributing ](#-contributing-)
- [⭐️ Show your support ](#️-show-your-support-)
- [🙏 Acknowledgments ](#-acknowledgments-)
- [📝 License ](#-license-)
<!-- PROJECT DESCRIPTION -->
# 📖 [Awesome Book] <a name="about-project"></a>
**[Awesome Book]** is a webpage for storing and displying books from the localStorage of the browser
## 🛠 Built With <a name="built-with"></a>
### Tech Stack <a name="tech-stack"></a>
<details>
<summary>HTML</summary>
<ul>
<li><a href="https://en.wikipedia.org/wiki/HTML">HTML</a></li>
</ul>
</details>
<details>
<summary>CSS</summary>
<ul>
<li><a href="https://en.wikipedia.org/wiki/CSS">CSS</a></li>
</ul>
</details>
<details>
<summary>JavaScript</summary>
<ul>
<li><a href="https://en.wikipedia.org/wiki/JavaScript">JavaScript</a></li>
</ul>
</details>
<!-- Features -->
### Key Features <a name="key-features"></a>
- **[local storage]**
- **[dynamic pages]**
- **[navigation]**
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- LIVE DEMO -->
## 🚀 Live Demo <a name="live-demo"></a>
- [Awesome Book](https://kwaku28.github.io/Awesome-book-ES6/)
<!-- GETTING STARTED -->
## 💻 Getting Started <a name="getting-started"></a>
To get a local copy up and running, follow these steps.
### Prerequisites
In order to run this project you need:
```sh
sudo apt install git-all
or
npm install
```
### Setup
Clone this repository to your desired folder:
```sh
cd my-folder
git clone https://github.com/Kwaku28/Awesome-book-ES6.git
```
### Usage
To run the project, execute the following command:
```sh
Open index.html in browser
or
open with Live server in Vscode
```
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- AUTHORS -->
## 👥 Authors <a name="authors"></a>
👤 **Lawrence Amoafo**
- GitHub: [@Kwaku28](https://github.com/Kwaku28)
<!-- FUTURE FEATURES -->
## 🔭 Future Features <a name="future-features"></a>
- [ ] **[Add more pages]**
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- CONTRIBUTING -->
## 🤝 Contributing <a name="contributing"></a>
Contributions, issues, and feature requests are welcome!
Feel free to check the [issues page](https://github.com/Yacoubou-seidou/awesome_book/issues).
<!-- SUPPORT -->
## ⭐️ Show your support <a name="support"></a>
If you like this project show some love by commenting
<!-- ACKNOWLEDGEMENTS -->
## 🙏 Acknowledgments <a name="acknowledgements"></a>
I would like to thank Microverse staff for their support
<!-- LICENSE -->
## 📝 License <a name="license"></a>
This project is [MIT](https://github.com/Kwaku28/Awesome-book-ES6/blob/main/LICENSE) licensed.
<p align="right">(<a href="#readme-top">back to top</a>)</p>
| "Awesome books" is a simple website that displays a list of books and allows you to add and remove books from that list. This website is built with JavaScript(ES6) modules | javascript | 2023-03-27T14:34:22Z | 2023-03-27T23:00:22Z | null | 1 | 1 | 13 | 0 | 0 | 4 | null | MIT | JavaScript |
cristianmeelo/react-app-fakeshop | main | <table align="right">
<tr>
<td>
<a href="README-EN.md">🇺🇸 English (apenas no GitHub)</a>
</td>
</tr>
<tr>
<td>
<a href="README.md">🇧🇷 Português</a>
</td>
</tr>
</table>
<div align="center">
<a href="https://react-app-fakeshop.vercel.app/">
<img src="https://img.shields.io/badge/-CONFIRA%20AQUI-lightblue" alt="Image App" >
</a>
</div>
<br/>
# FakeShop
A Fakeshop é uma loja virtual de e-commerce. Lá, você pode acessar um produto e ver seus detalhes.
## 🔨 Recursos do projeto
FakeShop é um e-commerce online. Para o design, foi utilizado o framework semântico de UI, proporcionando mais tempo para o desenvolvimento do gerenciamento de estado. Usando axios, acessar a página de cada produto facilita a leitura da chamada da API. Utilizando o redux no app, fixei os conceitos antes de trazê-los para os projetos da empresa que trabalho. O typescript vem como a cereja no topo do bolo e adiciona robustez ao projeto.
## ⚙️ Técnicas e tecnologias usadas
Confira essa lista de tudo que vamos usar nesse app:
- `React`
- `Vite`
- `TypeScript`
- `Redux`
- `Semantic UI`
- `Axios`
- `GitHub`
## 🛠️ Abra e execute o projeto
Para abrir e executar o projeto, execute `npm i` para instalar as dependências e `npm run dev` para iniciar o projeto.
Em seguida, vá para <a href="http://localhost:3000/">http://localhost:3000/</a> em seu navegador.
## 📚 Mais informações do tutorial
Fakeshop é um e-commerce virtual fictício desenvolvido a partir do tutorial [Dipesh Malvia](https://www.youtube.com/@DipeshMalvia). A ideia principal da implementação deste tutorial é evoluir ainda mais o conhecimento em React e na ferramenta de gerenciamento de estado redux, implementando redutores, ações e tipos de ação.
| :placard: Vitrine.Dev | |
| --------------------- | --------------------------------------------------------------------------- |
| :sparkles: Nome | **Fake Shop** |
| :label: Tecnologias | React, TypeScript,Redux, Semantic Ui, Axios, GitHub(tecnologias utilizadas) |
| :rocket: URL | https://react-app-fakeshop.vercel.app/ |
| :fire: Desafio | https://www.youtube.com/watch?v=0W6i5LYKCSI&ab_channel=DipeshMalvia |
| ⚛️ 🛠️ This is an application of the redux state management tool. The application consists of a virtual ecommerce. | react,react-redux,redux,semantic-ui,cristianmeelo,axios,javascript,reactjs,vitrinedev | 2023-03-30T19:29:18Z | 2023-10-05T21:45:30Z | null | 2 | 0 | 54 | 0 | 0 | 4 | null | MIT | TypeScript |
Metaverse-Nabeel/Awesome-Books-Updated | main | <!-- TABLE OF CONTENTS -->
# 📗 Table of Contents
- [📖 About the Project](#about-project)
- [🛠 Built With](#built-with)
- [Tech Stack](#tech-stack)
- [Key Features](#key-features)
- [💻 Getting Started](#getting-started)
- [Setup](#setup)
- [Prerequisites](#prerequisites)
- [Install](#install)
- [Usage](#usage)
- [👥 Authors](#authors)
- [🔭 Future Features](#future-features)
- [🤝 Contributing](#contributing)
- [⭐️ Show your support](#support)
- [🙏 Acknowledgements](#acknowledgements)
- [📝 License](#license)
<!-- PROJECT DESCRIPTION -->
# 📖 Awesome Books <a name="about-project"></a>
**Awesome Books** is a project for Microverse bootcamp to learn about adding data into the local storage and then fetching them to display using JavaScript.
## 🛠 Built With <a name="built-with"></a>
### Tech Stack <a name="tech-stack"></a>
<details>
<summary>HTML</summary>
<ul>
<li><a href="#">HTML</a></li>
</ul>
</details>
<details>
<summary>CSS</summary>
<ul>
<li><a href="#">CSS</a></li>
</ul>
</details>
<details>
<summary>Java Script</summary>
<ul>
<li><a href="#">JS</a></li>
</ul>
</details>
<details>
<summary>Github</summary>
<ul>
<li><a href="#">Github</a></li>
</ul>
</details>
<!-- Features -->
### Key Features <a name="key-features"></a>
- **Basic UI**
- **Form Submission to add books**
- **Storing into the local storage**
- **[Desktop Version]**
- **[Dynamic Design]**
- **[SPA design]**
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- GETTING STARTED -->
## 💻 Getting Started <a name="getting-started"></a>
To get a local copy up and running, follow these steps.
### Prerequisites
In order to run this project you need:
### Setup
Clone this repository to your desired folder:
cd my-folder
git clone https://github.com/Metaverse-Nabeel/Awesome-Books-Updated.git
### Install
Install this project with:
1. Install WebHint: npm install --save-dev hint@7.x
2. Install StyleLint npm install --save-dev stylelint@13.x stylelint-scss@3.x stylelint-config-standard@21.x stylelint-csstree-validator@1.x
3. npm install --save-dev eslint@7.x eslint-config-airbnb-base@14.x eslint-plugin-import@2.x babel-eslint@10.x
### Usage
To run the project, Open index.html in browser.
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- AUTHORS -->
## 👥 Authors <a name="authors"></a>
👤 **Author 1 Nabeel**
- GitHub: [@Metaverse-Nabeel](https://github.com/Metaverse-Nabeel)
- Twitter: [@Nabeel129](https://twitter.com/Nabeel129)
- LinkedIn: [@Nabeel129](https://linkedin.com/in/Nabeel129)
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- FUTURE FEATURES -->
## 🔭 Future Features <a name="future-features"></a>
- **Maybe making UI more stylish for users**
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- CONTRIBUTING -->
## 🤝 Contributing <a name="contributing"></a>
Contributions, issues, and feature requests are welcome!
Feel free to check the [issues page](../../issues/).
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- SUPPORT -->
## ⭐️ Show your support <a name="support"></a>
If you like this project you can follow me and give the project a star.
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- ACKNOWLEDGEMENTS -->
## 🙏 Acknowledgments <a name="acknowledgements"></a>
**Microverse**
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- LICENSE -->
## 📝 License <a name="license"></a>
This project is [MIT](./LICENSE.md) licensed.
<p align="right">(<a href="#readme-top">back to top</a>)</p>
| Awesome Books is a project for Microverse bootcamp to learn about adding data into the local storage and then fetching them to display using JavaScript. Built with HTML, CSS, and JavaScript. | css,html,javascript | 2023-03-29T06:43:11Z | 2023-04-05T09:10:14Z | null | 1 | 1 | 6 | 0 | 0 | 4 | null | NOASSERTION | JavaScript |
Lul-Abdifan/Todo-Js | master | <a name="readme-top"></a>
<div align="center">
<br/>
<h3><b>Todo Lists Project</b></h3>
</div>
<!-- TABLE OF CONTENTS -->
# 📗 Table of Contents
- [📖 About the Project](#about-project)
- [🛠 Built With](#built-with)
- [Tech Stack](#tech-stack)
- [Key Features](#key-features)
- [🚀 Live Demo](#live-demo)
- [💻 Getting Started](#getting-started)
- [Setup](#setup)
- [Prerequisites](#prerequisites)
- [Install](#install)
- [Usage](#usage)
- [Run tests](#run-tests)
- [Deployment](#triangular_flag_on_post-deployment)
- [👥 Authors](#authors)
- [🔭 Future Features](#future-features)
- [🤝 Contributing](#contributing)
- [⭐️ Show your support](#support)
- [🙏 Acknowledgements](#acknowledgements)
- [📝 License](#license)
<!-- PROJECT DESCRIPTION -->
# 📖 [Todo-List] <a name="about-project"></a>
Todo-List is an online tool designed to help individuals or teams manage their tasks and projects. The website typically includes features such as creating and organizing tasks, setting deadlines and reminders, prioritizing tasks, and tracking progress. Users can also collaborate with others by sharing tasks or lists, assigning tasks to specific team members, and leaving comments or notes on specific tasks. Todo-List websites can be used for personal task management or as a project management tool for teams working on projects together. Some popular examples of Todo-List websites include Todoist, Trello, Asana, and Wunderlist.
### Tech Stack <a name="tech-stack"></a>
<details>
<summary>Client</summary>
<ul>
<li>HTML</li>
<li>CSS</li>
<li>JAVASCRIPT</li>
</ul>
</details>
<!-- Features -->
### Key Features <a name="key-features"></a>
- **[Responsive design]**
- **[Page Jumps]**
- **[Add/Remove buttons]**
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- LIVE DEMO -->
## 🚀 Live Demo <a name="live-demo"></a>
- [Todo-List](https://lul-abdifan.github.io/Todo-Js/)
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- GETTING STARTED -->
## 💻 Getting Started <a name="getting-started"></a>
To get a local copy up and running, follow these steps.
### Prerequisites
In order to run this project you need:
<ul>
<li>The current version of node</li>
<li>To have Git installed on your local machine</li>
<li>Node Package manager (npm) </li>
<li>An editor such as Visual Studio Code</li>
</ul>
### Setup
Clone this repository to your desired folder:
<ul>
<li>Create your classic access token from github.com</li>
<li>run "git clone https://{access_token}@github.com/username/{repo_name}.git"</li>
<li>Update your git identity by running "git config --global user.email "your_email@gmail.com""</li>
<li>Update your name on git by running "git config --global user.name "your_name"</li>
</ul>
### Install
Install this project with:
- In the first commit of your feature branch create a .github/workflows folder and add a copy of [.github/workflows/linters.yml](https://github.com/microverseinc/linters-config/blob/master/html-css-js/.github/workflows/linters.yml) to that folder.
- create a .gitignore file and add 'node_modules' to it
- run 'npm init -y'
- run 'npm install --save-dev hint@7.x'
- Copy [hintrc](https://github.com/microverseinc/linters-config/blob/master/html-css-js/.hintrc) to the root directory of your project.
- run 'npx hint .'
- Fix validation errors.
- run 'npm install --save-dev stylelint@13.x stylelint-scss@3.x stylelint-config-standard@21.x stylelint-csstree-validator@1.x'
- Copy [stylelintrc.json](https://github.com/microverseinc/linters-config/blob/master/html-css-js/.stylelintrc.json) to the root directory of your project.
- Run 'npx stylelint "**/*.{css,scss}"'
- fix linter errors
- run 'npm install --save-dev eslint@7.x eslint-config-airbnb-base@14.x eslint-plugin-import@2.x babel-eslint@10.x'
- Copy [eslintrc.json](https://github.com/microverseinc/linters-config/tree/master/html-css-js)
- Run npx eslint . on the root of your directory of your project
- Fix linter error.
### Usage
To run the project, execute the following command:
```sh
use git bash to open in Vs code
```
### Run tests
To run tests, run the following command:
```sh
Run "npx hint ."
Run "npx stylelint "**/*.{css,scss} --fix " to fix linters
Run "npx eslint . --fix to fix linters"
```
### Deployment
You can deploy this project using:
- github pages
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- AUTHORS -->
## 👥 Authors <a name="authors"></a>
👤 **Author1**
- GitHub: [Abdi Bekele](https://github.com/Lul-Abdifan)
- LinkedIn: [LinkedIn](https://www.linkedin.com/in/abdi-bekele-a63860254/)
- e-mail: [tasanbannu@gmail.com](mailto:tasanbannu@gmail.com)
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- FUTURE FEATURES -->
## 🔭 Future Features <a name="future-features"></a>
- [ ] **[contact form page]**
- [ ] **[A feature for price inclusion]**
- [ ] **[A feature for updating the cart]**
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- CONTRIBUTING -->
## 🤝 Contributing <a name="contributing"></a>
Contributions, issues, and feature requests are welcome!
Feel free to check the [issues page](../../issues/).
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- SUPPORT -->
## ⭐️ Show your support <a name="support"></a>
If you like this project, kindly drop a star for me.
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- ACKNOWLEDGEMENTS -->
## 🙏 Acknowledgments <a name="acknowledgements"></a>
I would like to use this medium to appreciate Microverse that bringing me The best platform ever for me.
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- LICENSE -->
## 📝 License <a name="license"></a>
This project is [MIT](./LICENSE) licensed.
<p align="right">(<a href="#readme-top">back to top</a>)</p>
| A tool that helps you keep track of tasks. It lets you add, remove, and delete items. By using local storage, you can access it offline. | html,javascript,scss | 2023-03-27T15:03:27Z | 2023-03-31T22:09:11Z | null | 1 | 3 | 54 | 2 | 0 | 4 | null | null | JavaScript |
Cisco-the-wayword/To-do-list | main | # To-do-list
<a name="readme-top"></a>
<!-- TABLE OF CONTENTS -->
# 📗 Table of Contents
- [📖 About the Project](#about-project)
- [🛠 Built With](#built-with)
- [Tech Stack](#tech-stack)
- [Key Features](#key-features)
- [🚀 Live Demo](#live-demo)
- [💻 Getting Started](#getting-started)
- [Setup](#setup)
- [Prerequisites](#prerequisites)
- [Install](#install)
- [Usage](#usage)
- [Run tests](#run-tests)
- [Deployment](#triangular_flag_on_post-deployment)
- [👥 Authors](#authors)
- [🔭 Future Features](#future-features)
- [🤝 Contributing](#contributing)
- [⭐️ Show your support](#support)
- [🙏 Acknowledgements](#acknowledgements)
- [📝 License](#license)
<!-- PROJECT DESCRIPTION -->
# 📖 To-do-list <a name="about-project"></a>
**To-do-list** is a project to enable users add and remove tasks easily
## 🛠 Built With <a name="built-with"></a>
### Tech Stack <a name="tech-stack"></a>
<details>
<summary>Markup</summary>
<ul>
<li><a href="https://html5.org/">HTML5</a></li>
</ul>
</details>
<details>
<summary>Interaction</summary>
<ul>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript">JavaScript</a></li>
</ul>
</details>
<!-- Features -->
### Key Features <a name="key-features"></a>
- **Easy navigation**
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- LIVE DEMO -->
## 🚀 Live Demo <a name="live-demo"></a>
- [Live Demo Link](https://cisco-the-wayword.github.io/list/)
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- GETTING STARTED -->
## 💻 Getting Started <a name="getting-started"></a>
To get a local copy up and running, follow these steps.
### Prerequisites
In order to run this project you need an IDE such as VS code, sublime, atom e.t.c:
### Setup
Clone this repository to your desired folder:
Example commands:
```sh
$ cd my-folder
$ git@github.com:Cisco-the-wayword/To-do-list.git
```
### Install
Install git to work on this project with:
```sh
$ git config --global user.name "First Last"
$ git config --global user.email "example@example.com"
```
### Usage
To run the project have Node.js installed, execute the following command:
```sh
Run the code on your code editor's live server.
Then navigate to webpack-demo/src to deploy the page.
```
Go to your browser and type localhost:8080. Your Application should run
### Run tests
To run tests, run the HTML document in Google Chrome and right-click the HTML element you want to inspect. Click on "Inspect" and you will have the tools to run, analyze, and even debug the code
### Deployment
You can deploy this project using build tools such as webpack, Rollup, Parcel, e.t.c or even deploy using Github pages:
Example: To build for production with parcel, use the folowing commands:
- Initialise npm package
- Install parcel
- Build for production
```sh
$ npm init -y
$ npm i -g parcel-bundler
$ parcel build index.html
```
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- AUTHORS -->
## 👥 Authors <a name="authors"></a>
👤 **Cisco**
- GitHub: [@Cisco-the-wayword](https://github.com/Cisco-the-wayword)
- Twitter: [@the_wayword1](https://twitter.com/the_wayword1)
- LinkedIn: [LinkedIn](https://www.linkedin.com/in/boluwatife-adegboyega-9397a81b3?lipi=urn%3Ali%3Apage%3Ad_flagship3_profile_view_base_contact_details%3BNGz7hXcRTTWAVNixcs9b%2FA%3D%3D)
<!-- FUTURE FEATURES -->
## 🔭 Future Features <a name="future-features"></a>
> Future features that will be added to the project include:
- **An improved user interface**
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- CONTRIBUTING -->
## 🤝 Contributing <a name="contributing"></a>
Contributions, issues, and feature requests are welcome!
Feel free to check the [issues page](../../issues/).
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- SUPPORT -->
## ⭐️ Show your support <a name="support"></a>
If you like this project, give a ⭐️.
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- ACKNOWLEDGEMENTS -->
## 🙏 Acknowledgments <a name="acknowledgements"></a>
We would like to thank [Microverse](https://www.microverse.org/go?utm_source=google&utm_medium=paid&utm_campaign=search_europe&gclid=CjwKCAjwq-WgBhBMEiwAzKSH6IxBgyh61fi4WRuQvUsaGigJMuzzc9177uC6mhMwXeriUDendiuvChoC20wQAvD_BwE) for the opportunity to conduct pair programming on this project.
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- LICENSE -->
## 📝 License <a name="license"></a>
This project is [MIT](./LICENSE) licensed.
<p align="right">(<a href="#readme-top">back to top</a>)</p>
| This repository contains a To-do list application that helps the user keep track of pending actions and acts as a reminder to get them done. | bootstrap5,css3,html5,javascript | 2023-04-03T20:06:32Z | 2023-04-08T01:09:59Z | null | 1 | 4 | 44 | 0 | 0 | 4 | null | MIT | JavaScript |
kirpalsingh17/javaScript-important-concepts-understanding | main | [What is JavaScript?](#what-is-javascript)
[What are the advantages of using JavaScript?](#what-are-the-advantages-of-using-javascript)
[What are the disadvantages of using JavaScript?](#what-are-the-advantages-of-using-javascript)
[How do you declare a variable in JavaScript?](#how-do-you-declare-a-variable-in-javascript)
[What is the difference between let and var in JavaScript?](#what-is-the-difference-between-let-and-var-in-javascript)
[What is the difference between == and === in JavaScript?](#what-is-the-difference-between--and--in-javascript)
[How do you create a function in JavaScript?](#how-do-you-create-a-function-in-javascript)
[What is an event in JavaScript?](#what-is-an-event-in-javascript)
[What is a callback function in JavaScript?](#what-is-a-callback-function-in-javascript)
[What is the difference between synchronous and asynchronous code in JavaScript?](#what-is-the-difference-between-synchronous-and-asynchronous-code-in-javascript)
[What is a closure in JavaScript?](#what-is-a-closure-in-javascript)
[What is the difference between null and undefined in JavaScript?](#what-is-the-difference-between-null-and-undefined-in-javascript)
[How do you check if a variable is undefined in JavaScript?](#how-do-you-check-if-a-variable-is-undefined-in-javascript)
[How do you check if a variable is null in JavaScript?](#how-do-you-check-if-a-variable-is-null-in-javascript)
[What is the difference between null and NaN in JavaScript?](#what-is-the-difference-between-null-and-nan-in-javascript)
[What is a prototype in JavaScript?](#what-is-a-prototype-in-javascript)
[What is an object in JavaScript?](#what-is-an-object-in-javascript)
[What is the difference between an array and an object in JavaScript?](#what-is-the-difference-between-an-array-and-an-object-in-javascript)
[How do you add an element to an array in JavaScript?](#how-do-you-add-an-element-to-an-array-in-javascript)
[How do you remove an element from an array in JavaScript?](#how-do-you-remove-an-element-from-an-array-in-javascript)
[What is the DOM in JavaScript?](#what-is-the-dom-in-javascript)
[What is an event listener in JavaScript?](#what-is-an-event-listener-in-javascript)
[How do you create a class in JavaScript?](#how-do-you-create-a-class-in-javascript)
[What is inheritance in JavaScript?](#what-is-inheritance-in-javascript)
[How do you implement inheritance in JavaScript?](#how-do-you-implement-inheritance-in-javascript)
[What is a module in JavaScript?](#what-is-a-module-in-javascript)
[How do you create a module in JavaScript?](#how-do-you-create-a-module-in-javascript)
[What is the difference between synchronous and asynchronous module loading in JavaScript?](#what-is-the-difference-between-synchronous-and-asynchronous-module-loading-in-javascript)
[What is a promise in JavaScript?](#what-is-a-promise-in-javascript)
[How do you create a promise in JavaScript?](#how-do-you-create-a-promise-in-javascript)
[How do you handle errors in a promise in JavaScript?](#how-do-you-handle-errors-in-a-promise-in-javascript)
[What is the difference between resolve and reject in a promise in JavaScript?](#what-is-the-difference-between-resolve-and-reject-in-a-promise-in-javascript)
[What is the difference between then and catch in a promise in JavaScript?](#what-is-the-difference-between-then-and-catch-in-a-promise-in-javascript)
[What is the difference between a callback and a promise in JavaScript?](#what-is-the-difference-between-a-callback-and-a-promise-in-javascript)
[How do you use the fetch API to make an HTTP request in JavaScript?](#how-do-you-use-the-fetch-api-to-make-an-http-request-in-javascript)
[What is a closure in JavaScript?](#what-is-a-closure-in-javascript-1)
[How do you use closures in JavaScript?](#how-do-you-use-closures-in-javascript)
[What is a callback function in JavaScript?](#what-is-a-callback-function-in-javascript-1)
[How do you use a callback function in JavaScript?](#how-do-you-use-a-callback-function-in-javascript)
[What is the difference between a callback function and a promise in JavaScript?](#what-is-the-difference-between-a-callback-function-and-a-promise-in-javascript)
[What is the difference between let, const and var in JavaScript?](#what-is-the-difference-between-let-const-and-var-in-javascript)
[What is the difference between a function declaration and a function expression in JavaScript?](#what-is-the-difference-between-a-function-declaration-and-a-function-expression-in-javascript)
[What is hoisting in JavaScript?](#what-is-hoisting-in-javascript)
[What is the difference between an arrow function and a regular function in JavaScript?](#what-is-the-difference-between-an-arrow-function-and-a-regular-function-in-javascript)
[What is a generator function in JavaScript?](#what-is-a-generator-function-in-javascript)
[How do you use a generator function in JavaScript?](#how-do-you-use-a-generator-function-in-javascript)
[What is the difference between call, apply and bind in JavaScript?](#what-is-the-difference-between-call-apply-and-bind-in-javascript)
[How do you use call, apply and bind in JavaScript?](#how-do-you-use-call-apply-and-bind-in-javascript)
[What is a higher-order function in JavaScript?](#what-is-a-higher-order-function-in-javascript)
[How do you use a higher-order function in JavaScript?](#how-do-you-use-a-higher-order-function-in-javascript)
[What is the difference between map, filter and reduce in JavaScript?](#what-is-the-difference-between-map-filter-and-reduce-in-javascript)
[How do you use map, filter and reduce in JavaScript?](#how-do-you-use-map-filter-and-reduce-in-javascript)
[What is a curried function in JavaScript?](#what-is-a-curried-function-in-javascript)
[How do you use a curried function in JavaScript?](#how-do-you-use-a-curried-function-in-javascript)
[What is a closure in JavaScript?](#what-is-a-closure-in-javascript-2)
[How do you use closures in JavaScript?](#how-do-you-use-closures-in-javascript-1)
[What is memoization in JavaScript?](#what-is-memoization-in-javascript)
[How do you use memoization in JavaScript?](#how-do-you-use-memoization-in-javascript)
[What is a decorator function in JavaScript?](#what-is-a-decorator-function-in-javascript)
[How do you use a decorator function in JavaScript?](#how-do-you-use-a-decorator-function-in-javascript)
[What is event bubbling in JavaScript?](#what-is-event-bubbling-in-javascript)
[How do you stop event bubbling in JavaScript?](#how-do-you-stop-event-bubbling-in-javascript)
[What is event delegation in JavaScript?](#what-is-event-delegation-in-javascript)
[How do you use event delegation in JavaScript?](#how-do-you-use-event-delegation-in-javascript)
[What is the difference between client-side and server-side JavaScript?](#what-is-the-difference-between-client-side-and-server-side-javascript)
[What is the difference between an object and a function in JavaScript?](#what-is-the-difference-between-an-object-and-a-function-in-javascript)
[What is a singleton in JavaScript?](#what-is-a-singleton-in-javascript)
[How do you create a singleton in JavaScript?](#how-do-you-create-a-singleton-in-javascript)
[What is functional programming in JavaScript?](#what-is-functional-programming-in-javascript)
[How do you write functional programming code in JavaScript?](#how-do-you-write-functional-programming-code-in-javascript)
[What is the difference between imperative and declarative programming in JavaScript?](#what-is-the-difference-between-imperative-and-declarative-programming-in-javascript)
[How do you write declarative programming code in JavaScript?](#how-do-you-write-declarative-programming-code-in-javascript)
[What is a monad in JavaScript?](#what-is-a-monad-in-javascript)
[How do you use a monad in JavaScript?](#how-do-you-use-a-monad-in-javascript)
[What is a functor in JavaScript?](#what-is-a-functor-in-javascript)
[How do you use a functor in JavaScript?](#how-do-you-use-a-functor-in-javascript)
[What is a monoid in JavaScript?](#what-is-a-monoid-in-javascript)
[How do you use a monoid in JavaScript?](#how-do-you-use-a-monoid-in-javascript)
[What is the difference between prototypal and classical inheritance in JavaScript?](#what-is-the-difference-between-prototypal-and-classical-inheritance-in-javascript)
[How do you implement prototypal inheritance in JavaScript?](#how-do-you-implement-prototypal-inheritance-in-javascript)
[How do you implement classical inheritance in JavaScript?](#how-do-you-implement-classical-inheritance-in-javascript)
[What is the difference between a closure and a module in JavaScript?](#what-is-the-difference-between-a-closure-and-a-module-in-javascript)
[How do you use the this keyword in JavaScript?](#how-do-you-use-the-this-keyword-in-javascript)
[What is the difference between call, apply, and bind in JavaScript?](#what-is-the-difference-between-call-apply-and-bind-in-javascript-1)
[How do you use the apply method in JavaScript?](#how-do-you-use-the-apply-method-in-javascript)
[How do you use the bind method in JavaScript?](#how-do-you-use-the-bind-method-in-javascript)
[What is a factory function in JavaScript?](#what-is-a-factory-function-in-javascript)
[How do you use a factory function in JavaScript?](#how-do-you-use-a-factory-function-in-javascript)
[What is a promise in JavaScript?](#what-is-a-promise-in-javascript-1)
[How do you use a promise in JavaScript?](#how-do-you-use-a-promise-in-javascript)
[What is a callback function in JavaScript?](#what-is-a-callback-function-in-javascript-2)
[How do you use a callback function in JavaScript?](#how-do-you-use-a-callback-function-in-javascript-1)
[What is the difference between a callback function and a promise in JavaScript?](#what-is-the-difference-between-a-callback-function-and-a-promise-in-javascript-1)
[What is the difference between a promise and an observable in JavaScript?](#what-is-the-difference-between-a-promise-and-an-observable-in-javascript)
[What is a higher-order component in React?](#what-is-a-higher-order-component-in-react)
[How do you use a higher-order component in React?](#how-do-you-use-a-higher-order-component-in-react)
[What is Redux in React?](#what-is-redux-in-react)
[How do you use Redux in React?](#how-do-you-use-redux-in-react)
#### What is JavaScript?
JavaScript is a high-level, dynamic programming language that is used mainly for web development. It allows developers to create interactive and dynamic web pages by adding interactivity, animations, and other dynamic elements to the webpage.
JavaScript is executed on the client side, meaning it runs in the user's web browser, rather than on the server. This makes it an essential component of modern web development, as it allows developers to create rich, interactive user interfaces without relying on server-side processing.
JavaScript is also widely used in server-side programming, such as with Node.js, which allows developers to use JavaScript for building scalable, networked applications. Additionally, JavaScript is commonly used in game development, desktop application development, and mobile app development.
---
#### What are the advantages of using JavaScript?
There are several advantages of using JavaScript in web development:
**Client-side execution:** JavaScript runs in the user's web browser, which means it doesn't require server-side processing, reducing the workload on the server.
**Interactivity:** JavaScript allows developers to create dynamic, interactive web pages that respond to user actions, such as clicking buttons or scrolling.
**Versatility:** JavaScript can be used for a wide variety of tasks, from simple animations to complex, interactive web applications.
Cross-platform compatibility: JavaScript runs on all modern web browsers and is supported by most mobile devices, making it a popular choice for building responsive, mobile-friendly websites.
**Large community and resources:** JavaScript has a large and active developer community, with many libraries, frameworks, and plugins available to simplify development and increase functionality.
**Fast development:** JavaScript is easy to learn and has a low entry barrier, allowing developers to quickly create prototypes and iterate on designs.
**SEO friendly:** JavaScript is search engine optimization (SEO) friendly, meaning that search engines can easily index content built with JavaScript, helping to improve a website's search engine ranking.
---
#### What are the disadvantages of using JavaScript?
While JavaScript has many advantages, it also has some disadvantages that developers should consider:
**Browser compatibility issues:** Different web browsers may interpret JavaScript code differently, which can result in unexpected behavior or errors. This means developers must test their code thoroughly on different browsers to ensure compatibility.
**Security risks:** JavaScript is executed on the client side, which means it can be manipulated by users or malicious scripts, creating security vulnerabilities.
**Performance issues:** Heavy use of JavaScript can slow down the performance of a website, especially on older devices or slower internet connections.
**Lack of standardization:** While there are industry standards for JavaScript, there is also a lot of variation in coding practices and frameworks, which can make it challenging for developers to maintain consistency across projects.
**Debugging challenges:** Debugging JavaScript code can be difficult, especially when working with complex applications or codebases.
**Limited functionality:** JavaScript has some limitations when it comes to accessing system resources, such as the file system or hardware, which can limit its functionality for certain types of applications.
**Accessibility concerns:** JavaScript can create accessibility issues for users with disabilities, such as those using assistive technology or screen readers, if not implemented properly.
---
#### How do you declare a variable in JavaScript?
In JavaScript, you can declare a variable using the var, let, or const keywords. Here's an example of each:
**var:** The var keyword is used to declare a variable with function scope or global scope. Here's an example:
```javascript
var myVariable = 10;
```
**let:** The let keyword is used to declare a variable with block scope. Here's an example:
```javascript
let myVariable = 10;
```
**const:** The const keyword is used to declare a variable that cannot be reassigned. Here's an example:
```javascript
const myVariable = 10;
```
In all three cases, myVariable is the name of the variable, and 10 is the initial value assigned to it.
---
#### What is the difference between let and var in JavaScript?
The main difference between let and var in JavaScript is in their scoping rules.
var variables have function scope, meaning that they are accessible within the function in which they are defined, as well as any nested functions. If a var variable is declared outside of a function, it becomes a global variable, accessible throughout the entire code.
let variables, on the other hand, have block scope, meaning that they are only accessible within the block in which they are defined (e.g., within a for loop, an if statement, or a function). let variables are not accessible outside of the block in which they are defined.
Another difference between let and var is that let variables cannot be re-declared within the same scope, while var variables can be re-declared multiple times within the same scope.
Here's an example to illustrate the difference:
```javascript
function myFunction() {
var x = 1;
if (true) {
var x = 2; // This re-declares the same variable
console.log(x); // Output: 2
}
console.log(x); // Output: 2
}
function myOtherFunction() {
let y = 1;
if (true) {
let y = 2; // This is a new variable, not a re-declaration
console.log(y); // Output: 2
}
console.log(y); // Output: 1
}
```
In the first function, var x is re-declared inside the if statement, which also changes the value of the original x variable declared outside of the if statement. In the second function, let y creates a new variable inside the if statement, which does not affect the original y variable declared outside of the if statement.
---
#### What is the difference between == and === in JavaScript?
In JavaScript, == and === are both used for comparison, but they behave differently.
**==** is the equality operator and checks whether the two operands are equal in value, after performing any necessary type conversions. If the operands are of different data types, JavaScript will try to convert them to a common type before making the comparison. This can sometimes lead to unexpected results.
For example:
```javascript
console.log(5 == "5"); // Output: true
```
In this case, 5 and "5" are not the same data type, but JavaScript automatically converts the string "5" to the number 5 before making the comparison.
**===** is the strict equality operator and checks whether the two operands are equal in both value and data type. If the operands are of different data types, === returns false without trying to convert them to a common type.
For example:
```javascript
console.log(5 === "5"); // Output: false
```
In this case, 5 and "5" are not the same data type, so === returns false without trying to convert them to a common type.
In general, it's recommended to use === for comparisons in JavaScript, as it provides a more strict and predictable comparison. However, there may be cases where == is more appropriate, depending on the specific needs of your code.
---
#### How do you create a function in JavaScript?
In JavaScript, you can create a function using the function keyword, followed by the name of the function, and the function parameters enclosed in parentheses. The function body is enclosed in curly braces {}. Here's an example of a basic function that takes two parameters and returns their sum:
```javascript
function addNumbers(num1, num2) {
return num1 + num2;
}
```
In this example, addNumbers is the name of the function, and num1 and num2 are the parameters. The function body consists of a single statement that returns the sum of the two parameters.
You can then call the function by using its name, followed by the values you want to pass as arguments, enclosed in parentheses. For example:
```javascript
let result = addNumbers(5, 10);
console.log(result); // Output: 15
```
In this example, the addNumbers function is called with the arguments 5 and 10, which are passed to the num1 and num2 parameters, respectively. The result variable is then assigned the value returned by the function, which is 15.
---
#### What is an event in JavaScript?
In JavaScript, an event is an action or occurrence that happens in the browser, such as a user clicking on a button, submitting a form, or loading a page. Events can be detected and handled using event listeners, which are functions that are executed in response to a specific event.
There are many types of events that can occur in the browser, such as:
**Mouse events,** such as click, mousemove, and mouseover.
**Keyboard events,** such as keydown, keyup, and keypress.
**Form events,** such as submit, reset, and change.
**Document and window events,** such as load, unload, and resize.
To handle an event in JavaScript, you can use the addEventListener() method to attach an event listener to a specific HTML element. The first argument to addEventListener() is the name of the event you want to handle, and the second argument is the function that will be executed when the event occurs.
Here's an example that shows how to handle a click event on a button element:
```html
<button id="myButton">Click me</button>
```
```javascript
let button = document.getElementById("myButton");
button.addEventListener("click", function() {
console.log("Button clicked!");
});
```
In this example, the getElementById() method is used to retrieve the button element from the HTML document, and the addEventListener() method is used to attach a click event listener to the button. When the button is clicked, the function passed as the second argument to addEventListener() is executed, which logs a message to the console.
---
#### What is a callback function in JavaScript?
In JavaScript, a callback function is a function that is passed as an argument to another function and is executed inside that function. Callback functions are often used to perform some action after a specific task is completed, such as fetching data from a server or executing an animation.
Here's an example of a simple callback function that logs a message to the console:
```javascript
function myCallback() {
console.log("Callback executed!");
}
function doSomething(callback) {
// Perform some task here...
console.log("Task completed!");
// Call the callback function
callback();
}
doSomething(myCallback); // Output: "Task completed!" "Callback executed!"
```
In this example, the doSomething() function takes a callback function as an argument and executes it after performing some task. When doSomething() is called with myCallback as the argument, it executes the task and then calls the myCallback() function, which logs a message to the console.
Callbacks are a powerful feature of JavaScript that enable asynchronous programming and help to avoid blocking the main thread. They are often used in combination with other JavaScript features such as promises, async/await, and event listeners to create complex and dynamic web applications.
---
#### What is the difference between synchronous and asynchronous code in JavaScript?
In JavaScript, synchronous code is executed in a sequential manner, meaning that each statement is executed one after the other in the order they appear in the code. When a synchronous operation is performed, the program waits for it to complete before continuing to execute the next statement.
Asynchronous code, on the other hand, allows the program to continue executing other statements while waiting for a long-running operation to complete. Asynchronous code is typically used for tasks that involve I/O operations, such as reading and writing files or making network requests, as these operations can take a long time to complete.
One way to implement asynchronous code in JavaScript is to use callback functions. When a long-running operation is started, a callback function is provided that will be executed once the operation completes. This allows the program to continue executing other statements while waiting for the operation to complete.
Another way to implement asynchronous code in JavaScript is to use promises. Promises are objects that represent the eventual completion or failure of an asynchronous operation, and can be used to handle asynchronous code in a more structured and readable way.
Here's an **example of synchronous code** that calculates the sum of two numbers:
```javascript
function addNumbers(num1, num2) {
return num1 + num2;
}
let result = addNumbers(5, 10);
console.log(result); // Output: 15
```
In this example, the addNumbers() function is executed synchronously, and the program waits for the function to complete before logging the result to the console.
Here's an **example of asynchronous code** that reads data from a file using callbacks:
```javascript
const fs = require("fs");
fs.readFile("data.txt", "utf8", function(err, data) {
if (err) throw err;
console.log(data);
});
console.log("Reading file..."); // This statement is executed before the file is read
```
In this example, the fs.readFile() function is executed asynchronously, and the program continues executing the next statement after calling the function. When the file is read, the callback function is executed, and the contents of the file are logged to the console.
---
#### What is a closure in JavaScript?
In JavaScript, a closure is created when a function is defined within another function (also known as the outer function) and the inner function has access to the outer function's variables, parameters, and scope chain.
The inner function maintains a reference to the outer function's scope, even after the outer function has returned. This means that the inner function can continue to access and manipulate the variables and parameters of the outer function, even though the outer function has finished executing.
Here's an example:
```javascript
function outerFunction() {
var outerVariable = "I am from the outer function";
function innerFunction() {
console.log(outerVariable);
}
return innerFunction;
}
var innerFunc = outerFunction();
innerFunc(); // Output: "I am from the outer function"
```
In this example, outerFunction creates a variable outerVariable and defines an inner function innerFunction that logs the value of outerVariable to the console. outerFunction then returns innerFunction.
When outerFunction is called and the returned function is assigned to innerFunc, outerVariable is still accessible to innerFunction even though outerFunction has finished executing. When innerFunc is called, it logs the value of outerVariable to the console.
This is a simple example of a closure in JavaScript.
---
#### What is the difference between null and undefined in JavaScript?
In JavaScript, null and undefined are both values that represent absence of a value, but they are used in different situations.
undefined is a value that a variable can have if it has not been assigned a value, or if it has been explicitly assigned the value undefined. It is also the value returned by a function if no return value is specified, or if a variable is declared but not initialized. For example:
```javascript
var myVar;
console.log(myVar); // Output: undefined
function myFunc() {
// no return statement
}
console.log(myFunc()); // Output: undefined
```
In the example above, myVar is declared but not initialized, so its value is undefined. Similarly, myFunc does not have a return statement, so it returns undefined.
null, on the other hand, is a value that represents the intentional absence of any object value. It is often used to indicate that a variable should have no value or that an object property should be empty. For example:
```javascript
var myVar = null;
console.log(myVar); // Output: null
var myObj = { name: null };
console.log(myObj.name); // Output: null
```
In the example above, myVar is assigned the value null, indicating that it intentionally has no value. myObj.name is also assigned the value null, indicating that the name property of the myObj object intentionally has no value.
In summary, undefined is used to represent the absence of a value when a value is expected, while null is used to represent the intentional absence of any object value.
---
#### How do you check if a variable is undefined in JavaScript?
In JavaScript, there are a few ways to check if a variable is undefined:
Using the **typeof operator**:
```javascript
var myVar;
if (typeof myVar === 'undefined') {
console.log('myVar is undefined');
}
```
The typeof operator returns a string representing the data type of the variable. When the variable has not been assigned a value, or has been explicitly assigned the value undefined, typeof returns the string "undefined". This can be used to check if the variable is undefined.
Using strict equality with the undefined value:
```javascript
var myVar;
if (myVar === undefined) {
console.log('myVar is undefined');
}
```
In JavaScript, undefined is a global variable that represents the undefined value. When a variable has not been assigned a value, or has been explicitly assigned the value undefined, it is equal to the undefined value. This can be used to check if the variable is undefined.
It's worth noting that it's generally recommended to use the typeof approach, as using undefined directly can be error-prone. If a variable has not been declared, referencing it directly will result in a reference error. For example:
```javascript
if (myVar === undefined) {
console.log('myVar is undefined');
}
// ReferenceError: myVar is not defined
```
To avoid this error, it's best to use the typeof approach.
---
#### How do you check if a variable is null in JavaScript?
In JavaScript, you can check if a variable is null using the strict equality operator (===) to compare it to the null value:
```javascript
var myVar = null;
if (myVar === null) {
console.log('myVar is null');
}
```
When a variable is explicitly assigned the value null, it is equal to the null value. This can be used to check if the variable is null.
It's important to note that if a variable has not been declared or defined, attempting to compare it to null will result in a reference error. For example:
```javascript
if (myVar === null) {
console.log('myVar is null');
}
// ReferenceError: myVar is not defined
```
To avoid this error, you should first check if the variable exists before attempting to compare it to null. You can do this using the typeof operator or by using a truthy/falsy check:
javascript
```javascript
if (myVar && myVar === null) {
console.log('myVar is null');
}
```
In the example above, the first part of the condition checks if myVar is truthy (i.e. not null, undefined, 0, false, or an empty string), and the second part checks if it is explicitly equal to null. If myVar is not truthy, the second part of the condition will not be evaluated, avoiding a reference error.
---
#### What is the difference between null and NaN in JavaScript?
In JavaScript, null and NaN are both values that represent the absence of a value, but they are used in different situations.
null is a value that represents the intentional absence of any object value. It is often used to indicate that a variable should have no value or that an object property should be empty. For example:
```javascript
var myVar = null;
console.log(myVar); // Output: null
var myObj = { name: null };
console.log(myObj.name); // Output: null
```
In the example above, myVar is assigned the value null, indicating that it intentionally has no value. myObj.name is also assigned the value null, indicating that the name property of the myObj object intentionally has no value.
On the other hand, NaN stands for "Not a Number" and is a special value in JavaScript that represents an invalid or unrepresentable mathematical value. It is typically the result of a mathematical operation that cannot be performed, such as dividing by zero or trying to perform arithmetic on non-numeric data types. For example:
```javascript
var result = 1 / 0;
console.log(result); // Output: Infinity
var notANumber = "foo" / 3;
console.log(notANumber); // Output: NaN
```
In the example above, result is assigned the value Infinity, which is the result of dividing a number by zero. notANumber is assigned the value NaN, which is the result of dividing a string by a number.
In summary, null is used to represent the intentional absence of any object value, while NaN is used to represent an invalid or unrepresentable mathematical value.
---
#### What is a prototype in JavaScript?
In JavaScript, every object has a prototype, which is a reference to another object. The prototype is used as a fallback source of properties and methods for the object. When you access a property or method of an object, JavaScript first looks for it in the object itself, and if it's not found, it looks for it in the object's prototype, and so on up the prototype chain until it reaches the root object.
The prototype chain is created by the prototype property of a constructor function. When you create a new object with a constructor function using the new keyword, the prototype of the new object is set to the constructor function's prototype property. For example:
```javascript
function Person(name, age) {
this.name = name;
this.age = age;
}
Person.prototype.sayHello = function() {
console.log('Hello, my name is ' + this.name + ' and I am ' + this.age + ' years old');
};
var person1 = new Person('John', 30);
person1.sayHello(); // Output: "Hello, my name is John and I am 30 years old"
```
In the example above, we define a Person constructor function that takes a name and an age parameter and sets them as properties of the new object created by the function. We also define a sayHello method on the Person function's prototype. When we create a new Person object with person1 = new Person('John', 30), the prototype of person1 is set to Person.prototype, which contains the sayHello method. Therefore, when we call person1.sayHello(), JavaScript first looks for the sayHello method on person1 and, not finding it there, looks up the prototype chain to find it on Person.prototype.
Prototypes are powerful and flexible, as they allow you to create objects that inherit properties and methods from other objects, which can reduce code duplication and make your code more modular and reusable. However, it's important to be aware of the prototype chain and understand how it affects the behavior of your code.
---
#### What is an object in JavaScript?
In JavaScript, an object is a collection of properties, where each property has a name and a value, and the value can be of any data type, including other objects. Objects can be created using object literals, constructor functions, or using the Object() constructor.
Object literals are the most common way to create objects in JavaScript, and they consist of a comma-separated list of name-value pairs enclosed in curly braces. For example:
```javascript
var person = {
name: 'John',
age: 30,
address: {
street: '123 Main St',
city: 'Anytown',
state: 'CA',
zip: '12345'
},
hobbies: ['reading', 'running', 'cooking']
};
```
In the example above, we create an object called person with four properties: name, age, address, and hobbies. The address property is an object itself, with its own set of properties, and the hobbies property is an array of strings.
**Constructor functions are another way to create objects in JavaScript,** and they allow you to define a blueprint for creating similar objects. For example:
```javascript
function Person(name, age) {
this.name = name;
this.age = age;
this.sayHello = function() {
console.log('Hello, my name is ' + this.name + ' and I am ' + this.age + ' years old');
}
}
var person1 = new Person('John', 30);
person1.sayHello(); // Output: "Hello, my name is John and I am 30 years old"
```
In the example above, we define a Person constructor function that takes a name and an age parameter and sets them as properties of the new object created by the function. We also define a sayHello method on the object that is created by the function. When we create a new Person object with person1 = new Person('John', 30), we call the constructor function with the new keyword, which creates a new object and sets its prototype to Person.prototype. Then, we call the sayHello method on the person1 object.
Overall, objects in JavaScript are a fundamental concept that allow you to store and manipulate data in a flexible and powerful way.
---
#### What is the difference between an array and an object in JavaScript?
In JavaScript, arrays and objects are both types of data structures that can be used to store and manipulate data, but they have some differences in how they are implemented and used.
An array is an ordered list of values, where each value is associated with an index. The index is a non-negative integer, and the first value in the array has an index of 0. Arrays can contain any type of value, including other arrays or objects. Arrays in JavaScript are implemented as objects with a special length property that reflects the number of elements in the array. Arrays also have built-in methods for manipulating their contents, such as push(), pop(), shift(), unshift(), and slice().
An object, on the other hand, is an unordered collection of properties, where each property has a name and a value. The name of the property is a string or a symbol, and the value can be any type of value, including other objects or arrays. Objects in JavaScript are implemented as a key-value store, where the keys are the property names and the values are the property values. Objects also have built-in methods for manipulating their properties, such as Object.keys(), Object.values(), and Object.entries().
Here is an example that shows the difference between an array and an object:
```javascript
var myArray = [1, 2, 3];
var myObject = {a: 1, b: 2, c: 3};
console.log(myArray[1]); // Output: 2
console.log(myObject.b); // Output: 2
myArray.push(4);
myObject.d = 4;
console.log(myArray); // Output: [1, 2, 3, 4]
console.log(myObject); // Output: {a: 1, b: 2, c: 3, d: 4}
```
In the example above, we define an array myArray and an object myObject, both containing the same set of values. We access the second value of the array using its index (myArray[1]) and the second property of the object using its name (myObject.b). We then add a new value to the array using the push() method and a new property to the object using dot notation (myObject.d = 4). Finally, we print the modified array and object to the console.
Overall, arrays and objects in JavaScript have different use cases, and it's important to understand their differences and choose the appropriate data structure for your needs.
---
#### How do you add an element to an array in JavaScript?
You can add an element to an array in JavaScript using the push() method, which adds one or more elements to the end of an array and returns the new length of the array. Here's an example:
```javascript
var myArray = [1, 2, 3];
myArray.push(4);
console.log(myArray); // Output: [1, 2, 3, 4]
```
In the example above, we define an array myArray containing three values, and then we add the value 4 to the end of the array using the push() method. We then print the modified array to the console.
You can also add an element to the beginning of an array using the unshift() method, which adds one or more elements to the beginning of an array and returns the new length of the array. Here's an example:
```javascript
var myArray = [2, 3, 4];
myArray.unshift(1);
console.log(myArray); // Output: [1, 2, 3, 4]
```
In the example above, we define an array myArray containing three values, and then we add the value 1 to the beginning of the array using the unshift() method. We then print the modified array to the console.
Finally, you can also add an element to a specific position in an array using the bracket notation ([]) and the index of the position where you want to insert the element. Here's an example:
```javascript
var myArray = [1, 2, 4];
myArray[2] = 3;
console.log(myArray); // Output: [1, 2, 3, 4]
```
In the example above, we define an array myArray containing three values, and then we replace the value at index 2 with the value 3 using bracket notation (myArray[2] = 3). We then print the modified array to the console.
---
#### How do you remove an element from an array in JavaScript?
You can remove an element from an array in JavaScript using the splice() method, which changes the contents of an array by removing or replacing existing elements and/or adding new elements. The splice() method modifies the original array in place and returns an array containing the removed elements.
The **splice() method** takes two parameters: the index of the element to remove and the number of elements to remove. Here's an example:
```javascript
var myArray = [1, 2, 3, 4];
var removed = myArray.splice(1, 1);
console.log(myArray); // Output: [1, 3, 4]
console.log(removed); // Output: [2]
```
In the example above, we define an array myArray containing four values, and then we remove the element at index 1 (the second element) using the splice() method with parameters 1 and 1. The method returns an array containing the removed element ([2]). We then print the modified array and the removed element to the console.
You can also remove multiple elements from an array by passing a larger number as the second parameter to the splice() method. For example:
```javascript
var myArray = [1, 2, 3, 4];
var removed = myArray.splice(1, 2);
console.log(myArray); // Output: [1, 4]
console.log(removed); // Output: [2, 3]
```
In the example above, we remove two elements starting at index 1, which removes the second and third elements of the array ([2, 3]). The splice() method returns an array containing the removed elements, and we print both the modified array and the removed elements to the console.
If you don't know the index of the element to remove, but you know its value, you can use the indexOf() method to find the index first, and then use the splice() method to remove the element at that index. For example:
```javascript
var myArray = [1, 2, 3, 4];
var index = myArray.indexOf(3);
if (index !== -1) {
myArray.splice(index, 1);
}
console.log(myArray); // Output: [1, 2, 4]
```
In the example above, we define an array myArray containing four values, and then we use the indexOf() method to find the index of the value 3. If the value is found (i.e., the index is not -1), we remove the element at that index using the splice() method. We then print the modified array to the console.
---
#### What is the DOM in JavaScript?
The Document Object Model (DOM) in JavaScript is a programming interface for web documents. It represents the web page as a structured document or tree-like model where each node of the tree represents an element or an object in the web page such as text, images, forms, and other HTML or XML elements.
JavaScript can interact with the DOM by accessing or manipulating the nodes and their attributes. This allows developers to dynamically modify the content and structure of a web page without having to reload the entire page.
The DOM also provides a set of methods and properties that can be used to add, remove, or modify elements, as well as to respond to user interactions like clicks and key presses.
Overall, the DOM is a powerful tool for creating dynamic and interactive web pages using JavaScript.
---
#### What is an event listener in JavaScript?
An event listener in **JavaScript is a function** that waits for a specific event to occur and then performs an action in response to that event. Events can be actions performed by the user, such as clicking a button or typing a key, or they can be triggered by the browser or other parts of the web page, such as when a page finishes loading.
To add an event listener in JavaScript, you typically use the addEventListener() method. This method takes two arguments: the type of event to listen for (e.g., "click", "keyup", "load") and the function to call when the event occurs.
Here's an example that adds an event listener to a button element:
```javascript
const button = document.querySelector('button');
button.addEventListener('click', function() {
alert('Button clicked!');
});
```
In this example, we select a button element using querySelector(), and then add an event listener for the "click" event using addEventListener(). When the button is clicked, the anonymous function passed as the second argument to addEventListener() will be executed, displaying an alert dialog with the message "Button clicked!".
Event listeners are a powerful tool in JavaScript for creating dynamic and interactive web pages that respond to user input and other events.
---
#### How do you create a class in JavaScript?
In JavaScript, you can create a class using the class keyword. Here is an example of a simple class:
```javascript
class Person {
constructor(name, age) {
this.name = name;
this.age = age;
}
sayHello() {
console.log(`Hello, my name is ${this.name} and I'm ${this.age} years old.`);
}
}
```
In this example, we define a Person class with a constructor that takes two parameters, name and age. Inside the constructor, we initialize two instance variables (this.name and this.age) with the values passed in as parameters.
We also define a sayHello() method that logs a greeting message to the console, using the instance variables this.name and this.age.
To create a new instance of the Person class, we can use the new keyword, like this:
```javascript
const person1 = new Person('Alice', 25);
person1.sayHello(); // output: "Hello, my name is Alice and I'm 25 years old."
```
In this example, we create a new instance of the Person class named person1, passing in the values 'Alice' and 25 for the name and age parameters, respectively. We then call the sayHello() method on the person1 object, which logs the greeting message to the console.
Classes in JavaScript provide a way to define reusable templates for objects with similar properties and behaviors. They are an important feature of object-oriented programming in JavaScript.
---
#### What is inheritance in JavaScript?
Inheritance in JavaScript is a mechanism that allows one class to inherit properties and methods from another class. This helps to promote code reuse and make object-oriented programming more efficient.
In JavaScript, inheritance is implemented using the extends keyword. Here's an example:
```javascript
class Animal {
constructor(name) {
this.name = name;
}
speak() {
console.log(`${this.name} makes a noise.`);
}
}
class Dog extends Animal {
speak() {
console.log(`${this.name} barks.`);
}
}
const dog = new Dog('Fido');
dog.speak(); // output: "Fido barks."
```
In this example, we define an Animal class with a constructor() method that takes a name parameter and initializes an instance variable this.name with the value passed in. We also define a speak() method that logs a message to the console.
We then define a Dog class that extends the Animal class using the extends keyword. This means that the Dog class inherits the properties and methods of the Animal class. In this case, we override the speak() method of the Animal class with a new implementation that logs a different message.
Finally, we create a new instance of the Dog class and call its speak() method, which outputs "Fido barks.".
Inheritance in JavaScript is a powerful tool for creating hierarchies of classes that share common properties and behaviors. It allows developers to write more efficient and maintainable code by avoiding duplication and promoting code reuse.
---
#### How do you implement inheritance in JavaScript?
In JavaScript, you can implement inheritance using the extends keyword to create a child class that inherits properties and methods from a parent class. Here's an example:
```javascript
class Animal {
constructor(name) {
this.name = name;
}
speak() {
console.log(`${this.name} makes a noise.`);
}
}
class Dog extends Animal {
constructor(name) {
super(name); // call the constructor of the parent class
}
speak() {
console.log(`${this.name} barks.`);
}
}
const dog = new Dog('Fido');
dog.speak(); // output: "Fido barks."
```
In this example, we define an Animal class with a constructor and a speak() method. We also define a Dog class that extends the Animal class using the extends keyword. We override the speak() method of the Animal class with a new implementation that logs a different message.
To create an instance of the Dog class, we call its constructor with a name parameter. In the constructor, we call the constructor of the parent class using the super() method to initialize the name property.
When we call the speak() method on the dog object, it calls the speak() method of the Dog class, which overrides the speak() method of the Animal class and logs the message "Fido barks." to the console.
By using inheritance, we can create classes that reuse the properties and methods of parent classes, while also allowing us to customize their behavior in child classes.
---
#### What is a module in JavaScript?
A module in JavaScript is a self-contained piece of code that defines variables, functions, or classes that can be reused in other parts of a program. Modules help to organize code into smaller, more manageable pieces and promote code reuse across different parts of a project.
In JavaScript, modules are implemented using the export and import keywords. The export keyword is used to export a variable, function, or class from a module, and the import keyword is used to import it into another module. Here's an example:
```javascript
// module.js
export const PI = 3.14;
export function square(x) {
return x * x;
}
export class Circle {
constructor(radius) {
this.radius = radius;
}
area() {
return PI * this.radius * this.radius;
}
}
```
In this example, we define a module named module.js that exports three things: a constant PI, a function square, and a class Circle.
To use these exports in another module, we can use the import statement, like this:
```javascript
// main.js
import { PI, square, Circle } from './module.js';
console.log(PI); // output: 3.14
console.log(square(5)); // output: 25
const circle = new Circle(10);
console.log(circle.area()); // output: 314
```
In this example, we import the PI, square, and Circle exports from the module.js module using the import statement. We then use them in the main.js module to log the value of PI, call the square() function, and create a new instance of the Circle class.
By using modules in JavaScript, we can create reusable code that is easy to maintain and update.
---
#### How do you create a module in JavaScript?
To create a module in JavaScript, you can use the export keyword to export variables, functions, or classes from the module, and then use the import keyword to import them into another module. Here's an example:
```javascript
// module.js
export const PI = 3.14;
export function square(x) {
return x * x;
}
export class Circle {
constructor(radius) {
this.radius = radius;
}
area() {
return PI * this.radius * this.radius;
}
}
```
In this example, we define a module named module.js that exports three things: a constant PI, a function square, and a class Circle. We use the export keyword before each variable, function, or class declaration to make it available for import into other modules.
To use the exports in another module, we can use the import statement, like this:
```javascript
// main.js
import { PI, square, Circle } from './module.js';
console.log(PI); // output: 3.14
console.log(square(5)); // output: 25
const circle = new Circle(10);
console.log(circle.area()); // output: 314
```
In this example, we import the PI, square, and Circle exports from the module.js module using the import statement. We then use them in the main.js module to log the value of PI, call the square() function, and create a new instance of the Circle class.
By using modules in JavaScript, we can create reusable code that is easy to maintain and update.
---
#### What is the difference between synchronous and asynchronous module loading in JavaScript?
In JavaScript, module loading can be done synchronously or asynchronously.
Synchronous module loading blocks the execution of the program until the module is loaded. When a module is loaded synchronously, the program waits for the module to be fully loaded and evaluated before it continues executing. This means that the execution of the program can be delayed until the module is loaded. Synchronous module loading is the default behavior in most JavaScript environments.
On the other hand, asynchronous module loading does not block the execution of the program. When a module is loaded asynchronously, the program continues to execute while the module is being loaded. This means that other code can be executed while the module is being loaded. Asynchronous module loading is typically used in large applications where performance is critical.
Asynchronous module loading is commonly implemented using the import() function in JavaScript. The import() function returns a Promise that resolves to the module exports when the module is loaded. Here's an example:
```javascript
// main.js
import('./module.js')
.then((module) => {
console.log(module.PI); // output: 3.14
})
.catch((error) => {
console.error(error);
});
```
In this example, we use the import() function to load the module.js module asynchronously. The import() function returns a Promise that resolves to the module exports when the module is loaded. We use the then() method to access the exported values from the module.
By using asynchronous module loading, we can improve the performance of our application by loading modules in the background while other code is being executed. However, it's important to note that asynchronous module loading can make the code more complex and harder to debug.
---
#### What is a promise in JavaScript?
In JavaScript, a promise is an object that represents the eventual completion (or failure) of an asynchronous operation and its resulting value. Promises are used to handle asynchronous operations in a more readable and maintainable way.
A promise has three states:
**Pending:** The initial state of a promise. The promise is neither fulfilled nor rejected.
**Fulfilled:** The state of a promise when the asynchronous operation is completed successfully. The promise has a resulting value.
**Rejected:** The state of a promise when the asynchronous operation fails. The promise has a reason for failure.
A promise is created using the Promise constructor. The Promise constructor takes a single argument, a function called the executor function. The executor function takes two parameters, resolve and reject. The resolve function is used to fulfill the promise with a value, while the reject function is used to reject the promise with a reason.
Here's an example of creating a promise in JavaScript:
```javascript
const myPromise = new Promise((resolve, reject) => {
// Perform an asynchronous operation
// ...
if (/* operation successful */) {
resolve('Success!');
} else {
reject('Error!');
}
});
```
In this example, we create a promise that performs an asynchronous operation. If the operation is successful, we use the resolve function to fulfill the promise with the value 'Success!'. If the operation fails, we use the reject function to reject the promise with the reason 'Error!'.
We can handle the fulfillment or rejection of a promise using the then() and catch() methods. The then() method is called when the promise is fulfilled, and the catch() method is called when the promise is rejected. Here's an example:
```javascript
myPromise
.then((result) => {
console.log(result); // output: Success!
})
.catch((error) => {
console.error(error); // output: Error!
});
```
In this example, we use the then() method to handle the fulfillment of the promise. If the promise is fulfilled, the result parameter of the then() callback function will contain the fulfilled value ('Success!' in this case). If the promise is rejected, the catch() method will be called with the reason for rejection ('Error!' in this case).
---
#### How do you create a promise in JavaScript?
In JavaScript, a promise is created using the Promise constructor. The Promise constructor takes a single argument, a function called the executor function. The executor function takes two parameters, resolve and reject. The resolve function is used to fulfill the promise with a value, while the reject function is used to reject the promise with a reason.
Here's an example of creating a promise in JavaScript:
```javascript
const myPromise = new Promise((resolve, reject) => {
// Perform an asynchronous operation
// ...
if (/* operation successful */) {
resolve('Success!');
} else {
reject('Error!');
}
});
```
In this example, we create a promise that performs an asynchronous operation. If the operation is successful, we use the resolve function to fulfill the promise with the value 'Success!'. If the operation fails, we use the reject function to reject the promise with the reason 'Error!'.
We can also use the Promise.resolve() and Promise.reject() methods to create a fulfilled or rejected promise, respectively:
```javascript
const fulfilledPromise = Promise.resolve('Success!'); // creates a fulfilled promise
const rejectedPromise = Promise.reject('Error!'); // creates a rejected promise
```
In this example, fulfilledPromise is a fulfilled promise with the value 'Success!', while rejectedPromise is a rejected promise with the reason 'Error!'.
---
#### How do you handle errors in a promise in JavaScript?
In JavaScript, errors in a promise can be handled using the **catch() method,** which is called when the promise is rejected. The catch() method takes a single parameter, a callback function that will be called with the reason for rejection.
Here's an example of handling errors in a promise:
```javascript
const myPromise = new Promise((resolve, reject) => {
// Perform an asynchronous operation
// ...
if (/* operation successful */) {
resolve('Success!');
} else {
reject(new Error('Error!'));
}
});
myPromise
.then((result) => {
console.log(result); // output: Success!
})
.catch((error) => {
console.error(error); // output: Error!
});
```
In this example, we create a promise that performs an asynchronous operation. If the operation is successful, we use the resolve function to fulfill the promise with the value 'Success!'. If the operation fails, we use the reject function to reject the promise with an Error object.
We handle the rejection of the promise using the catch() method. If the promise is rejected, the error parameter of the catch() callback function will contain the reason for rejection (an Error object in this case). We can then handle the error in any way we choose, such as logging it to the console or displaying an error message to the user.
It's important to always include error handling when working with promises, as unhandled errors can cause the application to crash or behave unexpectedly.
---
#### What is the difference between resolve and reject in a promise in JavaScript?
In JavaScript, a promise can be in one of two states: fulfilled or rejected. The resolve() and reject() methods are used to transition a promise from its pending state to either a fulfilled or rejected state, respectively.
The **resolve() method is used to fulfill** a promise with a value. When a promise is fulfilled, any then() methods chained to it will be called with the fulfilled value as the parameter. Here's an example:
```javascript
const myPromise = new Promise((resolve, reject) => {
// Perform an asynchronous operation
// ...
if (/* operation successful */) {
resolve('Success!');
} else {
reject(new Error('Error!'));
}
});
myPromise
.then((result) => {
console.log(result); // output: Success!
})
.catch((error) => {
console.error(error); // output: Error!
});
```
In this example, we create a promise that performs an asynchronous operation. If the operation is successful, we use the resolve function to fulfill the promise with the value 'Success!'.
The **reject() method, on the other hand, is used to reject a promise** with a reason (typically an Error object). When a promise is rejected, any catch() methods chained to it will be called with the rejected reason as the parameter. Here's an example:
```javascript
const myPromise = new Promise((resolve, reject) => {
// Perform an asynchronous operation
// ...
if (/* operation successful */) {
resolve('Success!');
} else {
reject(new Error('Error!'));
}
});
myPromise
.then((result) => {
console.log(result); // output: Success!
})
.catch((error) => {
console.error(error); // output: Error!
});
```
In this example, we create a promise that performs an asynchronous operation. If the operation fails, we use the reject function to reject the promise with an Error object.
In summary, the resolve() method is used to fulfill a promise with a value, while the reject() method is used to reject a promise with a reason (typically an Error object).
---
#### What is the difference between then and catch in a promise in JavaScript?
In JavaScript, the then() and catch() methods are used to handle the result of a promise after it has been fulfilled or rejected, respectively.
The then() method is used to handle the fulfilled result of a promise. It takes two callback functions as parameters: the first is called if the promise is fulfilled, and the second is called if the promise is rejected. Here's an example:
```javascript
const myPromise = new Promise((resolve, reject) => {
// Perform an asynchronous operation
// ...
if (/* operation successful */) {
resolve('Success!');
} else {
reject(new Error('Error!'));
}
});
myPromise
.then((result) => {
console.log(result); // output: Success!
})
.catch((error) => {
console.error(error); // output: Error!
});
```
In this example, we create a promise that performs an asynchronous operation. If the operation is successful, we use the resolve function to fulfill the promise with the value 'Success!'. We handle the fulfilled result of the promise using the then() method, passing in a callback function that will be called with the fulfilled value as its parameter.
The catch() method, on the other hand, is used to handle the rejected result of a promise. It takes a single callback function as its parameter, which will be called if the promise is rejected. Here's an example:
```javascript
const myPromise = new Promise((resolve, reject) => {
// Perform an asynchronous operation
// ...
if (/* operation successful */) {
resolve('Success!');
} else {
reject(new Error('Error!'));
}
});
myPromise
.then((result) => {
console.log(result); // output: Success!
})
.catch((error) => {
console.error(error); // output: Error!
});
```
In this example, we create a promise that performs an asynchronous operation. If the operation fails, we use the reject function to reject the promise with an Error object. We handle the rejected result of the promise using the catch() method, passing in a callback function that will be called with the rejected reason (an Error object in this case) as its parameter.
In summary, the then() method is used to handle the fulfilled result of a promise, while the catch() method is used to handle the rejected result of a promise.
---
#### What is the difference between a callback and a promise in JavaScript?
Both callbacks and promises are used in JavaScript to handle asynchronous operations. However, there are some key differences between the two:
**Callback:** A callback is a function that is passed as an argument to another function and is executed when that function has completed its task. Callbacks have been used in JavaScript for a long time to handle asynchronous operations. The main problem with callbacks is that when multiple callbacks are involved, it can lead to what is called **"callback hell" or "pyramid of doom"**, where the code becomes difficult to read and maintain.
**Promise:** A promise is an object that represents the eventual completion or failure of an asynchronous operation and its resulting value. Promises were introduced in **ECMAScript 6** as a way to simplify the handling of asynchronous operations in JavaScript. Promises provide a cleaner and more structured way of handling asynchronous code. Promises allow you to chain multiple asynchronous operations together without creating nested callbacks.
Here is an example that demonstrates the difference between a callback and a promise:
```javascript
// Using a callback
function fetchData(callback) {
setTimeout(() => {
callback('Data');
}, 1000);
}
fetchData((data) => {
console.log(data); // output: Data
});
// Using a promise
function fetchData() {
return new Promise((resolve, reject) => {
setTimeout(() => {
resolve('Data');
}, 1000);
});
}
fetchData().then((data) => {
console.log(data); // output: Data
});
```
In the above example, fetchData is a function that simulates an asynchronous operation by using setTimeout. When the operation completes, it calls the callback function with the result in the case of the first example or the resolve function in the case of the second example. In the callback example, the fetchData function is called with a callback function that logs the data to the console. In the promise example, the fetchData function returns a promise that resolves with the data, and the then method is used to handle the result of the promise.
In summary, while callbacks have been used for a long time in JavaScript to handle asynchronous operations, promises provide a cleaner and more structured way of handling asynchronous code, allowing you to chain multiple asynchronous operations together without creating nested callbacks.
---
#### How do you use the fetch API to make an HTTP request in JavaScript?
The fetch API is a modern way of making HTTP requests in JavaScript. It is a built-in function in the web browser and can be used to make requests to a server and receive the response. Here's an example of how to use the fetch API to make an HTTP GET request:
```javascript
fetch('https://jsonplaceholder.typicode.com/posts/1')
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error(error));
```
In the above example, we are making a GET request to the JSONPlaceholder API to get a single post with an ID of 1.
The fetch function takes a URL as its argument and returns a Promise that resolves with the Response object representing the response to the request.
We then call the json() method on the response object to convert the response to a JSON object. This also returns a Promise.
We then chain another then method to handle the resulting data. In this case, we log the data to the console.
Finally, we use the catch method to handle any errors that may occur during the request.
You can also use the fetch API to make other types of requests, such as POST, PUT, and DELETE, by passing in additional options to the fetch function. Here's an example of how to make a POST request with fetch:
```javascript
fetch('https://jsonplaceholder.typicode.com/posts', {
method: 'POST',
body: JSON.stringify({
title: 'foo',
body: 'bar',
userId: 1,
}),
headers: {
'Content-type': 'application/json; charset=UTF-8',
},
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error(error));
```
In this example, we're making a POST request to the JSONPlaceholder API to create a new post. We pass in an options object as the second argument to the fetch function, which includes the request method, the request body, and the request headers. We're also using the JSON.stringify() method to convert the request body to a JSON string.
---
#### What is a closure in JavaScript?
In JavaScript, **a closure is a function that has access to variables in its outer (enclosing) function**, even after that outer function has returned. The inner function has access to the outer function's variables and parameters, as well as to the global scope.
A closure is created when a function is defined inside another function, and the inner function is returned or passed as an argument to another function. The outer function acts as a container for the inner function and its variables, and when the outer function is called, the inner function is created along with its closure.
Here's an example:
```javascript
function outerFunction(x) {
return function innerFunction(y) {
return x + y;
};
}
var closure = outerFunction(10);
console.log(closure(5)); // Output: 15
```
In this example, outerFunction takes a parameter x, and returns an inner function innerFunction that takes a parameter y. When outerFunction is called with an argument of 10, it returns innerFunction with a closure that includes the value of x.
We then assign the returned function to a variable closure. When we call closure with an argument of 5, it uses the value of x from its closure and returns 15.
Closures are often used to create private variables and functions in JavaScript. Since the inner function has access to the outer function's variables, but the outer function's variables are not accessible outside of the closure, we can use closures to create encapsulated code that can't be modified or accessed from outside the function.
---
#### How do you use closures in JavaScript?
Closures in JavaScript are created when a function is defined inside another function, and the inner function has access to the variables and parameters of the outer function. Here are some examples of how to use closures in JavaScript:
Creating private variables and functions:
```javascript
function counter() {
var count = 0;
return {
increment: function() {
count++;
},
decrement: function() {
count--;
},
getCount: function() {
return count;
}
};
}
var c = counter();
c.increment();
c.increment();
c.decrement();
console.log(c.getCount()); // Output: 1
```
In this example, the counter function returns an object with three methods: increment, decrement, and getCount. The count variable is declared inside the counter function and is not accessible outside of it. However, the returned object has closures that allow it to access the count variable and modify it. This creates a counter that can be incremented and decremented, but its value cannot be accessed or modified directly.
**Avoiding global variables:**
```javascript
(function() {
var name = 'John';
function sayHello() {
console.log('Hello ' + name);
}
window.sayHello = sayHello;
})();
sayHello(); // Output: Hello John
```
In this example, an immediately-invoked function expression (IIFE) is used to create a closure that encapsulates the name variable and the sayHello function. The sayHello function is then assigned to the global window object, allowing it to be called from anywhere in the program. This prevents the name variable from being accessed or modified from outside the closure.
**Memoizing expensive function calls:**
```javascript
function fibonacci() {
var cache = {};
return function(n) {
if (n in cache) {
return cache[n];
} else {
if (n < 2) {
return n;
} else {
cache[n] = fibonacci(n - 1) + fibonacci(n - 2);
return cache[n];
}
}
};
}
var fib = fibonacci();
console.log(fib(10)); // Output: 55
```
In this example, the fibonacci function returns an inner function that uses a closure to cache the results of previous function calls. This memoization technique improves the performance of the function by avoiding the need to recalculate the same values multiple times.
These are just a few examples of how closures can be used in JavaScript. Closures are a powerful feature of the language and can be used in many different ways to create encapsulated code, avoid global variables, and improve performance.
---
#### What is a callback function in JavaScript?
In JavaScript, a **callback function is a function that is passed as an argument to another function and is called by that function at a later time.** The purpose of a callback function is to provide a way for one function to execute code in another function.
Here's an example of a callback function in JavaScript:
```javascript
function printWithDelay(text, delay, callback) {
setTimeout(function() {
console.log(text);
callback();
}, delay);
}
function sayHello() {
console.log('Hello!');
}
printWithDelay('Hi there!', 2000, sayHello);
```
In this example, the printWithDelay function takes three arguments: a text string, a delay time in milliseconds, and a callback function. The setTimeout method is used to delay the execution of the function for the specified amount of time. When the timeout expires, the text string is printed to the console, and the callback function is called.
The sayHello function is passed as the callback argument to the printWithDelay function. When the timeout expires, the sayHello function is executed, and the message "Hello!" is printed to the console.
Callback functions are commonly used in asynchronous programming to handle events, process data, or perform other operations that take time to complete. They allow code to be executed in response to an event or after a long-running operation has finished, without blocking the execution of the program.
---
#### How do you use a callback function in JavaScript?
In JavaScript, you can use a callback function by passing it as an argument to another function, which will then call the callback function at a later time. Here's an example:
```javascript
function myFunction(param1, param2, callback) {
// Perform some operation using param1 and param2
let result = param1 + param2;
// Call the callback function with the result as an argument
callback(result);
}
// Define a callback function
function myCallback(result) {
console.log('The result is: ' + result);
}
// Call myFunction and pass the callback function as an argument
myFunction(5, 10, myCallback);
```
In this example, the myFunction function takes three arguments: param1, param2, and callback. It performs an operation using param1 and param2, and then calls the callback function with the result as an argument.
The myCallback function is defined separately and takes a single argument result. When it is called by myFunction, it simply logs the result to the console.
Finally, myFunction is called with the values 5 and 10 for param1 and param2, respectively, and myCallback is passed as the callback argument. When myFunction is executed, it performs the operation, calculates the result (15), and then calls myCallback with the result as an argument. The myCallback function logs the result to the console, and the program finishes executing.
---
#### What is the difference between a callback function and a promise in JavaScript?
In JavaScript, callback functions and promises are two different ways to handle asynchronous operations, but they have some important differences.
A callback function is a function that is passed as an argument to another function and is called by that function when an operation is completed. Callback functions are commonly used to handle asynchronous operations, such as fetching data from a server or performing a long-running computation.
On the other hand, a promise is an object that represents the eventual completion (or failure) of an asynchronous operation and allows you to handle the result of the operation in a more structured way. Promises have three states: pending, fulfilled, or rejected, and you can attach callbacks to these states using the methods then() and catch().
Here are some of the key differences between callback functions and promises:
Callback functions can be error-prone and difficult to manage, especially when dealing with multiple asynchronous operations. Promises provide a more structured and predictable way to handle asynchronous operations.
Promises allow you to chain multiple operations together and handle errors in a more concise and structured way. Callback functions can make this more difficult, especially when dealing with deeply nested functions.
Promises provide a way to handle asynchronous operations that is more similar to synchronous code, making it easier to understand and reason about. Callback functions can make code harder to read and understand, especially when dealing with complex control flow.
In summary, while both callback functions and promises are useful for handling asynchronous operations in JavaScript, promises provide a more structured and predictable way to handle these operations, making them easier to manage and reason about.
---
#### What is the difference between let, const and var in JavaScript?
In JavaScript, let, const, and var are all used to declare variables, but they differ in terms of their scope, hoisting behavior, and mutability.
**var:**
Variables declared with var are function-scoped, meaning that they are accessible within the function in which they are declared, or globally if they are declared outside of a function.
var variables are also hoisted to the top of their scope, which means that they can be accessed before they are declared.
var variables can be reassigned and their values can be changed.
Example:
```javascript
function example() {
var x = 10;
if (true) {
var x = 20;
console.log(x); // Output: 20
}
console.log(x); // Output: 20
}
example();
```
**let:**
Variables declared with let are block-scoped, meaning that they are accessible only within the block in which they are declared (including any nested blocks).
let variables are not hoisted, which means that they cannot be accessed before they are declared.
let variables can be reassigned but not redeclared within the same scope.
Example:
```javascript
function example() {
let x = 10;
if (true) {
let x = 20;
console.log(x); // Output: 20
}
console.log(x); // Output: 10
}
example();
```
**const:**
Variables declared with const are also block-scoped, meaning that they are accessible only within the block in which they are declared (including any nested blocks).
const variables are not hoisted, which means that they cannot be accessed before they are declared.
const variables cannot be reassigned or redeclared within the same scope.
Example:
```javascript
function example() {
const x = 10;
if (true) {
const x = 20;
console.log(x); // Output: 20
}
console.log(x); // Output: 10
}
example();
```
---
#### What is the difference between a function declaration and a function expression in JavaScript?
In JavaScript, there are two ways to define functions: function declarations and function expressions. Although they both create functions, there are some important differences between them.
**Function Declaration:**
A function declaration is a statement that defines a function with a specified name. It consists of the function keyword, followed by the function name, a list of parameters (wrapped in parentheses), and the function body (wrapped in curly braces).
Example:
```javascript
function add(x, y) {
return x + y;
}
```
**Function Expression:**
A function expression is an expression that defines a function and assigns it to a variable or a property of an object. It consists of the function keyword, followed by an optional name (if you omit the name, it is called an anonymous function), a list of parameters (wrapped in parentheses), and the function body (wrapped in curly braces).
Example:
```javascript
const add = function(x, y) {
return x + y;
}
```
**Differences:**
+ Function declarations are hoisted, which means that they are available for use before the execution of the code starts, whereas function expressions are not hoisted.
+ Function declarations are statements and can be used anywhere a statement can be used, whereas function expressions are used as values and can be used wherever a value can be used (e.g., as arguments to other functions).
+ Function declarations must have a name, whereas function expressions can be anonymous (i.e., have no name).
+ Function declarations can be called before they are defined, whereas function expressions can only be called after they are defined.
--
#### What is hoisting in JavaScript?
Hoisting is a JavaScript mechanism where variables and function declarations are moved to the top of their respective scopes (either global or local) before the code is executed. This means that they are available for use before they are declared.
However, it is important to note that only the declarations are hoisted, not the assignments. For example, if a variable is declared and assigned a value later in the code, only the declaration will be hoisted to the top of the scope, not the assignment.
**Hoisting occurs in two phases:** the creation phase and the execution phase. During the creation phase, the JavaScript engine creates the global object, sets up memory space for variables and functions, and assigns default values to them. In the case of variables, their values are set to undefined.
During the execution phase, the code is executed line by line, and variables are assigned their actual values. Functions, however, are fully hoisted during the creation phase, meaning that they can be called anywhere in the code, even before their declaration.
Here is an example of hoisting in action:
```javascript
console.log(x); // Output: undefined
var x = 10;
```
In this example, even though the variable x is not declared until the second line, it is still available in the first line because its declaration is hoisted to the top of the scope during the creation phase. However, its value is undefined at that point, because the assignment occurs later in the code during the execution phase.
It is generally considered a good practice to declare variables and functions at the beginning of their respective scopes, to avoid any confusion or unexpected behavior due to hoisting.
---
#### What is the difference between an arrow function and a regular function in JavaScript?
In JavaScript, there are two ways to define functions: regular functions and arrow functions. Although they both create functions, there are some important differences between them.
Arrow functions were introduced in **ES6 as a shorthand syntax** for creating functions. Here are some of the key differences:
**Syntax:**
Regular functions use the function keyword followed by the function name, parameter list (wrapped in parentheses), and the function body (wrapped in curly braces).
```javascript
function add(x, y) {
return x + y;
}
```
Arrow functions use an arrow (=>) instead of the function keyword, and the parameter list and function body can be written in different ways depending on the complexity of the function.
```javascript
const add = (x, y) => x + y;
```
**this keyword:**
In a regular function, the value of this is determined by how the function is called, which can lead to some confusion or unexpected behavior.
In an arrow function, this is lexically bound, meaning that it is set to the value of this in the surrounding context, which is usually the parent scope. This can make arrow functions easier to reason about and can help prevent some common errors.
**arguments object:**
In a regular function, the arguments object is an array-like object that contains all of the arguments passed to the function.
In an arrow function, the arguments object is not available, which can be an advantage or a disadvantage depending on the situation.
**Usage:**
Regular functions can be used for any type of function, while arrow functions are particularly useful for shorter functions that don't require complex logic or multiple lines of code.
Here's an example of a regular function and an arrow function that do the same thing:
```javascript
// Regular function
function multiply(x, y) {
return x * y;
}
// Arrow function
const multiply = (x, y) => x * y;
```
Ultimately, the choice between regular functions and arrow functions depends on the specific use case and personal preference.
---
#### What is a generator function in JavaScript?
A generator function is a special type of function in JavaScript that allows you to **control the iteration over a sequence of values.** When a generator function is called, it returns a generator object, which can be used to generate a series of values on demand, rather than all at once.
Generator functions are defined using the function* syntax (note the asterisk). They use the yield keyword to define the sequence of values to be returned. Each time the yield keyword is encountered, the function returns the current value and "pauses" execution, allowing the calling code to resume the iteration when it's ready.
Here's an example of a simple generator function:
```javascript
function* generateNumbers() {
yield 1;
yield 2;
yield 3;
}
const generator = generateNumbers();
console.log(generator.next()); // Output: { value: 1, done: false }
console.log(generator.next()); // Output: { value: 2, done: false }
console.log(generator.next()); // Output: { value: 3, done: false }
console.log(generator.next()); // Output: { value: undefined, done: true }
```
In this example, the generateNumbers function is defined as a generator function, and it yields the values 1, 2, and 3. The const generator variable is assigned the result of calling the generateNumbers function, which returns a generator object.
Each time the generator.next() method is called, the generator function resumes execution from the point where it left off, and returns the next value in the sequence, along with a done property that indicates whether there are more values to be generated.
Generator functions can also be used to implement infinite sequences or generate values based on external events, making them a powerful tool in JavaScript.
---
#### How do you use a generator function in JavaScript?
To use a generator function in JavaScript, you first need to define the generator function using the **function* syntax**. Inside the generator function, you can use the yield keyword to return values one at a time.
Here's an example of a generator function that generates an infinite sequence of random numbers:
```javascript
function* randomNumbers() {
while (true) {
yield Math.random();
}
}
```
In this example, the randomNumbers function is defined as a generator function using the function* syntax. Inside the function, there is a while loop that generates an infinite sequence of random numbers using the Math.random() function and yields each value using the yield keyword.
To use the randomNumbers generator function, you can create an instance of the generator using the function name followed by parentheses, just like calling a regular function. This will return a generator object, which you can use to iterate over the sequence of values using the next() method.
Here's an example of how you could use the randomNumbers generator function to generate five random numbers:
```javascript
const generator = randomNumbers();
for (let i = 0; i < 5; i++) {
console.log(generator.next().value);
}
```
In this example, the const generator variable is assigned the result of calling the randomNumbers generator function, which returns a generator object.
Inside the for loop, the generator.next() method is called to generate the next value in the sequence. The value property of the result contains the current value of the sequence, and the done property indicates whether there are more values to be generated.
This code will generate five random numbers and output them to the console.
```javascript
0.08127449766676712
0.7160689557201538
0.9663585278550099
0.350323771249771
0.6567341319190859
```
---
#### What is the difference between call, apply and bind in JavaScript?
In JavaScript, call, apply, and bind are methods that allow you to set the this value and pass arguments to a function.
**The main differences between them are:**
call and apply are used to invoke a function immediately, while bind returns a new function with the this value and arguments bound.
call and apply take the this value as the first argument, while bind takes the this value as the first argument and allows you to pass additional arguments.
apply takes an array of arguments, while call takes a list of arguments.
Here's an example of how to use call, apply, and bind:
```javascript
const obj = { name: 'Alice' };
function sayHello(message, punctuation) {
console.log(`${message}, ${this.name}${punctuation}`);
}
// Using call:
sayHello.call(obj, 'Hello', '!'); // Output: "Hello, Alice!"
// Using apply:
sayHello.apply(obj, ['Hi', '?']); // Output: "Hi, Alice?"
// Using bind:
const boundSayHello = sayHello.bind(obj, 'Hey');
boundSayHello('!!!'); // Output: "Hey, Alice!!!"
```
In this example, the sayHello function is defined with two arguments: message and punctuation. Inside the function, it uses this.name to access the name property of the object passed as this.
To call the sayHello function with a specific this value and set arguments, you can use call or apply. call takes the this value as the first argument, followed by the arguments to the function. apply takes the this value as the first argument and an array of arguments to the function.
To create a new function with a bound this value and arguments, you can use bind. bind takes the this value as the first argument, followed by the arguments to the function. It returns a new function with the this value and arguments bound, which can be called later.
In this example, the sayHello function is called three times using call, apply, and bind, respectively, with different arguments. The this value is set to the obj object, which has a name property of 'Alice'. The output shows the result of calling the function with the specified arguments and this value.
---
#### How do you use call, apply and bind in JavaScript?
In JavaScript, call, apply, and bind are methods that allow you to set the this value and pass arguments to a function.
Here's an example of how to use call, apply, and bind:
```javascript
const obj = { name: 'Alice' };
function sayHello(message, punctuation) {
console.log(`${message}, ${this.name}${punctuation}`);
}
// Using call:
sayHello.call(obj, 'Hello', '!'); // Output: "Hello, Alice!"
// Using apply:
sayHello.apply(obj, ['Hi', '?']); // Output: "Hi, Alice?"
// Using bind:
const boundSayHello = sayHello.bind(obj, 'Hey');
boundSayHello('!!!'); // Output: "Hey, Alice!!!"
```
In this example, the sayHello function is defined with two arguments: message and punctuation. Inside the function, it uses this.name to access the name property of the object passed as this.
To call the sayHello function with a specific this value and set arguments, you can use call or apply. call takes the this value as the first argument, followed by the arguments to the function. apply takes the this value as the first argument and an array of arguments to the function.
To create a new function with a bound this value and arguments, you can use bind. bind takes the this value as the first argument, followed by the arguments to the function. It returns a new function with the this value and arguments bound, which can be called later.
In this example, the sayHello function is called three times using call, apply, and bind, respectively, with different arguments. The this value is set to the obj object, which has a name property of 'Alice'. The output shows the result of calling the function with the specified arguments and this value.
---
#### What is a higher-order function in JavaScript?
In JavaScript, a higher-order function is a function that **takes one or more functions as arguments or returns a function as its result**. This means that higher-order functions can operate on functions themselves, treating them like any other type of data.
Higher-order functions can be used to create more abstract and reusable code, by separating concerns and allowing functions to be composed together in different ways.
For example, consider the map method on arrays, which takes a function as an argument and applies it to each element of the array, returning a new array with the results:
```javascript
const numbers = [1, 2, 3, 4];
const squared = numbers.map(function(num) {
return num * num;
});
console.log(squared); // Output: [1, 4, 9, 16]
```
In this example, the map method is a higher-order function because it takes a function as an argument (in this case, an anonymous function that squares each element of the array). The function is then called for each element of the array, and the results are collected into a new array.
Another example of a higher-order function in JavaScript is setTimeout, which takes a function as its first argument and a number of milliseconds as its second argument. The function is called after the specified delay:
```javascript
function sayHello() {
console.log('Hello!');
}
setTimeout(sayHello, 1000); // Output: "Hello!" (after 1 second)
```
In this example, setTimeout is a higher-order function because it takes a function as its first argument (in this case, the sayHello function). The function is then called after the specified delay of 1000 milliseconds (1 second).
Higher-order functions are a powerful feature of JavaScript and can be used to create more expressive and flexible code.
---
#### How do you use a higher-order function in JavaScript?
In JavaScript, you can use a higher-order function by passing one or more functions as arguments to another function, or by returning a function from a function. Here are a few examples:
Passing a function as an argument:
```javascript
function add(a, b) {
return a + b;
}
function multiply(a, b) {
return a * b;
}
function applyOperation(a, b, operation) {
return operation(a, b);
}
console.log(applyOperation(2, 3, add)); // Output: 5
console.log(applyOperation(2, 3, multiply)); // Output: 6
```
In this example, applyOperation is a higher-order function that takes two numbers and a function as arguments. It then applies the function to the numbers and returns the result. The add and multiply functions are passed as arguments to applyOperation, which then calls them with the numbers 2 and 3, respectively.
Returning a function from a function:
```javascript
function multiplyBy(factor) {
return function(number) {
return number * factor;
};
}
const double = multiplyBy(2);
const triple = multiplyBy(3);
console.log(double(5)); // Output: 10
console.log(triple(5)); // Output: 15
```
In this example, multiplyBy is a higher-order function that takes a number factor and returns a new function that takes another number number and multiplies it by factor. The returned function is a closure that remembers the value of factor. The double and triple functions are created by calling multiplyBy with 2 and 3, respectively. They can then be called with a number to return the result of multiplying the number by 2 or 3.
These are just a few examples of how to use higher-order functions in JavaScript. Higher-order functions are a powerful feature that can make your code more expressive and flexible, and allow you to create more reusable and composable code.
---
#### What is the difference between map, filter and reduce in JavaScript?
In JavaScript, map, filter, and reduce are three commonly used array methods that are used to perform different kinds of operations on arrays.
**map:** The map method creates a new array by calling a function on each element of an existing array, and using the returned value as the corresponding element of the new array. The original array is not modified.
```javascript
const numbers = [1, 2, 3, 4];
const squared = numbers.map(function(num) {
return num * num;
});
console.log(squared); // Output: [1, 4, 9, 16]
```
In this example, the map method is used to create a new array called squared which contains the squares of each element of the original numbers array.
**filter:** The filter method creates a new array by filtering the elements of an existing array based on a condition specified in a function. Only elements that satisfy the condition are included in the new array. The original array is not modified.
```javascript
const numbers = [1, 2, 3, 4];
const even = numbers.filter(function(num) {
return num % 2 === 0;
});
console.log(even); // Output: [2, 4]
```
In this example, the filter method is used to create a new array called even which contains only the even numbers from the original numbers array.
**reduce:** The reduce method reduces an array to a single value by repeatedly calling a function on each element of the array and accumulating the result. The function takes two arguments: an accumulator and the current element of the array. The accumulator is updated on each iteration and its final value is returned as the result of the reduce method.
```javascript
const numbers = [1, 2, 3, 4];
const sum = numbers.reduce(function(accumulator, num) {
return accumulator + num;
}, 0);
console.log(sum); // Output: 10
```
In this example, the reduce method is used to calculate the sum of all the elements of the numbers array.
In summary, the main difference between map, filter, and reduce is the type of operation they perform on an array. map is used to transform each element of an array into a new value, filter is used to select elements from an array based on a condition, and reduce is used to reduce an array to a single value by applying a function to each element.
---
#### How do you use map, filter and reduce in JavaScript?
Here are some examples of how to use map, filter, and reduce in JavaScript:
**map:** To use the map method, you call it on an array and pass in a function as an argument. This function takes the current element of the array as its argument, and should return a new value for that element. The map method returns a new array with the transformed values.
Example: Transform an array of numbers by doubling each element.
```javascript
const numbers = [1, 2, 3, 4];
const doubled = numbers.map(function(num) {
return num * 2;
});
console.log(doubled); // Output: [2, 4, 6, 8]
```
**filter:** To use the filter method, you call it on an array and pass in a function as an argument. This function should return true or false depending on whether the current element should be included in the new array. The filter method returns a new array with only the elements that returned true.
Example: Filter an array of numbers to only include even numbers.
```javascript
const numbers = [1, 2, 3, 4];
const even = numbers.filter(function(num) {
return num % 2 === 0;
});
console.log(even); // Output: [2, 4]
```
**reduce:** To use the reduce method, you call it on an array and pass in a function as an argument. This function takes two arguments: an accumulator and the current element of the array. The function should return the updated value of the accumulator. The reduce method returns the final value of the accumulator.
Example: Calculate the sum of an array of numbers.
```javascript
const numbers = [1, 2, 3, 4];
const sum = numbers.reduce(function(accumulator, num) {
return accumulator + num;
}, 0);
console.log(sum); // Output: 10
```
In this example, the reduce method is called on the numbers array, and the function passed in takes two arguments: an accumulator (initialized as 0), and the current element of the array. On each iteration, the current element is added to the accumulator, and the updated accumulator value is returned. At the end, the final value of the accumulator (which is the sum of all the numbers) is returned.
---
#### What is a curried function in JavaScript?
A curried function in JavaScript is a **function that takes multiple arguments one at a time instead of taking all of its arguments at once.** It works by returning a new function that takes the next argument, and so on until all the arguments have been received and the final result can be returned.
Here's an example of a curried function:
```javascript
function multiply(a) {
return function(b) {
return a * b;
}
}
const double = multiply(2); // returns a new function that multiplies by 2
console.log(double(3)); // Output: 6
```
In this example, multiply is a curried function that takes one argument (a) and returns a new function that takes another argument (b). The new function multiplies a and b together and returns the result.
The double constant is created by calling multiply with the argument 2. This returns a new function that multiplies its argument by 2, which is assigned to the double constant.
Finally, double is called with the argument 3, which results in the value 6 being returned.
Currying can be useful for creating more flexible and reusable functions, as well as for simplifying code and reducing repetition. It allows you to create functions that are more composable and easier to understand.
---
#### How do you use a curried function in JavaScript?
Here's an example of how to use a curried function in JavaScript:
```javascript
function add(a) {
return function(b) {
return a + b;
}
}
const addFive = add(5); // returns a new function that adds 5 to its argument
console.log(addFive(3)); // Output: 8
```
In this example, the add function is a curried function that takes one argument (a) and returns a new function that takes another argument (b). The new function adds a and b together and returns the result.
The addFive constant is created by calling add with the argument 5. This returns a new function that adds its argument to 5, which is assigned to the addFive constant.
Finally, addFive is called with the argument 3, which results in the value 8 being returned.
This example demonstrates the power of currying for creating more flexible and reusable functions. By creating a function that can be partially applied with arguments, you can create more specialized versions of that function that can be used in a variety of situations.
---
#### What is a closure in JavaScript?
In JavaScript, a closure is created whenever a function is defined inside another function. The inner function has access to variables in the outer function's scope, even after the outer function has returned. This allows the inner function to "remember" the state of the outer function's variables at the time it was created.
Here's an example:
```javascript
function outer() {
const message = 'Hello';
function inner() {
console.log(message);
}
return inner;
}
const fn = outer();
fn(); // Output: 'Hello'
```
In this example, outer is a function that defines a local variable message and a nested function inner. inner has access to message even after outer has returned. When outer is called, it returns inner, which is assigned to the fn constant. When fn is called, it logs the value of message to the console.
Closures are powerful because they allow functions to access variables from their parent scope, even if those variables are no longer in scope. This can be useful for creating private variables or functions that can only be accessed by certain code. Closures are also used extensively in functional programming, where they allow functions to be composed together in powerful ways.
---
#### How do you use closures in JavaScript?
Here's an example of how to use closures in JavaScript:
```javascript
function makeCounter() {
let count = 0;
return function() {
count++;
console.log(count);
}
}
const counter = makeCounter();
counter(); // Output: 1
counter(); // Output: 2
counter(); // Output: 3
```
In this example, makeCounter is a function that returns another function. The returned function increments a local variable count each time it is called and logs its value to the console.
When makeCounter is called, it creates a new closure containing the local variable count and the returned function. This closure "remembers" the state of count each time the returned function is called, allowing it to keep track of how many times it has been called.
The counter constant is assigned the returned function from makeCounter. When counter is called, it increments count and logs its value to the console. Each time counter is called, it has access to the closure created by makeCounter, allowing it to access and modify the value of count.
This example demonstrates the power of closures for creating functions that "remember" state and can be used in a variety of situations. By creating a closure with local variables, you can create functions that have private data and can only be accessed in certain ways.
---
#### What is memoization in JavaScript?
Memoization is a technique used in computer science and programming to **speed up the execution of functions by caching the results of expensive function calls and returning the cached result when the same inputs occur again.**
In JavaScript, memoization can be implemented using closures. Here's an example:
```javascript
function memoize(func) {
const cache = {};
return function(...args) {
const key = JSON.stringify(args);
if (cache[key]) {
console.log('Returning cached result');
return cache[key];
}
console.log('Calculating result');
const result = func.apply(null, args);
cache[key] = result;
return result;
}
}
function fib(n) {
if (n <= 1) {
return n;
}
return fib(n - 1) + fib(n - 2);
}
const memoizedFib = memoize(fib);
console.log(memoizedFib(10)); // Output: 55 (calculated)
console.log(memoizedFib(10)); // Output: 55 (cached)
```
In this example, memoize is a higher-order function that takes a function func as an argument and returns a new function that memoizes its results. The memoized function uses a cache object to store the results of expensive function calls.
The fib function is a recursive function that calculates the nth Fibonacci number. When memoizedFib is called with the same input multiple times, the result is cached and returned from the cache on subsequent calls.
This example demonstrates how memoization can be used to optimize the performance of functions that are called frequently with the same input. By caching the results of expensive function calls, you can avoid redundant computation and speed up your code.
---
#### How do you use memoization in JavaScript?
To use memoization in JavaScript, you can create a higher-order function that takes a function as an argument and returns a new function that memoizes its results. Here's an example:
```javascript
function memoize(func) {
const cache = {};
return function(...args) {
const key = JSON.stringify(args);
if (cache[key]) {
console.log('Returning cached result');
return cache[key];
}
console.log('Calculating result');
const result = func.apply(null, args);
cache[key] = result;
return result;
}
}
function add(x, y) {
console.log('Calculating sum');
return x + y;
}
const memoizedAdd = memoize(add);
console.log(memoizedAdd(2, 3)); // Output: Calculating sum, 5
console.log(memoizedAdd(2, 3)); // Output: Returning cached result, 5
console.log(memoizedAdd(4, 5)); // Output: Calculating sum, 9
console.log(memoizedAdd(4, 5)); // Output: Returning cached result, 9
```
In this example, memoize is a higher-order function that takes a function func as an argument and returns a new function that memoizes its results. The memoized function uses a cache object to store the results of expensive function calls.
The add function is a simple function that adds two numbers together. When memoizedAdd is called with the same input multiple times, the result is cached and returned from the cache on subsequent calls.
This example demonstrates how memoization can be used to optimize the performance of functions that are called frequently with the same input. By caching the results of expensive function calls, you can avoid redundant computation and speed up your code.
---
#### What is a decorator function in JavaScript?
A decorator function in JavaScript is a **higher-order function** that takes a function as an argument and returns a new function with added functionality. The decorator function wraps the original function, adding new behavior to it, without modifying its source code.
Here's an example of a decorator function in JavaScript:
```javascript
function logDecorator(func) {
return function() {
console.log('Starting function');
const result = func.apply(null, arguments);
console.log('Ending function');
return result;
}
}
function add(x, y) {
return x + y;
}
const decoratedAdd = logDecorator(add);
console.log(decoratedAdd(2, 3)); // Output: Starting function, Ending function, 5
```
In this example, logDecorator is a decorator function that takes a function func as an argument and returns a new function that logs the start and end of the function. The new function calls the original func function with the same arguments and returns its result.
The add function is a simple function that adds two numbers together. When decoratedAdd is called, it logs the start and end of the function, then calls the original add function with the same arguments and returns its result.
This example demonstrates how a decorator function can be used to add new behavior to an existing function without modifying its source code. By wrapping the original function with a decorator function, you can reuse the original function with added functionality, making it more versatile and easier to maintain.
---
#### How do you use a decorator function in JavaScript?
To use a decorator function in JavaScript, you can create a decorator function that takes a function as an argument and returns a new function with added functionality. Here's an example:
```javascript
function logDecorator(func) {
return function() {
console.log('Starting function');
const result = func.apply(null, arguments);
console.log('Ending function');
return result;
}
}
function add(x, y) {
return x + y;
}
const decoratedAdd = logDecorator(add);
console.log(decoratedAdd(2, 3)); // Output: Starting function, Ending function, 5
```
In this example, logDecorator is a decorator function that takes a function func as an argument and returns a new function that logs the start and end of the function. The new function calls the original func function with the same arguments and returns its result.
The add function is a simple function that adds two numbers together. When decoratedAdd is called, it logs the start and end of the function, then calls the original add function with the same arguments and returns its result.
This example demonstrates how a decorator function can be used to add new behavior to an existing function without modifying its source code. By wrapping the original function with a decorator function, you can reuse the original function with added functionality, making it more versatile and easier to maintain.
---
#### What is event bubbling in JavaScript?
Event bubbling is a concept in JavaScript that describes the way in which **events propagate through the DOM (Document Object Model) tree.** When an event is triggered on a particular element, it is first handled by that element's event listener. Then, the event "bubbles up" through the DOM hierarchy, triggering the event listeners of each ancestor element in turn, until it reaches the top of the tree (the document object).
For example, consider a web page with a nested hierarchy of elements: a div containing a paragraph, which in turn contains a span. If a user clicks on the span element, a "click" event is first handled by the span's event listener. Then, the event bubbles up to the paragraph's event listener, and finally to the div's event listener, and so on until it reaches the document object.
Event bubbling can be useful for event delegation, which allows you to handle events on parent elements rather than on individual child elements. By handling events at a higher level in the DOM tree, you can avoid attaching event listeners to every single child element, which can improve performance and reduce code complexity.
---
#### How do you stop event bubbling in JavaScript?
In JavaScript, you can stop event bubbling using the **stopPropagation()** method of the Event object. This method prevents the event from propagating further up the DOM tree.
Here's an example of how to use stopPropagation() to stop event bubbling:
```javascript
const childElement = document.querySelector('#child-element');
const parentElement = document.querySelector('#parent-element');
childElement.addEventListener('click', function(event) {
event.stopPropagation();
console.log('Child element clicked');
});
parentElement.addEventListener('click', function(event) {
console.log('Parent element clicked');
});
```
In this example, we have two elements: a child element and a parent element. When the child element is clicked, its event listener is triggered first, and we use stopPropagation() to prevent the event from propagating further up the DOM tree. As a result, the parent element's event listener is not triggered.
Note that while stopping event propagation can be useful in some cases, it can also lead to unexpected behavior if not used carefully. Make sure to test thoroughly and consider the implications of stopping event propagation before implementing it in your code.
---
#### What is event delegation in JavaScript?
Event delegation is a technique in JavaScript that allows you to **handle events on parent elements rather than on individual child elements**. When an event is triggered on a child element, the event "bubbles up" to the parent element, where it can be handled by a single event listener. This can be more efficient than attaching event listeners to each individual child element, especially for large or dynamically generated sets of elements.
Here's an example of how to use event delegation in JavaScript:
```javascript
const parentElement = document.querySelector('#parent-element');
parentElement.addEventListener('click', function(event) {
if (event.target && event.target.matches('button')) {
console.log('Button clicked');
}
});
```
In this example, we have a parent element with several child elements (in this case, buttons). We attach an event listener to the parent element and check if the event target matches a certain selector (in this case, the 'button' selector). If the target matches, we handle the event accordingly.
By using event delegation, we can handle events on all child elements with a single event listener, rather than attaching a separate event listener to each button element.
Event delegation can be especially useful for elements that are added to the DOM dynamically, since you don't need to attach an event listener to each new element individually. However, it's important to be mindful of the performance implications of using event delegation for large sets of elements, and to test your code thoroughly to ensure that events are being handled correctly.
---
#### How do you use event delegation in JavaScript?
To use event delegation in JavaScript, you first need to attach an event listener to a parent element that contains the child elements you want to handle events for. When an event is triggered on a child element, the event "bubbles up" to the parent element, where it can be handled by the event listener.
Here's an example of how to use event delegation in JavaScript:
```javascript
const parentElement = document.querySelector('#parent-element');
parentElement.addEventListener('click', function(event) {
if (event.target && event.target.matches('button')) {
console.log('Button clicked');
}
});
```
In this example, we have a parent element with several child elements (in this case, buttons). We attach an event listener to the parent element and check if the event target matches a certain selector (in this case, the 'button' selector). If the target matches, we handle the event accordingly.
By using event delegation, we can handle events on all child elements with a single event listener, rather than attaching a separate event listener to each button element.
Note that you can use any valid CSS selector to match child elements with event targets. You can also use event delegation for any type of event, not just click events.
Event delegation can be especially useful for elements that are added to the DOM dynamically, since you don't need to attach an event listener to each new element individually. However, it's important to be mindful of the performance implications of using event delegation for large sets of elements, and to test your code thoroughly to ensure that events are being handled correctly.
---
#### What is the difference between client-side and server-side JavaScript?
Client-side JavaScript and server-side JavaScript are two distinct environments in which JavaScript code can be executed.
Client-side JavaScript refers to code that is executed in the user's web browser. This can include code that adds interactivity to web pages, such as event handlers, form validation, and animation effects. Client-side JavaScript is typically used to improve the user experience of a web application or website, and it is executed on the client's computer or mobile device.
Server-side JavaScript refers to code that is executed on the server side of a web application. This can include code that generates dynamic web pages, communicates with databases or APIs, and performs other tasks that require access to server resources. Server-side JavaScript is typically used to handle tasks that cannot be performed on the client side, such as processing user input and generating custom content based on user preferences.
One key difference between client-side and server-side JavaScript is that client-side code is executed on the user's device, while server-side code is executed on the server. This means that client-side code can be affected by factors such as the user's browser and device, while server-side code is not.
Another key difference is that client-side code is visible to users and can potentially be modified or hacked, while server-side code is not visible to users and is typically more secure.
Overall, client-side and server-side JavaScript are both important tools for building modern web applications, and understanding their differences and strengths is essential for developing effective and secure web applications.
---
#### What is the difference between an object and a function in JavaScript?
In JavaScript, an object is a collection of key-value pairs, where each key is a string (or symbol) and each value can be any data type, including other objects or functions. Objects can be created using object literals, constructors, or classes.
A function, on the other hand, is a type of object that can be invoked (called) to perform a specific task. Functions can be defined using function declarations, function expressions, arrow functions, or methods (which are functions that are properties of objects).
One key difference between objects and functions is their purpose. Objects are typically used to represent entities or concepts in a program, and can contain properties and methods that describe the characteristics and behavior of those entities. Functions, on the other hand, are used to encapsulate logic and perform specific tasks, such as manipulating data or responding to user input.
Another key difference is how they are invoked. Objects are not invoked directly, but can be used to store and manipulate data or perform actions indirectly through their methods. Functions, on the other hand, are invoked directly using their name and parentheses.
It's also worth noting that functions can be properties of objects, which allows them to be used as methods. In this case, the function is still a function, but it is also a property of an object.
Overall, objects and functions are both important concepts in JavaScript, and understanding their differences is essential for writing effective and efficient code.
---
#### What is a singleton in JavaScript?
In JavaScript, a singleton is a **design pattern that restricts the instantiation of a class to a single instance and provides a global point of access to that instance**. This means that only one instance of the singleton class can exist at a time, and all requests for the singleton return the same instance.
Singletons are typically used in situations where it is important to ensure that only one instance of a class exists, such as managing shared resources or configuration settings. By using a singleton, you can avoid creating unnecessary instances of the class, which can improve performance and reduce the risk of errors.
Here is an example of how to implement a singleton in JavaScript:
```javascript
const Singleton = (function() {
let instance;
function createInstance() {
// Private constructor
const object = new Object('I am the instance');
return object;
}
return {
getInstance: function() {
if (!instance) {
instance = createInstance();
}
return instance;
}
};
})();
const instance1 = Singleton.getInstance();
const instance2 = Singleton.getInstance();
console.log(instance1 === instance2); // true
```
In this example, we define a Singleton object using an immediately invoked function expression (IIFE). The Singleton object contains a private constructor that creates a new object instance, and a public getInstance method that returns the existing instance or creates a new one if it doesn't exist yet.
When we call the getInstance method twice and compare the resulting instances, we can see that they are the same object, since the Singleton pattern ensures that only one instance is created.
Overall, the singleton pattern is a powerful tool for managing shared resources and ensuring that only one instance of a class exists. However, it's important to use singletons judiciously, since they can also introduce global state and create dependencies that are difficult to manage.
---
#### How do you create a singleton in JavaScript?
In JavaScript, you can create a singleton by defining a class or object that restricts the instantiation of the class to a single instance and provides a global point of access to that instance. Here's an example of how to create a singleton using a class:
```javascript
class Singleton {
constructor() {
if (!Singleton.instance) {
Singleton.instance = this;
}
return Singleton.instance;
}
}
const instance1 = new Singleton();
const instance2 = new Singleton();
console.log(instance1 === instance2); // true
```
In this example, we define a Singleton class that checks whether an instance of the class already exists, and returns that instance if it does. If there is no existing instance, the constructor sets the Singleton.instance property to the current instance, effectively creating a new instance.
When we create two instances of the Singleton class and compare them using the strict equality operator (===), we can see that they are the same object, since the Singleton class ensures that only one instance is created.
Overall, creating a singleton in JavaScript involves ensuring that only one instance of a class or object is created, and providing a global point of access to that instance. This can be achieved using a variety of techniques, such as using a static property, a closure, or a self-invoking function.
---
#### What is functional programming in JavaScript?
Functional programming is a programming paradigm that **emphasizes the use of functions to solve problems.** In functional programming, functions are treated as first-class citizens, meaning they can be assigned to variables, passed as arguments to other functions, and returned as values from functions.
In JavaScript, functional programming is supported through a variety of features, including higher-order functions, closures, and anonymous functions. Here are some key principles of functional programming in JavaScript:
**Pure Functions:** A pure function is a function that returns a value based only on its input arguments, without modifying any external state or producing side effects. Pure functions are deterministic, meaning they always produce the same output for the same input.
**Immutability:** Functional programming encourages immutability, or the use of data structures that cannot be modified once they are created. This helps to prevent unexpected side effects and makes it easier to reason about the behavior of functions.
**Higher-Order Functions:** Higher-order functions are functions that take other functions as arguments or return functions as their result. Higher-order functions are a key feature of functional programming, since they allow for the composition of complex functionality from simpler building blocks.
**Recursion:** Recursion is a technique where a function calls itself to solve a problem. Recursion is often used in functional programming to process data structures, since it can provide an elegant way to iterate over collections of data.
Overall, functional programming is a powerful approach to programming that can help to reduce bugs, improve code readability, and make it easier to reason about the behavior of functions. While JavaScript was not originally designed for functional programming, the language has evolved to support many functional programming concepts, making it a popular choice for functional programming enthusiasts.
---
#### How do you write functional programming code in JavaScript?
In JavaScript, there are several ways to write functional programming code. Here are some common techniques:
**Use Pure Functions:** Write functions that take input arguments and return a value, without modifying any external state or producing side effects. Pure functions are deterministic and easy to reason about.
```javascript
// Example of a pure function
function add(x, y) {
return x + y;
}
```
**Use Immutability:** Use data structures that cannot be modified once they are created. This can help to prevent unexpected side effects and make your code easier to reason about.
```javascript
// Example of using immutability with an array
const arr = [1, 2, 3];
const newArr = [...arr, 4]; // creates a new array with 4 added to the end
```
**Use Higher-Order Functions:** Write functions that take other functions as arguments or return functions as their result. This can allow you to compose complex functionality from simpler building blocks.
```javascript
// Example of using a higher-order function
function map(arr, fn) {
const result = [];
for (let i = 0; i < arr.length; i++) {
result.push(fn(arr[i]));
}
return result;
}
const numbers = [1, 2, 3];
const doubledNumbers = map(numbers, x => x * 2);
```
**Use Recursion:** Write functions that call themselves to solve a problem. This can provide an elegant way to iterate over collections of data.
```javascript
// Example of using recursion to calculate the factorial of a number
function factorial(n) {
if (n === 0) {
return 1;
} else {
return n * factorial(n - 1);
}
}
const result = factorial(5); // returns 120
```
Overall, writing functional programming code in JavaScript involves using pure functions, immutability, higher-order functions, recursion, and other functional programming concepts to solve problems. By using these techniques, you can write code that is more modular, easier to test, and less prone to bugs.
---
#### What is the difference between imperative and declarative programming in JavaScript?
Imperative programming is a programming paradigm that **focuses on how to accomplish a task.** It involves explicitly listing out the steps that the program should take to achieve a particular goal. In imperative programming, you often have to manage the state of the program manually, which can lead to code that is difficult to reason about and prone to errors.
Declarative programming, on the other hand, is a programming paradigm that **focuses on what you want the program to accomplish, without specifying how to achieve it.** Instead of listing out the steps, you declare the desired outcome and let the underlying system figure out how to achieve it. Declarative programming is often associated with higher-level abstractions, such as functional programming or SQL, and can lead to more concise, modular, and maintainable code.
In JavaScript, you can see the difference between imperative and declarative programming in the way you write code to solve a problem. Here's an example:
**Imperative Approach:**
```javascript
// Example of imperative approach to finding the sum of an array of numbers
function sum(arr) {
let total = 0;
for (let i = 0; i < arr.length; i++) {
total += arr[i];
}
return total;
}
```
**Declarative Approach:**
```javascript
// Example of declarative approach to finding the sum of an array of numbers
function sum(arr) {
return arr.reduce((acc, cur) => acc + cur, 0);
}
```
In the imperative approach, we are explicitly iterating over the array and keeping track of the total ourselves. In the declarative approach, we are using the reduce() method to declare the desired outcome (the sum of the array) and letting the system handle the details.
Overall, declarative programming can lead to more concise, modular, and maintainable code, while imperative programming can provide more control and fine-grained management of the program state.
---
#### How do you write declarative programming code in JavaScript?
Declarative programming in JavaScript is all about focusing on what you want the program to accomplish, without specifying how to achieve it. Here are some common techniques for writing declarative programming code in JavaScript:
**Use Higher-Order Functions:** Higher-order functions are functions that take other functions as arguments or return functions as their result. This can allow you to compose complex functionality from simpler building blocks. Examples of higher-order functions include map(), filter(), and reduce().
```javascript
// Example of using the map() higher-order function
const numbers = [1, 2, 3];
const doubledNumbers = numbers.map(x => x * 2);
```
**Use Declarative Syntax:** Use declarative syntax when possible, such as template literals, object destructuring, and array destructuring. Declarative syntax can make your code more readable and expressive.
```javascript
// Example of using template literals to construct a string
const name = "Alice";
const greeting = `Hello, ${name}!`;
// Example of using object destructuring to extract properties from an object
const person = { name: "Bob", age: 30 };
const { name, age } = person;
// Example of using array destructuring to extract elements from an array
const numbers = [1, 2, 3];
const [first, second, third] = numbers;
```
**Use Immutability:** Use data structures that cannot be modified once they are created. This can help to prevent unexpected side effects and make your code easier to reason about.
```javascript
// Example of using immutability with an array
const arr = [1, 2, 3];
const newArr = [...arr, 4]; // creates a new array with 4 added to the end
```
**Use Pure Functions:** Write functions that take input arguments and return a value, without modifying any external state or producing side effects. Pure functions are deterministic and easy to reason about.
```javascript
// Example of a pure function
function add(x, y) {
return x + y;
}
```
By using these techniques, you can write code that is more declarative, modular, and easier to reason about.
---
#### What is a monad in JavaScript?
A monad is a design pattern in functional programming that allows you to **chain computations together while encapsulating side effects.** It provides a way to manage the complexity of asynchronous and impure code by providing a consistent way to represent and manipulate data.
In JavaScript, a monad is usually implemented as an object with two key methods: flatMap (also known as bind) and map. The flatMap method allows you to chain computations together, while the map method allows you to apply a function to the underlying data.
Here's an example of a monad in JavaScript:
```javascript
// Example of a simple Maybe monad
class Maybe {
constructor(value) {
this.value = value;
}
flatMap(f) {
if (this.value === null || this.value === undefined) {
return new Maybe(null);
} else {
return f(this.value);
}
}
map(f) {
if (this.value === null || this.value === undefined) {
return new Maybe(null);
} else {
return new Maybe(f(this.value));
}
}
}
// Example usage of the Maybe monad
const maybeOne = new Maybe(1);
const maybeTwo = maybeOne.flatMap(x => new Maybe(x + 1));
const maybeFour = maybeTwo.map(x => x * 2);
console.log(maybeFour.value); // Output: 4
```
In this example, we've defined a simple Maybe monad that can represent values that may or may not be present. We can chain computations together using the flatMap method, and apply transformations using the map method.
Overall, monads can be a powerful way to manage the complexity of asynchronous and impure code in JavaScript, by providing a consistent and composable way to represent and manipulate data. However, they can also be somewhat difficult to understand and use correctly, so they may not be appropriate for every situation.
---
#### How do you use a monad in JavaScript?
To use a monad in JavaScript, you need to create an instance of the monad and then use its methods to chain computations and apply transformations. Here's an example using the Maybe monad from the previous question:
```javascript
// Example usage of the Maybe monad
const maybeOne = new Maybe(1);
const maybeTwo = maybeOne.flatMap(x => new Maybe(x + 1));
const maybeFour = maybeTwo.map(x => x * 2);
console.log(maybeFour.value); // Output: 4
```
In this example, we first create a new instance of the Maybe monad with the value 1. We then use the flatMap method to add 1 to the value, resulting in a new Maybe instance with the value 2. Finally, we use the map method to double the value, resulting in a new Maybe instance with the value 4.
Note that in order to use the Maybe monad, we need to define it first. In this case, we've defined a simple Maybe class with flatMap and map methods, but there are many other monads that can be used in different situations. When working with monads, it's important to understand their behavior and limitations, and to use them appropriately for the problem at hand.
---
#### What is a functor in JavaScript?
In functional programming, a **functor is an object that implements a map method, which allows you to apply a function to the values inside the functor.** Functors are a way to generalize the concept of mapping over a collection to other types of data structures, such as Maybe, Either, and Promise.
In JavaScript, an object is considered a functor if it has a map method that takes a function as its argument, and returns a new functor with the result of applying the function to the original value. Here's an example of a simple functor in JavaScript:
```javascript
// Example of a simple functor
class Box {
constructor(value) {
this.value = value;
}
map(f) {
return new Box(f(this.value));
}
}
// Example usage of the Box functor
const boxOne = new Box(1);
const boxTwo = boxOne.map(x => x + 1);
const boxFour = boxTwo.map(x => x * 2);
console.log(boxFour.value); // Output: 4
```
In this example, we've defined a simple Box functor that wraps a value and allows you to map over it using the map method. We can chain together multiple map calls to apply a series of transformations to the value, just like we would with an array map method.
Overall, functors can be a useful abstraction for working with a variety of data structures in a functional programming style, and can help to simplify and generalize common patterns of transformation and manipulation.
---
#### How do you use a functor in JavaScript?
To use a functor in JavaScript, you first create an instance of the functor with the value you want to wrap, and then use the map method to apply a function to that value. The map method returns a new instance of the functor with the result of the function applied to the wrapped value. Here's an example using the Box functor from the previous question:
```javascript
// Example usage of the Box functor
const boxOne = new Box(1);
const boxTwo = boxOne.map(x => x + 1);
const boxFour = boxTwo.map(x => x * 2);
console.log(boxFour.value); // Output: 4
```
In this example, we first create a new instance of the Box functor with the value 1. We then use the map method to add 1 to the value, resulting in a new Box instance with the value 2. Finally, we use the map method again to double the value, resulting in a new Box instance with the value 4.
Note that when working with functors, it's important to follow the rules of the functor laws, which ensure that the map method behaves in a predictable and consistent way. In particular, the first law requires that calling map with the identity function should return the original functor unchanged, and the second law requires that composing two functions and then mapping with the result should be equivalent to mapping with the first function and then mapping with the second. By following these laws, you can ensure that your functor behaves properly and is compatible with other functional programming concepts and patterns.
---
#### What is a monoid in JavaScript?
In functional programming, **a monoid is a set of values along with a binary operation and an identity element, that satisfies certain properties.** Specifically, the binary operation must be associative and must have an identity element that acts as a neutral element under the operation. Monoids are a useful abstraction for working with many different types of data, and can help to simplify and generalize common patterns of aggregation and combination.
In JavaScript, there are many examples of monoids, such as numbers with addition as the binary operation and 0 as the identity element, or strings with concatenation as the binary operation and the empty string as the identity element.
Here's an example of a simple monoid in JavaScript:
```javascript
// Example of a simple monoid
const Sum = x => ({
x,
concat: ({ x: y }) => Sum(x + y)
});
Sum.empty = () => Sum(0);
// Example usage of the Sum monoid
const result = Sum(1).concat(Sum(2)).concat(Sum(3));
console.log(result.x); // Output: 6
```
In this example, we've defined a simple Sum monoid that wraps a value and allows you to concatenate it with another Sum instance using the concat method. The concat method returns a new Sum instance with the result of adding the two values together. We've also defined an empty method that returns a new Sum instance with a value of 0, which serves as the identity element under the concat operation.
Overall, monoids can be a powerful abstraction for working with many different types of data in a functional programming style, and can help to simplify and generalize common patterns of aggregation and combination.
---
#### How do you use a monoid in JavaScript?
To use a monoid in JavaScript, you typically create an instance of the monoid with an initial value, and then combine it with other instances of the same monoid using the concat method. The concat method should return a new instance of the monoid with the result of combining the values of the two original instances.
Here's an example of using the Sum monoid from the previous question:
```javascript
// Example usage of the Sum monoid
const result = Sum(1).concat(Sum(2)).concat(Sum(3));
console.log(result.x); // Output: 6
```
In this example, we create three instances of the Sum monoid with values of 1, 2, and 3. We then use the concat method to combine them together into a single instance with a value of 6. This works because the Sum monoid has an identity element of 0 and an associative binary operation of addition, which allows us to easily combine multiple instances together in a meaningful way.
Note that when working with monoids, it's important to follow the monoid laws, which ensure that the concat method behaves in a predictable and consistent way. Specifically, the laws require that the concat method must be associative and that the identity element must be neutral with respect to the concat operation. By following these laws, you can ensure that your monoid behaves properly and is compatible with other functional programming concepts and patterns.
---
#### What is the difference between prototypal and classical inheritance in JavaScript?
JavaScript **supports both prototypal and classical inheritance,** but the language's prototypal inheritance is more flexible and powerful than classical inheritance.
Classical inheritance is the approach used in languages such as Java, C++, and Python. It involves defining classes and then creating instances of those classes. The instances inherit properties and methods from their parent classes, and new classes can be created by extending existing classes. Classical inheritance is typically implemented using the "class" keyword in modern JavaScript.
Prototypal inheritance, on the other hand, involves creating objects that inherit properties and methods from other objects directly. In JavaScript, every object has an internal property called [[Prototype]] that refers to another object. When you access a property or method on an object that doesn't have that property or method directly defined on it, JavaScript looks to the object's [[Prototype]] to see if it exists there. If not, it looks to the [[Prototype]] of the object's [[Prototype]], and so on up the prototype chain until it finds the property or method or reaches the end of the chain.
One advantage of prototypal inheritance is that it allows for more dynamic and flexible object relationships than classical inheritance. For example, you can create objects that inherit from multiple prototypes, known as "mixins." You can also create objects that inherit from other objects at runtime, rather than having to define classes ahead of time.
In summary, while classical inheritance involves defining classes and creating instances of those classes, prototypal inheritance involves creating objects that inherit directly from other objects. Prototypal inheritance allows for more flexible and dynamic object relationships, while classical inheritance provides a more structured and familiar approach for developers coming from other languages.
---
#### How do you implement prototypal inheritance in JavaScript?
In JavaScript, prototypal inheritance can be implemented using the prototype property of functions and the Object.create() method. Here's an example:
```javascript
// Define a constructor function for the parent object
function Parent(name) {
this.name = name;
}
// Add a method to the parent object's prototype
Parent.prototype.greet = function() {
console.log("Hello, my name is " + this.name);
};
// Define a constructor function for the child object
function Child(name, age) {
Parent.call(this, name); // call the parent constructor with the child's name
this.age = age;
}
// Inherit the parent object's prototype using Object.create()
Child.prototype = Object.create(Parent.prototype);
// Add a method to the child object's prototype
Child.prototype.info = function() {
console.log(this.name + " is " + this.age + " years old");
};
// Create an instance of the child object
var child1 = new Child("Alice", 5);
// Use the inherited methods
child1.greet(); // "Hello, my name is Alice"
child1.info(); // "Alice is 5 years old"
```
In this example, we define a Parent constructor function that sets a name property on instances of the object and adds a greet method to the object's prototype. We then define a Child constructor function that calls the Parent constructor with the child's name and sets an age property on instances of the object. We then use Object.create() to inherit the Parent object's prototype and add a info method to the Child object's prototype.
Finally, we create an instance of the Child object and use the inherited greet and info methods. The child1.greet() method call prints "Hello, my name is Alice" to the console, and the child1.info() method call prints "Alice is 5 years old".
---
#### How do you implement classical inheritance in JavaScript?
In JavaScript, classical inheritance can be implemented using the class keyword introduced in ECMAScript 2015 (ES6) or the traditional constructor functions and prototypes.
Using the class keyword
Here's an example of how to implement classical inheritance using the class keyword:
```javascript
// Define the parent class
class Parent {
constructor(name) {
this.name = name;
}
greet() {
console.log("Hello, my name is " + this.name);
}
}
// Define the child class that extends the parent class
class Child extends Parent {
constructor(name, age) {
super(name); // call the parent constructor with the child's name
this.age = age;
}
info() {
console.log(this.name + " is " + this.age + " years old");
}
}
// Create an instance of the child class
var child1 = new Child("Alice", 5);
// Use the inherited methods
child1.greet(); // "Hello, my name is Alice"
child1.info(); // "Alice is 5 years old"
```
In this example, we define a Parent class using the class keyword, with a constructor method that sets a name property on instances of the object and a greet method. We then define a Child class that extends the Parent class using the extends keyword and adds an age property and an info method.
Finally, we create an instance of the Child class and use the inherited greet and info methods.
Using constructor functions and prototypes
Here's an example of how to implement classical inheritance using constructor functions and prototypes:
```javascript
// Define the parent constructor function
function Parent(name) {
this.name = name;
}
// Add a method to the parent prototype
Parent.prototype.greet = function() {
console.log("Hello, my name is " + this.name);
};
// Define the child constructor function
function Child(name, age) {
Parent.call(this, name); // call the parent constructor with the child's name
this.age = age;
}
// Inherit the parent prototype
Child.prototype = Object.create(Parent.prototype);
Child.prototype.constructor = Child; // reset the constructor property
// Add a method to the child prototype
Child.prototype.info = function() {
console.log(this.name + " is " + this.age + " years old");
};
// Create an instance of the child object
var child1 = new Child("Alice", 5);
// Use the inherited methods
child1.greet(); // "Hello, my name is Alice"
child1.info(); // "Alice is 5 years old"
```
In this example, we define a Parent constructor function that sets a name property on instances of the object and adds a greet method to the object's prototype. We then define a Child constructor function that calls the Parent constructor with the child's name and sets an age property on instances of the object. We then inherit the Parent prototype using Object.create() and add a info method to the Child prototype.
Finally, we create an instance of the Child object and use the inherited greet and info methods.
---
#### What is the difference between a closure and a module in JavaScript?
Both closures and modules are powerful concepts in JavaScript that can be used to encapsulate functionality and create reusable code. However, they serve slightly different purposes:
+ A closure is a function that has access to its outer function's variables, even after the outer function has returned. The closure "closes over" these variables and maintains a reference to them. This allows the closure to access and modify the outer function's variables, even when it's called outside the scope of the outer function.
+ A module is a pattern used to encapsulate related code into a single unit of code, called a module. Modules can be used to hide implementation details and create a clean, organized interface for interacting with the code. A module can contain functions, variables, and classes, and can be used to prevent naming collisions and create reusable code.
In other words, closures are a way of creating a private state within a function, while modules are a way of creating a private namespace for related functions and variables.
**Here's an example of a closure:**
```javascript
function makeCounter() {
var count = 0;
return function() {
count++;
console.log(count);
};
}
var counter1 = makeCounter();
counter1(); // logs 1
counter1(); // logs 2
```
In this example, makeCounter is a function that returns another function that has access to the count variable declared in the outer function. Each time the inner function is called, it increments the count variable and logs its value to the console. Because makeCounter returns a function that maintains a reference to count, the count variable persists between function calls, creating a closure.
**Here's an example of a module:**
```javascript
var myModule = (function() {
var privateVar = "This variable is private";
function privateFunction() {
console.log("This function is private");
}
return {
publicVar: "This variable is public",
publicFunction: function() {
console.log("This function is public");
},
usePrivateVar: function() {
console.log(privateVar);
},
usePrivateFunction: function() {
privateFunction();
}
};
})();
myModule.publicFunction(); // logs "This function is public"
myModule.usePrivateVar(); // logs "This variable is private"
```
In this example, we're using an immediately-invoked function expression (IIFE) to create a private namespace for our module. Within the IIFE, we declare some private variables and functions that are not accessible outside the module. We then return an object containing some public variables and functions that can be used to interact with the module.
When we invoke the IIFE, we get back an object representing our module, which we can then use to access the public variables and functions. The private variables and functions remain hidden and cannot be accessed from outside the module.
---
#### How do you use the this keyword in JavaScript?
The this keyword in JavaScript refers to the object that the current code is being executed in. The value of this can vary depending on how a function is called, and it can be used to access and manipulate object properties and methods.
Here are some common use cases for the this keyword:
In a function, this refers to the global object (window in a browser or global in Node.js) if the function is not called on an object. For example:
```javascript
function logThis() {
console.log(this);
}
logThis(); // logs the global object (e.g. window in a browser)
```
In a method, this refers to the object that the method is being called on. For example:
```javascript
var myObject = {
name: "John",
sayHello: function() {
console.log("Hello, my name is " + this.name);
}
};
myObject.sayHello(); // logs "Hello, my name is John"
```
In a constructor function, this refers to the new object being created. Constructor functions are used to create new objects with a shared set of properties and methods. For example:
```javascript
function Person(name, age) {
this.name = name;
this.age = age;
}
var person1 = new Person("John", 30);
var person2 = new Person("Jane", 25);
console.log(person1.name); // logs "John"
console.log(person2.age); // logs 25
```
In an event handler, this refers to the DOM element that triggered the event. For example:
```javascript
<button id="myButton">Click me</button>
<script>
document.getElementById("myButton").addEventListener("click", function() {
console.log(this); // logs the <button> element
});
</script>
```
In some cases, the value of this can be explicitly set using the call or apply methods on a function. These methods allow you to specify the object that this should refer to when the function is called. For example:
```javascript
var person1 = { name: "John" };
var person2 = { name: "Jane" };
function sayHello() {
console.log("Hello, my name is " + this.name);
}
sayHello.call(person1); // logs "Hello, my name is John"
sayHello.apply(person2); // logs "Hello, my name is Jane"
```
In the above example, we're calling the sayHello function with call and apply, and passing in different objects as the first argument. This sets the value of this to the respective objects, allowing us to log the correct names.
---
#### What is the difference between call, apply, and bind in JavaScript?
In JavaScript, call, apply, and bind are methods that can be used to set the value of this inside a function. Here's a brief overview of each method:
**call:** The call method is used to invoke a function and explicitly set the value of this. It takes the object that this should refer to as its first argument, followed by any arguments that the function should be called with. For example:
```javascript
function sayHello() {
console.log("Hello, my name is " + this.name);
}
var person = { name: "John" };
sayHello.call(person); // logs "Hello, my name is John"
```
**apply:** The apply method is similar to call, but it takes an array of arguments instead of individual arguments. This can be useful when the number of arguments is unknown or varies. For example:
```javascript
function sum(a, b, c) {
return a + b + c;
}
var numbers = [1, 2, 3];
var result = sum.apply(null, numbers);
console.log(result); // logs 6
```
**bind:** The bind method returns a new function with this bound to a specific object. It does not call the original function immediately, but instead returns a new function that can be called later. This can be useful when you want to create a new function with a fixed value of this. For example:
```javascript
var person = {
name: "John",
sayHello: function() {
console.log("Hello, my name is " + this.name);
}
};
var sayHelloToJohn = person.sayHello.bind(person);
sayHelloToJohn(); // logs "Hello, my name is John"
```
Note that bind does not change the value of this in the original function, but instead creates a new function with the same code and a fixed value of this.
In summary, call and apply are used to invoke a function with a specific value of this, while bind is used to create a new function with a fixed value of this.
---
#### How do you use the apply method in JavaScript?
In JavaScript, the apply method is used to call a function with a given this value and arguments provided as an array. It takes two arguments: the first argument is the object that this should refer to inside the function, and the second argument is an array or array-like object that contains the arguments to be passed to the function.
Here's an example that demonstrates how to use the apply method:
```javascript
function greet(greeting, punctuation) {
console.log(greeting + ' ' + this.name + punctuation);
}
const person = { name: 'John' };
greet.apply(person, ['Hello', '!']); // logs "Hello John!"
```
In this example, we define a function greet that takes two arguments: a greeting string and a punctuation string. We also define an object person that has a name property.
We then call the apply method on the greet function, passing in the person object as the first argument and an array ['Hello', '!'] as the second argument. The apply method calls the greet function with this set to the person object, and passes in the greeting and punctuation arguments as elements of the array.
The result is that the greet function is called with this set to the person object, and the output is logged to the console: "Hello John!".
---
#### How do you use the bind method in JavaScript?
In JavaScript, the bind method is used to create a new function that has a given this value and optionally some initial arguments. The bind method returns a new function that can be called later with the bound this value and any additional arguments.
Here's an example that demonstrates how to use the bind method:
```javascript
const person = {
name: 'John',
greet: function(greeting) {
console.log(greeting + ' ' + this.name);
}
};
const sayHelloToJohn = person.greet.bind(person, 'Hello');
sayHelloToJohn(); // logs "Hello John"
```
In this example, we define an object person with a name property and a greet method that takes a greeting argument. We then use the bind method to create a new function sayHelloToJohn that has this bound to the person object and an initial greeting argument of "Hello".
When we call the sayHelloToJohn function, it calls the greet method with this set to the person object and the greeting argument set to "Hello". The output is logged to the console: "Hello John".
Note that the bind method does not call the original function immediately, but instead returns a new function that can be called later with the bound this value and any additional arguments.
---
#### What is a factory function in JavaScript?
In JavaScript, a factory function is a function that returns an object without the use of the new keyword. It is a design pattern used for creating objects with a similar structure or behavior, without the need to create a class or constructor function.
A factory function can be used to create multiple instances of an object, each with their own unique properties and behavior. It is often used in functional programming as a way to create objects with private state and behavior.
Here's an example of a factory function that creates a person object with a name property and a greet method:
```javascript
function createPerson(name) {
return {
name: name,
greet: function() {
console.log('Hello, my name is ' + this.name);
}
};
}
const john = createPerson('John');
const jane = createPerson('Jane');
john.greet(); // logs "Hello, my name is John"
jane.greet(); // logs "Hello, my name is Jane"
```
In this example, we define a createPerson function that takes a name argument and returns an object with a name property and a greet method. The greet method logs a message to the console with the person's name.
We then use the createPerson function to create two person objects, john and jane, each with their own name property and greet method.
The advantage of using a factory function is that it allows for the creation of objects with private state and behavior, without exposing them to the outside world. This can help to avoid naming collisions and other issues that can arise when working with global variables or shared state.
---
#### How do you use a factory function in JavaScript?
In JavaScript, you can use a factory function to create objects with a similar structure or behavior, without the use of a class or constructor function. Here's an example of how to use a factory function:
```javascript
function createPerson(name, age) {
return {
name: name,
age: age,
greet: function() {
console.log(`Hello, my name is ${this.name} and I'm ${this.age} years old.`);
}
};
}
const john = createPerson('John', 30);
const jane = createPerson('Jane', 25);
john.greet(); // logs "Hello, my name is John and I'm 30 years old."
jane.greet(); // logs "Hello, my name is Jane and I'm 25 years old."
```
In this example, we define a createPerson function that takes a name and an age argument and returns an object with name, age, and greet properties. The greet method logs a message to the console with the person's name and age.
We then use the createPerson function to create two person objects, john and jane, each with their own name, age, and greet properties.
One advantage of using a factory function is that it allows you to create objects with private state and behavior, which can help to avoid naming collisions and other issues that can arise when working with global variables or shared state.
---
#### What is a promise in JavaScript?
In JavaScript, a promise is an object that represents a value that may not be available yet, but will be resolved at some point in the future. It is a way to handle asynchronous operations and avoid blocking the main thread of execution.
A promise can be in one of three states: pending, fulfilled, or rejected. When a promise is pending, it means that the operation it represents is still in progress. When a promise is fulfilled, it means that the operation was successful and the promise has a value. When a promise is rejected, it means that the operation failed and the promise has a reason for the failure.
Here's an example of how to create and use a promise:
```javascript
const promise = new Promise((resolve, reject) => {
setTimeout(() => {
const value = Math.random();
if (value > 0.5) {
resolve(value);
} else {
reject('Value is too small');
}
}, 1000);
});
promise.then(value => {
console.log('Resolved with value:', value);
}).catch(reason => {
console.log('Rejected with reason:', reason);
});
```
In this example, we create a promise that resolves with a random value after 1 second. If the value is greater than 0.5, the promise is resolved with the value. Otherwise, the promise is rejected with the reason "Value is too small".
We then use the then method to handle the fulfilled state of the promise and the catch method to handle the rejected state. When the promise is resolved with a value, the then method is called with the value as an argument. When the promise is rejected with a reason, the catch method is called with the reason as an argument.
Promises can be chained together using the then method, allowing for more complex asynchronous operations to be handled in a more readable way.
---
#### How do you use a promise in JavaScript?
In JavaScript, you can use a promise to handle asynchronous operations in a more readable and predictable way. Here's an example of how to use a promise to fetch data from an API:
```javascript
const fetchData = () => {
return new Promise((resolve, reject) => {
fetch('https://example.com/api/data')
.then(response => {
if (!response.ok) {
throw new Error('Network response was not ok');
}
return response.json();
})
.then(data => {
resolve(data);
})
.catch(error => {
reject(error);
});
});
};
fetchData()
.then(data => {
console.log('Data:', data);
})
.catch(error => {
console.error('Error:', error);
});
```
In this example, we define a function fetchData that returns a promise. The promise is created with a resolve and reject function that are called when the asynchronous operation is complete. We use the fetch function to make a request to an API and handle the response using the then method. If the response is not OK, we throw an error. Otherwise, we parse the response as JSON and resolve the promise with the data. If an error occurs during the operation, we reject the promise with the error.
We then use the fetchData function to fetch data from the API and handle the result using the then and catch methods. When the promise is resolved, the then method is called with the data as an argument. When the promise is rejected, the catch method is called with the error as an argument.
Promises can be chained together using the then method, allowing for more complex asynchronous operations to be handled in a more readable and maintainable way.
---
#### What is a callback function in JavaScript?
In JavaScript, a callback function is a function that is passed as an argument to another function and is called when that function has completed its task. The purpose of a callback function is to allow code to be executed asynchronously, or at a later time, without blocking the main thread of execution.
Here's an example of a simple callback function:
```javascript
function greet(name, callback) {
console.log('Hello, ' + name + '!');
callback();
}
function sayGoodbye() {
console.log('Goodbye!');
}
greet('Alice', sayGoodbye);
```
In this example, we define two functions: greet and sayGoodbye. The greet function takes two arguments: a name and a callback function. It logs a greeting to the console, then calls the callback function. The sayGoodbye function simply logs a farewell message to the console.
We then call the greet function with the name "Alice" and the sayGoodbye function as the callback. When the greet function has finished logging the greeting, it calls the sayGoodbye function, which logs the farewell message.
Callbacks are commonly used in JavaScript to handle asynchronous operations, such as fetching data from a server or waiting for a user action to complete. They are often passed as arguments to functions such as setTimeout, setInterval, and fetch.
---
#### How do you use a callback function in JavaScript?
In JavaScript, you can use a callback function by passing it as an argument to another function. When the function has finished its task, it can then call the callback function to execute additional code.
Here's an example of using a callback function to handle the result of an asynchronous operation, such as fetching data from a server:
```javascript
function fetchData(url, callback) {
fetch(url)
.then(response => response.json())
.then(data => callback(data))
.catch(error => console.error(error));
}
function handleData(data) {
console.log('Data:', data);
}
fetchData('https://example.com/api/data', handleData);
```
In this example, we define two functions: fetchData and handleData. The fetchData function takes two arguments: a URL and a callback function. It uses the fetch function to make a request to the server and handle the response using the then method. If the response is OK, it parses the response as JSON and calls the callback function with the data. If an error occurs during the operation, it logs the error to the console.
The handleData function simply logs the data to the console.
We then call the fetchData function with the URL "https://example.com/api/data" and the handleData function as the callback. When the data is fetched from the server, the handleData function is called with the data as an argument, and logs it to the console.
Callbacks can be used in many ways in JavaScript, such as to handle user interactions, animations, and other asynchronous operations. They are a powerful tool for writing flexible and reusable code.
---
#### What is the difference between a callback function and a promise in JavaScript?
The primary difference between a callback function and a promise in JavaScript is how they handle asynchronous operations and their resulting values.
A callback function is a function that is passed as an argument to another function and is executed when that function completes its task. Callbacks are commonly used to handle asynchronous operations, such as fetching data from a server or waiting for user input.
On the other hand, a Promise is a built-in JavaScript object that represents the eventual completion (or failure) of an asynchronous operation and its resulting value. Promises are a more recent addition to JavaScript and are designed to simplify asynchronous programming and avoid the so-called "callback hell" problem.
Here's an example that demonstrates the difference between a callback function and a Promise:
```javascript
// Using a callback function
function fetchData(url, callback) {
fetch(url)
.then(response => response.json())
.then(data => callback(null, data))
.catch(error => callback(error, null));
}
fetchData('https://example.com/api/data', (error, data) => {
if (error) {
console.error(error);
} else {
console.log('Data:', data);
}
});
// Using a Promise
function fetchData(url) {
return fetch(url)
.then(response => response.json());
}
fetchData('https://example.com/api/data')
.then(data => console.log('Data:', data))
.catch(error => console.error(error));
```
In the first example, we define a fetchData function that takes a URL and a callback function as arguments. It uses the fetch function to make a request to the server and handle the response using the then method. If the response is OK, it parses the response as JSON and calls the callback function with the data. If an error occurs during the operation, it calls the callback function with the error.
We then call the fetchData function with the URL "https://example.com/api/data" and a callback function that logs the data to the console if there are no errors, or logs the error to the console if there is an error.
In the second example, we define the same fetchData function, but instead of using a callback, we use a Promise. The fetchData function returns a Promise that resolves with the parsed JSON data if the response is OK, or rejects with an error if there is a problem. We then use the then method to log the data to the console if the Promise resolves successfully, or use the catch method to log the error to the console if the Promise is rejected.
In general, Promises are preferred over callbacks because they provide a cleaner and more expressive way of handling asynchronous operations, and they allow you to chain multiple asynchronous operations together.
---
#### What is the difference between a promise and an observable in JavaScript?
Promises and Observables are both used to handle asynchronous operations in JavaScript, but they have some key differences.
Promises represent a single value that will be available in the future. They have two possible states: "fulfilled" with a value or "rejected" with a reason. Once a promise is resolved (either fulfilled or rejected), it cannot be used again. Promises are commonly used in situations where you want to execute a task asynchronously and receive a result once it completes.
On the other hand, Observables represent a stream of values that will be available over time. They can emit zero, one, or multiple values, and they can complete or throw an error at any time. Observables are more powerful than Promises because they allow you to handle multiple values over time and handle errors in a more flexible way. Observables are commonly used in situations where you want to handle events or data streams.
Here are some key differences between Promises and Observables:
**Multiple values:** Observables can emit zero, one, or multiple values over time, whereas Promises can only resolve with a single value.
**Lazy execution:** Observables are lazily executed, which means that they will only start emitting values when they are subscribed to. Promises are eagerly executed, which means that they start executing as soon as they are created.
**Cancellation:** Observables can be cancelled, which means that they will stop emitting values and release any resources they are using. Promises cannot be cancelled.
**Error handling:** Observables allow you to handle errors in a more flexible way, by using operators like catchError and retry. Promises only allow you to handle errors using the catch method.
Here's an example that demonstrates the difference between a Promise and an Observable:
```javascript
// Using a Promise
const promise = fetch('https://api.example.com/data')
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error(error));
// Using an Observable
import { Observable } from 'rxjs';
const observable = new Observable(observer => {
fetch('https://api.example.com/data')
.then(response => response.json())
.then(data => {
observer.next(data);
observer.complete();
})
.catch(error => observer.error(error));
});
const subscription = observable.subscribe(
data => console.log(data),
error => console.error(error),
() => console.log('Completed')
);
// Later, if you want to cancel the subscription:
subscription.unsubscribe();
```
In this example, we use a Promise and an Observable to fetch some data from an API and log it to the console. In the Promise example, we use the fetch function to make the HTTP request, then use the then method to parse the JSON response and log it to the console. If there is an error, we use the catch method to log the error to the console.
In the Observable example, we use the Observable constructor to create a new Observable that wraps the fetch function. Inside the Observable, we use the observer object to emit the parsed JSON data using the next method, complete the Observable using the complete method, or emit an error using the error method. We then subscribe to the Observable using the subscribe method, passing in callback functions to handle the emitted data, errors, and completion. Finally, we store the subscription object in a variable so that we can later unsubscribe from the Observable if we want to cancel it.
---
#### What is a higher-order component in React?
In React, a Higher Order Component (HOC) is a function that takes a component and returns a new component with extended functionality. The returned component can be used just like any other React component.
HOCs allow you to reuse component logic, and can be used for things like providing data to a component, adding event handlers, or even wrapping a component with additional functionality like authentication or conditional rendering.
Here's an example of a simple HOC that adds a "loading" prop to a component, indicating whether data is currently being fetched:
```javascript
function withLoading(Component) {
return function(props) {
if (props.loading) {
return <div>Loading...</div>;
}
return <Component {...props} />;
}
}
```
This HOC takes a component and returns a new component that checks if the loading prop is true. If it is, it renders a "Loading..." message. If not, it renders the original component with all of the original props passed down.
You can use this HOC like this:
```javascript
const MyComponentWithLoading = withLoading(MyComponent);
// Use MyComponentWithLoading just like you would use MyComponent
<MyComponentWithLoading loading={true} />
```
---
#### How do you use a higher-order component in React?
Using a Higher Order Component (HOC) in React is quite simple. You can use it to wrap an existing component and add extra functionality to it.
Here's an example of how to use an HOC:
```javascript
// Define an HOC
function withData(WrappedComponent) {
return class extends React.Component {
state = {
data: null,
error: null,
isLoading: true
};
componentDidMount() {
fetchData().then(
data => {
this.setState({
data: data,
isLoading: false
});
},
error => {
this.setState({
error: error,
isLoading: false
});
}
);
}
render() {
return (
<WrappedComponent
{...this.props}
data={this.state.data}
error={this.state.error}
isLoading={this.state.isLoading}
/>
);
}
};
}
// Define a component
function MyComponent(props) {
if (props.isLoading) {
return <div>Loading...</div>;
} else if (props.error) {
return <div>Error: {props.error.message}</div>;
} else {
return <div>Data: {props.data}</div>;
}
}
// Use the HOC to create a new component
const MyComponentWithData = withData(MyComponent);
// Render the new component
<MyComponentWithData />;
```
In this example, the withData function is the HOC that adds the data loading functionality to the MyComponent component. The withData function returns a new component that fetches data from an API and passes it down to the wrapped component as props.
To use the HOC, you simply pass the original component (MyComponent) as an argument to the HOC function (withData). The result of calling the HOC function is a new component (MyComponentWithData) that you can use just like any other React component.
---
#### What is Redux in React?
Redux is a state management library for JavaScript applications, and it is commonly used with React. Redux provides a centralized store to manage the state of an application, making it easier to reason about and modify the application's state.
The core concepts of Redux are:
**Store:** A store is an object that holds the application's state tree. The state is read-only, which means that the only way to change it is by dispatching an action. When the state changes, the store notifies all subscribed components.
**Actions:** Actions are plain JavaScript objects that describe what happened in an application. They contain a type field that specifies the type of action being performed, as well as any data required to perform the action.
**Reducers:** Reducers are pure functions that take the current state and an action, and return a new state. They do not modify the current state directly, but instead return a new state that represents the updated state of the application.
**Dispatch:** Dispatch is a method on the store that is used to send an action to the store. When an action is dispatched, the store calls the appropriate reducer and updates the state of the application.
Redux is commonly used with React because it provides a clear separation of concerns between the state management and the view layer. React components can subscribe to the store and receive updates when the state changes, making it easy to keep the UI in sync with the application state.
---
#### How do you use Redux in React?
To use Redux in a React application, you'll need to install the redux and react-redux packages using npm or yarn. Once you have those installed, here are the general steps to use Redux in a React application:
**Create a Redux Store:** The first step is to create a Redux store, which will hold the state of your application. You can create a store by using the createStore function provided by Redux.
```javascript
import { createStore } from 'redux';
import rootReducer from './reducers';
const store = createStore(rootReducer);
```
**Create Reducers:** Reducers are functions that update the state of the store based on the actions that are dispatched. You should create one or more reducers that handle the actions in your application.
```javascript
const initialState = {
count: 0
};
function counterReducer(state = initialState, action) {
switch (action.type) {
case 'INCREMENT':
return { count: state.count + 1 };
case 'DECREMENT':
return { count: state.count - 1 };
default:
return state;
}
}
```
**Create Actions:** Actions are plain objects that represent something that happened in your application. You should create one or more action creators that return these action objects.
```javascript
function increment() {
return { type: 'INCREMENT' };
}
function decrement() {
return { type: 'DECREMENT' };
}
```
**Create React Components:** Create React components that will use the store to manage the state of your application. You can use the connect function from react-redux to connect your components to the Redux store.
```javascript
import { connect } from 'react-redux';
function Counter({ count, dispatch }) {
return (
<div>
<p>Count: {count}</p>
<button onClick={() => dispatch(increment())}>+</button>
<button onClick={() => dispatch(decrement())}>-</button>
</div>
);
}
const mapStateToProps = (state) => ({
count: state.count
});
export default connect(mapStateToProps)(Counter);
```
**Render Components:** Finally, render your React components and wrap your top-level component with the Provider component from react-redux, passing in your Redux store as a prop.
```javascript
import { Provider } from 'react-redux';
import store from './store';
import Counter from './Counter';
function App() {
return (
<Provider store={store}>
<Counter />
</Provider>
);
}
export default App;
```
With these steps, you should have a working Redux setup in your React application. Note that this is a simplified example, and there are many more advanced features of Redux that you may need to use in a larger application.
| Most important topics/questions of JavaScript that everybody should have information. Javascript interview questions and best answer. | javascript,javascript-applications,javascript-es6,javascript-es6-tutorial,javascript-framework,javascript-library,javascript-vanilla | 2023-04-07T08:34:52Z | 2023-05-04T08:50:01Z | null | 1 | 0 | 23 | 0 | 0 | 3 | null | null | null |
Henrich77/poor-4-lio | main |
<h1 align="center"> Henrich Tanis </h1>
 
<p align="center">Welcome to my porfolio!
</p>
<br>
## Table of Contents
- [Installation](#installation)
- [Usage](#usage)
- [License](#license)
<br>
## Description
As software developer, my portfolio showcases my technical abilities, problem-solving skills, and creativity. With a strong background in programming languages such as JavaScript I have developed a wide range of projects that demonstrate my expertise in web development, mobile application development, and software engineering. Throughout my career, I have contributed to numerous projects and have made a significant impact on the teams I have worked with. In addition to my technical skills, I am an Accountant, and proffessional pasta smasher. My portfolio is presented in a professional and visually appealing manner, showcasing my projects and achievements in a clear and concise way. With my proven track record of success, I am confident in my ability to bring value to any software development team.
<br>
<img width="1512" alt="Screenshot 2023-04-12 at 6 44 58 PM" src="https://user-images.githubusercontent.com/119962472/231615540-c3fbf58a-96d3-4863-80c6-25de4bcd8000.png">
<img width="1512" alt="Screenshot 2023-04-12 at 7 42 14 PM" src="https://user-images.githubusercontent.com/119962472/231615629-86edf74d-3c3d-46de-b431-17e15ca2bad4.png">
<img width="1511" alt="Screenshot 2023-04-12 at 7 42 46 PM" src="https://user-images.githubusercontent.com/119962472/231615646-f9a0566a-0679-4f71-8716-ccd93886ef17.png">
## <h2 id="usage"> Usage </h2>
The usage of my portfolio is to showcase my skills and experience to potential employers, and highlight my technical abilities, problem-solving skills, and creativity in software development.
######### Portfolio link: https://htanis.me ##################
<br>
<br>
<h2>Languages Used/Requirements</h2>
<br>
### Built With:
[](https://reactjs.org/) [](https://nodejs.org/en/) [](https://www.npmjs.com/) [](https://developer.mozilla.org/en-US/docs/Web/JavaScript) [](https://developer.mozilla.org/en-US/docs/Glossary/HTML5) [](https://developer.mozilla.org/en-US/docs/Web/CSS) [](https://getbootstrap.com/)   
- React
- JavaScript
- Node.js
<table>
<tr>
<td>
Don't forget to star ⭐ this repository
</td>
</tr>
<br>
<h2 id="license">MIT License</h2>
The MIT License (MIT)
Copyright (c) <year> Adam Veldhousen
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@Levi0100
</h5> | My Portfolio | css,html,javascript,reactjs | 2023-04-03T16:34:14Z | 2023-04-25T18:17:24Z | null | 1 | 0 | 99 | 0 | 0 | 3 | null | MIT | JavaScript |
kodie/kloner | main | null | A tiny, dependency-free JavaScript module for cloning/repeating elements. | clone,dynamic,frontend,javascript,repeater,vanilla-js | 2023-03-27T17:07:50Z | 2023-04-01T22:27:51Z | null | 1 | 0 | 9 | 0 | 0 | 3 | null | MIT | JavaScript |
harshi0102/AwesomeBooks-ES6 | main | <a name="readme-top"></a>
<!-- TABLE OF CONTENTS -->
# 📗 Table of Contents
- [📖 About the Project](#about-project)
- [🛠 Built With](#built-with)
- [Tech Stack](#tech-stack)
- [Key Features](#key-features)
- [🚀 Live Demo](#live-demo)
- [💻 Getting Started](#getting-started)
- [Setup](#setup)
- [Prerequisites](#prerequisites)
- [Install](#install)
- [Usage](#usage)
- [Run tests](#run-tests)
- [Deployment](#triangular_flag_on_post-deployment)
- [👥 Authors](#authors)
- [🤝 Contributing](#contributing)
- [⭐️ Show your support](#support)
- [🙏 Acknowledgements](#acknowledgements)
- [📝 License](#license)
<!-- PROJECT DESCRIPTION -->
# 📖 Awesome Books ES6 Project <a name="about-project"></a>
# [Live Preview](https://harshi0102.github.io/AwesomeBooks-ES6/)
<div align="center">
<img src="desktopversion.jpeg" alt="project sample" width="650" height="auto" />
<br/>
<img src="desktop2.jpeg" alt="project sample" width="650" height="auto" />
<br/>
<h3><b>Awesome Books ES6 Project</b></h3>
</div>
> "Awesome books" is a simple website that displays a list of books and allows you to add and remove books from that list. Mainly built with javascript in Microverse Module 2.
**Awesome Books ES6 Project** is a HTML, CSS and JavaScript based project.
ES6 syntax is used where Modules is divided and imported in index.js file.
Refracting of all functions to arrow functions is made which also displays the current date below the navigation bar for which **Luxon** library is being downloaded and imported as a module.
## 🛠 Built With <a name="built-with"></a>
# Built With
- Lighthouse (An open-source, automated tool for improving the quality of web pages. It has audits for performance, accessibility, progressive web apps, SEO and more).
- Webhint (A customizable linting tool that helps you improve your site's accessibility, speed, cross-browser compatibility, and more by checking your code for best practices and common errors).
- Stylelint (A mighty, modern linter that helps you avoid errors and enforce conventions in your styles).
- ESlint (A mighty, modern linter that helps you avoid errors and enforce conventions in JavaScript codes)
### Tech Stack <a name="tech-stack"></a>
> HTML, CSS, JavaScript and Linter Template
<details>
<summary>Languages</summary>
<ul>
<li>HTML</li>
<li>CSS</li>
<li>JavaScript</li>
</ul>
</details>
<!-- Features -->
### Key Features <a name="key-features"></a>
- **Single Page Application**
- **Add Book Feature**
- **Remove Book Feature**
- **Saving current state of book list to local storage**
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- LIVE DEMO -->
## 🚀 Live Demo <a name="live-demo"></a>
- [Live Demo Link](https://harshi0102.github.io/AwesomeBooks-ES6/)
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- GETTING STARTED -->
## 💻 Getting Started <a name="getting-started"></a>
To get a local copy up and running, follow these steps.
### Prerequisites
The basic requirements for building the executable are:
- A working browser application (Google chrome, Mozilla Fire fox, Microsoft edge ...)
- VSCode or any other equivalent code editor.
- Node Package Manager (For installing packages like Lighthous, webhint & stylelint used for checking for debugging bad codes before deployment).
### Setup
Checkout the project repository <a href="https://github.com/harshi0102/AwesomeBooks-ES6.git">here</a>
### Install
You can use the repository HTTPS or SSH urls to clone the project on your local machine or download the ZIP folder and extract its contents.
## Getting packages and debuging with Stylelint
```
npm install --save-dev stylelint@13.x stylelint-scss@3.x stylelint-config-standard@21.x stylelint-csstree-validator@1.x
```
##### For validation detection using Stylelint Run
```
npx stylelint "**/*.{css,scss}"
```
##### from parent source directory
## Getting packages and debuging with ESlint
```
npm install npm install --save-dev eslint@7.x eslint-config-airbnb-base@14.x eslint-plugin-import@2.x babel-eslint@10.x
```
##### For validation detection using Stylelint Run
```
npx eslint .
```
##### from parent source directory
## Getting packages and debuging with Webhint
```
npm init -y
npm install --save-dev hint@6.x
```
##### For validation detection using Webhint Run
```
npx hint .
```
### Usage
Run the index.html file in the root directory of the project using any browser.
### Run tests
Use Chrome dev tools
Ensure to checkout any linter errors
### Deployment
Use Github pages for free and secure deployment.
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- AUTHORS -->
## 👥 Authors <a name="authors"></a>
>Harshika Govind
👤 **Harshika Govind**
- GitHub: [@githubhandle](https://github.com/harshi0102)
- Twitter: [@twitterhandle](https://twitter.com/harshika0102me)
- LinkedIn: [LinkedIn](https://www.linkedin.com/in/harshikagovind)
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- FUTURE FEATURES -->
## 🔭 Future Features <a name="future-features"></a>
- [ ] **About Page**
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- CONTRIBUTING -->
## 🤝 Contributing <a name="contributing"></a>
Contributions, issues, and feature requests are welcome!
Feel free to check the [issues page](https://github.com/harshi0102/AwesomeBooks-ES6/issues).
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- SUPPORT -->
## ⭐️ Show your support <a name="support"></a>
Give a ⭐️ if you like this project!
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- ACKNOWLEDGEMENTS -->
## 🙏 Acknowledgments <a name="acknowledgements"></a>
I would like to thank Microverse.
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- LICENSE -->
## 📝 License <a name="license"></a>
This project is [MIT](https://github.com/harshi0102/AwesomeBooks-ES6/blob/main/LICENSE) licensed.
<p align="right">(<a href="#readme-top">back to top</a>)</p>
| AwesomeBooks with ES6-"Awesome books" is a simple website that displays a list of books and allows you to add and remove books from that list.It is built with HTML,CSS and Javascript. | css,html,javascript | 2023-04-02T18:07:04Z | 2023-04-03T09:39:59Z | null | 1 | 1 | 11 | 1 | 0 | 3 | null | MIT | JavaScript |
KaustubhN12/dizzy-stitch-9009 | main | <h1 align="center">Nearbuy clone </h1>
<h3 align="center" id="title">unique name :- DoorStep</h3>
<h3 align="center">It's a MERN Stack E-commerce web application with all the major functionalities</h3>
<h5>* fw22_0440 - Kaustubh Nawade(Team Lead)<br>* fw19_0161 - Shivam Kumar <br>* fp06_463 - Akash Singh <br>* fw21_0472 - Aman kumar Maurya <br>* fw19_1103 - Shubham Anand</h5>
<br />
<h2 align="center">🖥️ Tech Stack</h2>
<h4 align="center">Frontend:</h4>
<p align="center">
<img src="https://img.shields.io/badge/React-20232A?style=for-the-badge&logo=react&logoColor=61DAFB" alt="reactjs" />
<img src="https://img.shields.io/badge/Redux-593D88?style=for-the-badge&logo=redux&logoColor=white" alt="redux" />
<img src="https://img.shields.io/badge/Chakra%20UI-3bc7bd?style=for-the-badge&logo=chakraui&logoColor=white" alt="chakra-ui" />
<img src="https://img.shields.io/badge/JavaScript-323330?style=for-the-badge&logo=javascript&logoColor=F7DF1E" alt="javascript" />
<img src="https://img.shields.io/badge/Rest_API-02303A?style=for-the-badge&logo=react-router&logoColor=white" alt="restAPI" />
<img src="https://img.shields.io/badge/CSS3-1572B6?style=for-the-badge&logo=css3&logoColor=white" alt="css3" />
<img src="https://img.shields.io/badge/HTML5-E34F26?style=for-the-badge&logo=html5&logoColor=white" alt="html5" />
</p>
<h4 align="center">Backend:</h4>
<p align="center">
<img src="https://img.shields.io/badge/Node.js-339933?style=for-the-badge&logo=nodedotjs&logoColor=white" alt="nodejs" />
<img src="https://img.shields.io/badge/Express.js-000000?style=for-the-badge&logo=express&logoColor=white" alt="expressjs" />
<img src="https://img.shields.io/badge/MongoDB-4EA94B?style=for-the-badge&logo=mongodb&logoColor=white" alt="mongodb" />
<img src="https://img.shields.io/badge/JWT-000000?style=for-the-badge&logo=JSON%20web%20tokens&logoColor=white" alt="JsonWebToken" />
</p>
<h4 align="center">Deployed On:</h4>
<p align="center">
<img src="https://img.shields.io/badge/Vercel-000000?style=for-the-badge&logo=vercel&logoColor=white" alt="vercerl">
</p>
<h3 align="center"><a href="https://doorstep-iota.vercel.app/"><strong>Want to see live preview »</strong></a></h3>
Nearbuy Clone is MERN Stack web application that allows you to buy voucher and coupons. It has a variety of categories, just visit the product listing page and you will see all the services near your location, in just a few clicks you can buy any products from the website. This project is just for educational purpose.
<br />
## Screens
- Homepage / Landing Page
- services Listing Page
- service Description Page
- order Management Page
- Checkout Management Page
- Login / Logout Page
- Signup Page
- Admin page
<br />
## 🚀 Features
- Login and Signup User Account
- JWT (Json Web Token) Authentication and BcryptJS Password Hashing
- All category Add and Remove Items
- Order Update Quantities
<br />
## Glimpses of Nearbuy clone 🙈 :
<table>
<tr>
<td><img src="https://i.ibb.co/s5rJkz8/Screenshot-2080.png" alt="home" /></td>
<td><img src="https://i.ibb.co/B2673rL/Screenshot-2081.png" alt="coupons" /></td>
</tr>
<tr>
<td><img src="https://i.ibb.co/4Sw5vXY/Screenshot-2082.png" alt="allProducts" /></td>
<td><img src="https://i.ibb.co/f0fMRD0/Screenshot-2083.png" alt="men" /></td>
</tr>
<tr>
<td><img src="https://i.ibb.co/09gp7X8/Screenshot-2084.png" alt="women" /></td>
<td><img src="https://i.ibb.co/7r2H2LZ/Screenshot-2085.png" alt="kids" /></td>
</tr>
<tr>
<td><img src="https://i.ibb.co/XsP5F3J/Screenshot-2086.png" alt="description" /></td>
<td><img src="https://i.ibb.co/vvTT3wm/Screenshot-2087.png" alt="cart" /></td>
</tr>
</table>
<br />
## Getting Started
This project was built using React, Redux, Chakra UI, HTML, CSS, JavaScript, Rest API, Node JS, Express and MongoDB with JWT and RazorPay integration. It is an e-commerce web application and for running on your local environment you should follow these guidelines.
### Prerequisites
- NPM
- Node JS
- MongoDB
### Setup
The project repository can be found in [GitHub link](https://github.com/ArjunSinghBhakuni/Nike-Clone) or just clone the project using this command.
```
Using HTTPS
# git clone https://github.com/KaustubhN12/dizzy-stitch-9009.git
```
### Environment Variables
To run this project, you will need to add the following environment variables to your .env file in server folder
`port`
`url`
`
### Tools used on this project
- Visual Studio Code
- Mongoose Atlas
<br />
## Show your support
Give a ⭐️ if you like this project!
| Nearbuy Clone is MERN Stack web application that allows you to buy voucher and coupons. It has a variety of categories, just visit the product listing page and you will see all the services near your location. | bcrypt,chakraui,css,express,html,javascript,jwt-authentication,mongodb,nodejs,react-redux | 2023-03-28T08:26:18Z | 2023-05-19T08:56:44Z | null | 5 | 36 | 122 | 4 | 2 | 3 | null | null | JavaScript |
jodavid444/First-Capstone | main | # 📗 Table of Contents
- [📖 About the Project](#about-project)
- [🛠 Built With](#built-with)
- [Tech Stack](#tech-stack)
- [Key Features](#key-features)
- [🚀 Live Demo](#live-demo)
- [💻 Getting Started](#getting-started)
- [Setup](#setup)
- [Prerequisites](#prerequisites)
- [Usage](#usage)
- [👥 Authors](#authors)
- [🔭 Future Features](#future-features)
- [🤝 Contributing](#contributing)
- [⭐️ Show your support](#support)
- [🙏 Acknowledgements](#acknowledgements)
- [❓ FAQ](#faq)
- [📝 License](#license)
# 📖 [Greekle React Global Summits Website] <a name="about-project"></a>
> This is my first capstone project at microvesre after rounding up the portal section, The greekle online global summits website holds a virtual event where speakers who are leading expert from all over the world share ideas on how to solve challanges from work using react, greekle has the unique experience to gather huge tech summits with 10'000+ attendees in different tech domains.
## Desktop Preview 👇
<img src="./img/Desktop-image.PNG" alt="desktop preview image">
## Mobile Preview 👇
<img src="./img/mobile-preview.PNG" alt="mobile preview image">
## Learning objectives
- Understand how to use medium-fidelity wireframes to create a UI.
- Follow written requirements (e.g. user stories).
- Use semantic HTML tags.
- Apply best practices in HTML code.
- Use CSS selectors correctly.
- Use CSS box model.
- Use Flexbox to place elements in the page.
- Use images and backgrounds to enhance the look of a website.
- Demonstrate ability to create UIs adaptable to different screen sizes using media queries.
- Use GitHub Pages to deploy web pages.
- Apply JavaScript best practices and language style guides in code.
- Use JavaScript to manipulate DOM elements.
- Use JavaScript events.
- Use objects to store and access data.
- Communicate technical concepts to other technical people.
## 🛠 Built With <a name="built-with"></a>
- HTML (Hypertext Markup Language)
- CSS (Cascading Style Sheets)
- Js (JavaScript)
## Technologies used
- Github
- Git
- WebHint
- Stylelint
- ESlint
### Key Features <a name="key-features"></a>
- **[Gather huge tech summits with 10'000+ attendees in different tech domains.]**
- **[Gather leading expert virtually from all over the world to share ideas on how to solve challanges from work using react]**
<p align="right">(<a href="#readme-top">back to top</a>)</p>
## 🚀 Live Demo <a name="live-demo"></a>
[Live Demo Link](https://jodavid444.github.io/First-Capstone/)
[Video Presentation Link](https://www.loom.com/share/1d9997b6e58c49e6b8dbd4ce24764d0f)
<p align="right">(<a href="#readme-top">back to top</a>)</p>
## 💻 Getting Started <a name="getting-started"></a>
To get a local copy up and running, follow these steps.
### Prerequisites
In order to run this project you need:
- Code Editor (Vs Code)
- Git
- Browser (Chrome)
### Setup
Clone this repository to your desired folder:
run this commands:
```sh
git clone git@github.com:jodavid444/First-Capstone.git
cd First-Capstone
```
### Usage
```sh
Open index.html in Chrome to view the website
```
### If you are non a technical person you can download the zip file.
- To do that you have to go to the green button that says 'Code' and then press on it.
- Choose the option 'Download Zip' and wait until it download.
- Then you need to decompress it.
- You will need to have win rar file software installed in your computer. If you don't have it you can download it from here https://www.win-rar.com/download.html?&L=0
- Do double click on the First-Capstone.zip and choose a folder where to place all the decompressed files.
- Once you are done decompressing, you can open the created folder.
- In it you can double click on the index.html file and choose a browser to open it (For example google Chrome Browser).
- Now you should be able to see the project.
- Remember to use the mouse to navigate through the website. Also you can use the keys 'arrow up' and 'arrow down' of your keyboard to scroll up and down.
## Authors <a name="authors"></a>
👤 **Joseph David**
- GitHub: [@jodavid444](https://github.com/jodavid444)
- Twitter: [@jodavid444dave](https://twitter.com/jodavid444dave)
- LinkedIn: [@joseph-david](https://www.linkedin.com/in/joseph-david-/)
<p align="right">(<a href="#readme-top">back to top</a>)</p>
## 🔭 Future Features <a name="future-features"></a>
- [ ] **[Enlighten and improve skills of react developers]**
<p align="right">(<a href="#readme-top">back to top</a>)</p>
## 🤝 Contributing <a name="contributing"></a>
Contributions, issues, and feature requests are welcome!
Feel free to check the [issues page](../../issues/).
<p align="right">(<a href="#readme-top">back to top</a>)</p>
## ⭐️ Show your support <a name="support"></a>
If you like this project please leave a star. Thank you 🙏
<p align="right">(<a href="#readme-top">back to top</a>)</p>
## 🙏 Acknowledgments <a name="acknowledgements"></a>
- I would like to thank Microverse for the great project idea and acknowledgment to [Cindy Shin](https://www.behance.net/adagio07) the [author of the original design](https://www.behance.net/gallery/29845175/CC-Global-Summit-2015),
- Unsplash for providing content related free pictures.
- Thanks to my teammates, learning and coding partners.
<p align="right">(<a href="#readme-top">back to top</a>)</p>
## ❓ FAQ <a name="faq"></a>
- **[How to setup the website on your local machine]**
- [Follow the steps in the setup section]
- **[How to use the website on your local machine]**
- [Follow the steps in the usage section]
<p align="right">(<a href="#readme-top">back to top</a>)</p>
## 📝 License <a name="license"></a>
This project is [MIT](./LICENSE) licensed.
<p align="right">(<a href="#readme-top">back to top</a>)</p>
| Greekle Online Global Summits Website holds a virtual event where speakers who are leading expert from all over the world share ideas on how to solve challanges from work using react, greekle has the unique experience to gather huge tech summits with 10'000+ attendees in different tech domains. | css,html,javascript | 2023-03-29T22:12:33Z | 2023-07-27T18:27:31Z | null | 1 | 1 | 157 | 0 | 0 | 3 | null | MIT | CSS |
RHK-MICROVERSE/To-Do-List | main | # To-Do-List
<a name="readme-top"></a>
<div align="center">
<img src="./src/images/RHK Trading Logo.png" alt="logo" width="140" height="auto" />
<br/>
<h3><b>To do List Project</b></h3>
</div>
<h1>Capstone Project Module-1</h1>
<!-- TABLE OF CONTENTS -->
# 📗 Table of Contents
- [📖 About the Project](#about-project)
- [🛠 Walk through](#walk-through)
- [🛠 Built With](#built-with)
- [Tech Stack](#tech-stack)
- [Key Features](#key-features)
- [🚀 Live Demo](#live-demo)
- [💻 Getting Started](#getting-started)
- [Setup](#setup)
- [Prerequisites](#prerequisites)
- [Install](#install)
- [👥 Authors](#authors)
- [🔭 Future Features](#future-features)
- [🤝 Contributing](#contributing)
- [⭐️ Show your support](#support)
- [🙏 Acknowledgements](#acknowledgements)
- [❓ FAQ](#faq)
- [📝 License](#license)
<!-- PROJECT DESCRIPTION -->
# 📖 To Do List <a name="about-project"></a>
"To Do List" is a simple website that create a do List to check everyday task and remove what have been completed
<!-- > Describe your project in 1 or 2 sentences. -->
### How to build the "To Do List"
- 1: Manage Daily task (plain JS with objects).
- 2: Shows list of tasks to be done (plain JS with classes) and add basic CSS.
- 3: Create a complete List of tasks to be done and update it.
**New Features add**
- CRUD (create, read, update, delete) methods. All the elements of the user interface will be fully functional and your application will be completed.
- Functionality to application to make it interactive.
Will start by building the core functionalities and ignoring how the website looks. At the very beginning the website will look similar to the UI below. Note that it is plain HTML with no styling, but it will allow to add and remove books from the list!
<p align="center">
<img src="./src/images/first-apperance.png" alt="Basic UI" width="300px" />
</p>
Once have the code working, will play with refactoring it. In this step will also need to adhere to the layout presented in the wireframe, but i will choose the application's styling. So i initial ugly HTML will turn into better with higher
functionality as described in the following video:
<p align="center">
<a href="https://www.youtube.com/watch?v=AcUd-_Yjjqg" width="400px">Watch the Video</a>
</p>
**To Do List** is an Html,CSS&JavaScript-based project with the implementation of Webpack implementation including development server.
# Responsive website for communities events and particpants details <a name="about-project"></a>
This project is about creating a responsive website to showcase community event, activities and agenda. This is a implementation of SINGLE PAGE APPLICATION widely known as SPA.
<!-- > Describe your project in 1 or 2 sentences. -->
To Do List: mobile-first approach & responsive on desktop version and bigger size is the first capstone project in the process of experiences mimic real-world projects where we must apply what we learned throughout the entire Module, and are built with business specifications that will look really nice in our portfolio. This is a Single Page Application project where in a single page all elements are called through JavaScript Dynamic programming. Along with webpack implementation.
## 🛠 Walk through <a name="walk-through"></a>
<ul>
<li><a href="https://github.com/microverseinc/curriculum-javascript/blob/main/todo-list/m1_list_structure.md">See the Project Requirement</a></li>
<li>If required you should personalize the content of your page. Choose a topic that is different than the one in the original design</li>
## 🛠 Built With <a name="built-with"></a>
### Tech Stack <a name="tech-stack"></a>
<!-- > Describe the tech stack and include only the relevant sections that apply to your project. -->
<details>
<summary>Client Side / Front-End</summary>
<ul>
<li><a href="https://www.w3.org/html/">HTML</a></li>
<li><a href="https://www.w3.org/Style/CSS/">CSS</a></li>
<li><a href="https://www.javascript.com/">Javascript</a></li>
<li><a href="https://webpack.js.org/guides/getting-started/">Webpack</a></li>
</ul>
</details>
<details>
<summary>Server Side / Back-End</summary>
<ul>
<li><a href="https://www.json.org/json-en.html">JSON</a></li>
<!-- <li><a href=""> - </a></li>
<li><a href=""> - </a></li> -->
</ul>
</details>
<!-- Features -->
### Tools i have used for this project <a name="tools"></a>
<details>
<summary>Code Convention, Code Analysis</summary>
<ul>
<li><a href="https://eslint.org/">ESLint</a></li>
<li><a href="https://webhint.io/">Webhint</a></li>
<li><a href="https://stylelint.io/">Stylelint</a></li>
<li><a href="https://chrome.google.com/webstore/detail/lighthouse/blipmdconlkpinefehnmjammfjpmpbjk?hl=en">Lighthouse</a></li>
<li><a href="https://www.npmjs.com/package/npm-check">node_modules checker</a></li>
</ul>
</details>
<details>
<summary>Version Control, CI/CD, Hosting Service</summary>
<ul>
<li><a href="https://pages.github.com/">Github Pages</a></li>
<li><a href="https://github.com/features/actions">Github Actions</a></li>
<li><a href="https://git-scm.com/">Git</a></li>
</ul>
</details>
<details>
<summary>IDE, Desktop Apps, Other Tools</summary>
<ul>
<li><a href="https://code.visualstudio.com/">Visual Studio Code</a></li>
<li><a href="https://desktop.github.com/">Github Desktop</a></li>
<li><a href="https://www.behance.net/">Behance</a></li>
<!-- <li><a href="https://www.figma.com/">Figma</a></li> -->
</ul>
</details>
### Key Features <a name="key-features"></a>
<!-- > Describe between 1-3 key features of the application. -->
- Mobile First Approach
- Responsive Website
- Button Interactions (i.e. hover, etc.)
- Attractive Images & Design
- Modal/dialog
- Dynamic page (data is retrieved from JSON file)
<p align="right">(<a href="#readme-top">back to top</a>)</p>
## 🚀 Live Demo <a name="live-demo"></a>
[Live Demo Link](https://rhk-microverse.github.io/To-Do-List/)
## 💻 Getting Started <a name="getting-started"></a>
### Hi, there, I'm Rassel - aka [Full Stack Developer] [Check my portfolio](https://rhk-microverse.github.io/My-Portfolio/)
To get a local copy up and running, follow these steps.
### Prerequisites
In order to run this project you need:
- git version 2.38.x
- node.js version > 12.x
- IDE
- browser (chrome, firefox, edge, safari)
### Setup
Clone this repository to your desired folder:
```sh
cd my-folder
git git@github.com:RHK-MICROVERSE/To-Do-List.git
```
### Install
Install this project with:
```sh
cd my-project
node install
```
### Usage
To run the project, execute the following command:
run live server
<!--
```sh
rails server
```
-->
### Run tests
To run tests, run the following command:
Run Github Actions Test
```sh
npx stylelint "**/*.{css,scss}"
```
### Deployment
This project is deployed at github pages you can clone it here. [Please click to clone](https://github.com/RHK-MICROVERSE/To-Do-List)
<p align="right">(<a href="#readme-top">back to top</a>)</p>
## 👥 Authors <a name="Rassel Hassan Kadir"></a>
- Main Author: **Rassel Hassan Kadir**
> List of the collaborators of this project.
[Joseph Ddiiro](https://github.com/Ddiiro)
👤 **Rassel Hassan Kadir**
- GitHub: [@githubhandle](https://github.com/RHK-MICROVERSE)
- Twitter: [@twitterhandle](https://twitter.com/rhk_trading)
- Linkedin: [@linkedinhandle](https://www.linkedin.com/public-profile/settings?trk=d_flagship3_profile_self_view_public_profile)
- Email: 9rhktrading@gmail.com
<p align="right">(<a href="#readme-top">back to top</a>)</p>
## 🔭 Future Features <a name="future-features"></a>
- [ ] **Dynamic content.**
- [ ] **Add functionality of Javascript**
- [ ] **Will add some background **
- [ ] **Dynamic control of adding and deleting task through check box **
## 🤝 Contributing <a name="contributing"></a>
Contributions, issues, and feature requests are welcome!
Feel free to check the [issues page](https://github.com/RHK-MICROVERSE/To-Do-List/issues).
<p align="right">(<a href="#readme-top">back to top</a>)</p>
## ⭐️ Show your support <a name="support"></a>
If you like this project give a star to this repositiory.
<p align="right">(<a href="#readme-top">back to top</a>)</p>
## 🙏 Acknowledgments <a name="acknowledgements"></a>
I would like to thank the Microverse full-stack curriculum for the inspiration and guidance. Original design idea by Emilia Andrzejewska.
<p align="right">(<a href="#readme-top">back to top</a>)</p>
## ❓ FAQ <a name="faq"></a>
- **Is it allowed to copy the contents of this project and use it for personal use?**
- Yes, this project is free for copying and reusing in any way you like.
- How often will the future features will be implemented?
- As this is personal porfolio, the owner will update this projects pages more frequently with every enhancements in personal status.
## 📝 License <a name="license"></a>
This project is under [MIT](./LICENSE) licensed.
<p align="right">(<a href="#readme-top">back to top</a>)</p>
| Create a do List to check everyday task and remove what have been completed | css,html,javascript | 2023-03-28T13:19:45Z | 2023-05-02T11:48:52Z | null | 1 | 7 | 24 | 0 | 0 | 3 | null | MIT | JavaScript |
adityatupe-code/Airbnb_clone_main | main | # airbnb_Clone
ejs nodejs expressjs javascript css and bootstrap and npm liabraries are used in this
Airbnb Clone
This is an Airbnb clone made using EJS, JavaScript, CSS, Bootstrap, Node.js, Express.js, and MongoDB. This application allows users to browse and book listings for accommodations, as well as create and manage their own listings as hosts.
Getting Started
To get started with this application, you'll need to have Node.js and MongoDB installed on your machine. You can download Node.js from the official website, and MongoDB from the official website.
Once you have Node.js and MongoDB installed, you can clone this repository by running the .
Running the Application
Before running the application, you'll need to make sure that MongoDB is running on your machine. You can start MongoDB by running the following command in your terminal:mongod
Once MongoDB is running, you can start the application by running the following command: npm start
This will start the application on port 3000. You can access the application by opening your web browser and navigating to http://localhost:3000.
Dependencies
This application relies on several npm packages to function. These packages are listed in the package.json file
| null | css,express,javascript,mongodb,mongoose,nodejs,ejs | 2023-04-02T15:07:59Z | 2023-05-11T13:02:36Z | null | 1 | 0 | 10 | 0 | 0 | 3 | null | null | EJS |
Souvik2376/Test-Typing-Skill | main | # Test-Typing-Skill
The act of typing involves entering text into a computer or other device using a keyboard or another input method. The goal of typing is to swiftly and effectively transmit thoughts and information, frequently using written language. In many various professions, like writing, programming, data entry, customer service, and more, having good typing abilities is essential. There are other methods for typing quickly and accurately, such as touch typing, which uses all ten fingers without looking at the keyboard, and hunt-and-peck typing, which uses one or two fingers to locate and press each key separately. Overall, the ability to type is crucial for people to successfully communicate and do activities in the digital age.
Because so much of our communication now takes place digitally through computers, cellphones, and other devices, having good typing abilities is particularly crucial. The ability to type rapidly and precisely may improve a person's productivity and efficiency at work as well as their ability to interact and communicate with others.
There are a number of strategies that may be used to assist people get better at typing. In order to type properly, for instance, you need keep your shoulders relaxed and your back upright. Taking pauses to stretch and relax your hands and wrists can also be beneficial, especially if you type for long stretches of time.
Practise is another important element in improving one's typing abilities. Regularly doing typing drills and exercises will help you increase your accuracy and speed. There are several websites that provide free typing exercises and games to help you improve.
Finally, it's important to remember that there are several keyboards available with various features and designs that might affect how you type. While some individuals prefer more compact versions or ergonomic designs that are more comfortable for prolonged use, others might prefer mechanical keyboards for their tactile feedback and durability. Overall, you may build excellent typing abilities that will help you in both your personal and professional life by putting an emphasis on proper technique, practise, and selecting the correct keyboard for your purposes.
# Fast Typing Technique
The following quick typing methods will help you increase your typing speed and accuracy:
- Using good finger placement on the keyboard is one of the most crucial aspects of typing quickly. To reduce mobility and boost productivity, each finger should be allocated to a certain set of keys.
- Touch typing: By typing without glancing at the keyboard, you can concentrate on the screen and type more quickly. To use this strategy, it's crucial to remember where each key on the keyboard is located.
- Practise your typing skills on a regular basis to increase both your speed and accuracy. You may improve your typing abilities by taking advantage of the numerous online typing classes and exercises available.
- Learn keyboard shortcuts so that you can type faster and more efficiently. To speed up your work, try learning the standard keyboard shortcuts for your operating system and software programmes.
- Avoid Hunt-and-Peck Typing: This technique involves staring at the keyboard while using only a few fingers to type. Comparing this approach to touch typing, it is sluggish and ineffective.
- Maintain Proper Posture: Sit up straight with your shoulders back and relaxed, feet flat on the ground. This aids in easing stress and avoiding muscular ache.
- Use a Comfortable Keyboard: Your typing speed and accuracy may be greatly improved by using a comfortable keyboard that matches your hand size and typing style.
One may speed up and improve the efficiency of his or her typing by applying these strategies on a regular basis.
# Website Screen Shots
## Run Locally
Initialize git
```bash
git init
```
Clone the project
```bash
git clone https://github.com/Souvik2376/Test-Typing-Skill.git
```
Go to the project directory
```bash
cd Test-Typing-Skill
```
Run the HTML file
```bash
Run index.html
```
** Just chnage to the directory and open the index file and run .
# Test your typing skill
[Live Demo](https://souvik2376.github.io/Test-Typing-Skill/)
| Test your typing skill | api,css,html,javascript | 2023-04-02T15:16:57Z | 2023-04-26T14:53:59Z | null | 1 | 0 | 5 | 0 | 0 | 3 | null | null | JavaScript |
emmanuelekopimo/bubble-weather | main | # Bubble Weather
## Overview 📃
Bubble Weather is a web application that displays real-time weather and weather forecasts using the [open-meteo](https://open-meteo.com/en/docs) weather API. The app allows users to view current, hourly and weekly weather forecasts for any location.
## Features ⭐
- Current weather information including temperature, wind speed and precipitation.
- Hourly weather forecast for the next 24 hours.
- Weekly weather forecast for the next 6 days.
- Simple and intuitive user interface.
No installation required, the app can be accessed through any web browser.
## Technologies Used 🤖
- HTML
- CSS
- JavaScript
- Open-meteo weather API
## How to Use Bubble Weather 📱
Open your web browser and go to the [Bubble Weather](https://bubble-weather.netlify.app/) website.
On the home page, you can search for a location using the search bar or use your current location.
Once you have selected a location, the app will display the current weather information for that location.
The hourly forecast displays the weather information for the next 24 hours.
The weekly forecast displays the weather information for the next 6 days.
## Credits 🧾
The weather data is provided by the open-meteo weather API.
The icons used in the app are from [Flaticon](https://flaticon.con).
## Future Improvements 🚀
- Ability to add multiple locations and save them for future use.
- Improved UI design and user experience.
- Integration with social media platforms to share weather updates.
Feedback and Support
## Contributing 🤝
Contributions are welcome! To contribute to this project, please follow these steps:
- Fork this repository.
- Create a new branch for your feature
- Make your changes and commit them
- Push your changes to your forked repository
- Create a pull request.
## Feedback ✉️
If you have any feedback or need support using Bubble Weather, please email us at emmanuelekopimo@gmail.com
| A weather web app using the open-meteo weather API to display real-time weather and weather forecast. Showing current, hourly and weekly weather | javascript,vanilla-javascript,weather | 2023-04-08T09:04:23Z | 2023-04-17T18:31:17Z | null | 1 | 0 | 41 | 0 | 0 | 3 | null | null | JavaScript |
mrinalxdev/DevMeets | main |
A meet app which can used to create, join and schedule your meetings
If you do a lot of meetings and gets lost in fields of links to find the your next meeting link, then this is a perfect app that can help you
## Deployment
To deploy this project run
```bash
npm install --global yarn
yarn install
yarn run
npm run dev
``` | A platform where all developers can have video calls . Manage all their invited meetings and for free time they can invest it in reading docs and assessing their skills through quiz. | video-call,firebase,zegocloud,documentation,documentation-site,firebase-auth,javascript,quiz,react,types | 2023-04-01T05:51:21Z | 2023-04-02T05:46:20Z | null | 2 | 4 | 53 | 0 | 1 | 3 | null | null | TypeScript |
mahdigosyan/jenabe-time | main | # jenabetime
A complete program to achieve your goal with proper planning
-----------------------------------------
If you, like me, need to see the times you have every day, you are very welcome to this little project of mine.
In this project, we are going to have a goal list program that I named Jenabe-Time.
What is Jenabe Time doing now?
-
1- You can remember your daily list and always have it in front of your eyes
-
2-
You can check off any task or project you have finished and enjoy the completion of that program and move on to the next task on your list.
-
3-It helps you a lot in planning your work and makes you avoid procrastination and finish your plans on time.
-
<b>In short, if you want to have a regular plan for your personal goal, this project can help you a lot</b>
| A complete program to achieve your goal with proper planning | electron,react,todolist,javascript | 2023-04-08T03:24:12Z | 2023-04-11T02:35:46Z | null | 1 | 0 | 108 | 0 | 0 | 3 | null | null | JavaScript |
VarshaRani9/Crypto-Converter | gh-pages | # Crypto-Converter
This is a Crypto Converter web application built using HTML, CSS, JavaScript, React, React Hooks, and the third-party library Ant Design (antd).
The application allows users to convert between different cryptocurrencies. It fetches real-time data from a cryptocurrency exchange API to provide accurate conversion rates. The user interface is designed using Ant Design components, providing a sleek and intuitive experience.
# Technologies Used -
HTML: Used for structuring the web page.
CSS: Used for styling the web page.
JavaScript: Used for logic and interactivity.
React: JavaScript library for building user interfaces.
React Hooks: Used for managing state and lifecycle in functional components.
Ant Design (antd): Third-party UI library for building elegant and efficient user interfaces.
# Features
Convert between cryptocurrencies.
Real-time conversion rates fetched from a cryptocurrency exchange API.
| This repo contains a CRYPTO-CONVERTER application which is build using HTML, CSS, JavaScript, React and ant Design Library. | antd,api,css3,html5,javascript,reactjs | 2023-03-27T16:54:25Z | 2023-07-20T05:03:21Z | null | 1 | 0 | 3 | 0 | 0 | 3 | null | null | HTML |
niklasent/JSADD | main | # JSADD - JavaScript Anti-Debugging Detection Tool
<p align = center>
<a href="https://chrome.google.com/webstore/detail/jsadd-javascript-anti-deb/anebcnjpiakdhcnghhhndapcibdpgjcc"><img src="https://storage.googleapis.com/web-dev-uploads/image/WlD8wC6g8khYWPJUsQceQkhXSlv1/iNEddTyWiMfLSwFD6qGq.png" alt="Get JSADD for Chrome"></a>
</p>
## About
JSADD is a browser extension which detects common techniques implemented by websites that aim to impede, alter or detect debugging attempts using the integrated Developer Tools.
## Supported anti-debugging techniques
JSADD supports the detection of the following anti-debugging techniques:
- ShortCut (Impediment) [[1]](#1)
- TrigBreak (Impediment) (Chromium only) [[1]](#1)
- ConClear (Impediment) [[1]](#1)
- ModBuilt (Alteration) [[1]](#1)
- WidthDiff (Detection) [[1]](#1)
- LogGet (Detection) [[1]](#1)
- Firebug Lite (Detection) (Chrome only) [[2]](#2)
## Currently supported browsers
- Chromium-based browsers (e.g. Google Chrome)
Due to the [lack of support](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/scripting/ExecutionWorld) for the execution world *MAIN* of the scripting API in Firefox, JSADD is not supported for this browser yet.
## References
<a id="1">[1]</a>
Marius Musch and Martin Johns (2021).
“U Can’t Debug This: Detecting JavaScript Anti-Debugging Techniques in the Wild”.
In: 30th USENIX Security Symposium (USENIX Security 21). USENIX Association pp. 2935–2950.
<a id="2">[2]</a>
Sindre Sorhus.
GitHub repository [devtools-detect](https://github.com/sindresorhus/devtools-detect).
## License
[GPLv3](LICENSE.txt)
| Detects the presence of common anti-debugging techniques implemented in a website. | anti-debugging,developer-tools,javascript | 2023-03-26T11:22:11Z | 2023-05-01T13:12:05Z | null | 1 | 1 | 42 | 0 | 1 | 3 | null | GPL-3.0 | JavaScript |
OmerMohideen/meal-generator | master | # Meal Generator
Meal Generator is a web application that helps users generate random meal ideas with tutorials.
## Features
- Generate random meal ideas
- Responsive design for optimal viewing on all devices
## Technologies Used
- [Next.js](https://nextjs.org/)
- [Typescript](https://www.typescriptlang.org/)
- [TailwindCSS](https://tailwindcss.com/)
- [TheMealdB](https://www.themealdb.com/api.php)
## License
[MIT License](./LICENSE) © 2023 [Omer Mohideen](https://github.com/OmerMohideen) | An app which generates a random meal with its ingredients and tutorial on how to prepare | javascript,nextjs,recipe-app,recipe-website | 2023-03-27T09:32:13Z | 2023-03-31T21:08:23Z | null | 1 | 0 | 5 | 0 | 0 | 3 | null | MIT | TypeScript |
aryansaxena094/VJournal | master | # VJournal
This is a simple web application called VJournal, built using Node.js, Express.js, and EJS. It allows users to create blog posts, view all posts on the home page, and view individual posts by clicking on the post title. It also has an about and contact page.
## Technologies Used
- Node.js
- Express.js
- EJS
- body-parser
- lodash
- Bootstrap
## How to Use
1. Clone the repository to your local machine
2. Install the dependencies using the npm install command
3. Start the server using the npm start or node app.js command
4. Open your web browser and go to `http://localhost:3000/` to view the home page
5. To create a new post, click on the "COMPOSE" button on the navigation bar and fill out the form
6. To view an individual post, click on the post title on the home page
7. To view the about or contact page, click on the respective links on the navigation bar
## Project Structure
- app.js - The main application file
- views - Contains the EJS templates used to render the views
- partials - Contains the header and footer EJS templates used in multiple views
- about.ejs - The about page view
- compose.ejs - The post creation page view
- home.ejs - The home page view
- post.ejs - The individual post page view
- contact.ejs - The contact page view
- public - Contains the static assets like CSS and images
## Credits
This project was created by Aryan Saxena.
| "VJournal" is a web application built on Node.js, Express, and EJS that lets users create and publish blog posts. It features dynamic URL routing, HTTP request handling, and client-server communication, as well as responsive front-end design and customized styling. | css,ejs,expressjs,javascript,lodash | 2023-03-27T01:42:17Z | 2023-03-29T05:58:02Z | null | 1 | 0 | 14 | 0 | 0 | 3 | null | null | EJS |
alwaz-shahid/extenstion-chrome-get-tabs-data | main | <h1> Chrome Extension - Get Data from Tabs</h1>
<hr/> <br/>
<h2>Introduction</h2>
<p>The Chrome tab extension is a lightweight tool that enables users to quickly and easily extract the title and URL of each open tab in their Chrome browser. This extension is perfect for anyone who wants to save their current browsing session or keep a record of the websites they visit. The extension provides a simple and intuitive user interface, with the ability to export the extracted data to a file for easy sharing and organization.p>
<hr/> <br/>
<h2>Installation</h2>
<p>To install this extension, follow these steps:</p>
<ol>
<li>Download the extension files from the <a href="https://github.com/alwaz-shahid/extenstion-chrome-get-tabs-data">GitHub repository</a>.</li>
<li>Open Chrome and go to the Extensions page (chrome://extensions).</li>
<li>Turn on Developer mode.</li>
<li>Click the "Load unpacked" button and select the folder where you downloaded the extension files.</li>
<li>The extension should now be installed and ready to use.</li>
</ol>
<hr/> <br/>
<h2>Usage Instructions</h2>
<ol>
<li>Download the extension from the repository.</li>
<li>Open the Chrome browser and go to the Extensions page by typing "chrome://extensions/" in the address bar and hitting Enter.</li>
<li>Enable the Developer mode by clicking on the toggle switch on the top right corner of the Extensions page.</li>
<li>Drag and drop the downloaded CRX file onto the Extensions page.</li>
<li>Alternatively, click on the "Load unpacked" button and select the unzipped folder containing the extension files.</li>
<li>The extension should now be installed and ready to use.</li>
</ol>
<hr/> <br/>
<h2>Contributing</h2>
<p>If you would like to contribute to this project, please see the <a href="https://github.com/alwaz-shahid/extenstion-chrome-get-tabs-data/blob/master/CONTRIBUTING.md">contributing guidelines</a>.</p>
<h2>License</h2>
<p>This project is licensed under the MIT License. See the <a href="https://github.com/alwaz-shahid/extenstion-chrome-get-tabs-data/blob/master/LICENSE">LICENSE</a> file for more information.</p>
| The Chrome tab extension is a lightweight tool that enables users to quickly and easily extract the title and URL of each open tab in their Chrome browser. This extension is perfect for anyone who wants to save their current browsing session or keep a record of the websites they visit. | browser-extension,chrome-extension,tabs-management,chrome,chrome-extensions,html,javascript,productivity | 2023-04-01T13:20:18Z | 2023-04-23T10:31:21Z | null | 1 | 0 | 11 | 0 | 0 | 3 | null | MIT | JavaScript |
juliaDooby/Responsive-contact-form | main | ## Responsive-contact-form / ( Feedback form: form validation )
<div align="center"><img src="https://github.com/juliaDooby/Responsive-contact-form/blob/main/validationFormShot.JPG" width="100%" height="20%"></img></div>
[demo](https://juliadooby.github.io/Responsive-contact-form/)
---
### Technologies Used:
* HTML5
* CSS3
* Javascript
* PHP
---
### Development stages:
### [Frontend]
* Made the appearance of the form.
* Adapted for mobile devices.
* Wrote a universal script in JS for validating form fields.
* This script will automatically determine that the field is being checked for validity.
* To do this, just add a custom attribute to the input in the HTML markup.
* If the frame value is incorrect, the input fields are highlighted in red, if correct - green.
* The form submit button only works if all fields are filled out correctly.
| Feedback form: form validation | css3,html5,javascript,php,css,html | 2023-04-04T12:22:01Z | 2024-01-03T22:29:38Z | null | 1 | 0 | 30 | 0 | 0 | 3 | null | null | PHP |
emmett1999/cs2tactics | main | # AngularCs2tactics
This project was generated with [Angular CLI](https://github.com/angular/angular-cli) version 16.0.3.
## Development server
Run `ng serve` for a dev server. Navigate to `http://localhost:4200/`. The application will automatically reload if you change any of the source files.
## Code scaffolding
Run `ng generate component component-name` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module`.
## Build
Run `ng build` to build the project. The build artifacts will be stored in the `dist/` directory.
## Running unit tests
Run `ng test` to execute the unit tests via [Karma](https://karma-runner.github.io).
## Running end-to-end tests
Run `ng e2e` to execute the end-to-end tests via a platform of your choice. To use this command, you need to first add a package that implements end-to-end testing capabilities.
## Further help
To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.
| My Angular site for viewing Counter Strike 2 gifs | angular,counter-strike-2,counter-strike-global-offensive,javascript | 2023-03-26T17:19:39Z | 2024-03-16T00:32:33Z | 2023-12-28T00:19:24Z | 1 | 17 | 133 | 0 | 1 | 3 | null | null | TypeScript |
david-torres/tournament-organizer | main | # Tournament Organizer API
A REST API for creating and managing tournaments (single-elimination or round-robin), participants, and matches, with support for Elo ratings and bracket visualization.
## Features
- Create new members (participants)
- Create single-elimination tournaments
- Create round-robin tournaments
- Allow members to join tournaments
- Generate randomized matches, supporting byes for players with the highest Elo scores
- Track member Elo scores across matches and tournaments
- Generate a bracket graphic for visualizing the tournament
## Getting Started
### Prerequisites
- Node.js (v14 or newer)
- npm (v6 or newer)
### Installation
1. Clone the repository:
git clone https://github.com/david-torres/tournament-organizer.git
cd tournament-organizer
2. Install dependencies:
npm install
3. Start the API server:
node app.js
The API server will be running at `http://localhost:3000`.
## API Endpoints
| Method | Endpoint | Description |
|--------|----------------------------------------|----------------------------------------------------|
| GET | /members | Get a list of members |
| GET | /members/search?name=NAME | Search for a member by name |
| POST | /members | Create a new member |
| POST | /tournaments | Create a new tournament |
| GET | /tournaments/:id/participants | Get a list of tournament participants |
| POST | /tournaments/:id/participants | Add a member to a tournament |
| POST | /tournaments/:id/start | Generate matches to start a tournament |
| GET | /tournaments/:id/matches | Get the list of matches for a tournament |
| PATCH | /tournaments/:id/matches/:id | Update a match (set the winner) |
| GET | /tournaments/:id/bracket | Get the bracket data for a tournament |
## Bracket Visualization
You can get an HTML or PNG representation of the tournament bracket by calling:
HTML
wget http://localhost:3000/tournaments/:id/bracket?format=html
PNG
wget http://localhost:3000/tournaments/:id/bracket?format=image
## Running the Simulation Script
You can run the `simulate-tournament.js` script to simulate the entire flow of adding members, creating a tournament, participants joining, generating matches, and randomly assigning winners until the tournament is complete:
node simulate-tournament.js
## AI Disclosure
A large amount of this code was generated by ChatGPT (GPT-4). That said, it was pretty buggy and broken and I had to fix it up a fair amount to get it usable. See the [prompt](gpt-prompt.txt).
## License
This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
| A REST API for creating and managing tournaments (single-elimination or round-robin), participants, and matches, with support for ELO ratings and bracket visualization. | javascript,tournament,tournament-manager | 2023-04-08T03:11:03Z | 2024-03-14T02:37:45Z | null | 1 | 4 | 35 | 0 | 0 | 3 | null | MIT | JavaScript |
paribhandarkar/portfolio | main | # Pari's Portfolio
My portfolio project is a reflection of my creativity, technical skill, and unique perspective as a front end developer. I've designed every aspect of the website, from the user interface to the code, with my personal aesthetic and approach to web development in mind.
You can check out my portfolio by visiting [this link](https://paribhandarkar.vercel.app/).
<img src='https://paribhandarkar.vercel.app/static/media/portfolio.8c20f43c6eb9b3701dd84b6d92ce86ab.svg' />
## Inspiration
As someone who is passionate about computer science, I believe that incorporating my own unique perspective and aesthetic into my work is crucial. While traditional stereotypes of computer science might prioritize a masculine and utilitarian aesthetic, I see value in adding elements of femininity to my projects. This can include everything from the design of user interfaces to the code itself.
While some might argue that incorporating feminine aesthetics is not "serious" or "professional" enough for the field of computer science, I believe that this attitude is outdated and limiting. By embracing a more diverse range of aesthetics and design elements, we can create projects that are not only visually engaging, but also more representative of the diverse individuals who use them.
| My portfolio project is a reflection of my creativity, technical skill, and unique perspective as a front end developer. I've designed every aspect of the website, from the user interface to the code, with my personal aesthetic and approach to web development in mind. | animation-css,css,html,javascript,pink,pink-theme,portfolio,portfolio-page,portfolio-site,portfolio-website | 2023-03-29T20:14:22Z | 2023-04-11T17:30:59Z | null | 1 | 0 | 22 | 0 | 0 | 3 | null | null | JavaScript |
robertojunnior/alura-midi | master | null | Projeto chamado "Alura-Midi" criado dentro da Formação Front-end da escola de educação e tecnologia @alura. Apresentado por @vanessametonini . | css,devtools,github,html,javascript | 2023-04-01T22:37:25Z | 2023-07-16T22:43:24Z | null | 1 | 0 | 18 | 0 | 0 | 3 | null | null | CSS |
diego-rascon/panther-games | master | # Panther Games
## Tabla de Contenido
- [Introducción](#introduction)
- [Trabajando con el Proyecto](#working-with-the-proyect)
- [Requisitos Prévios](#prerequisites)
- [Recomendaciones](#recommendations)
- [Instalación](#instalation)
- [Ejecución](#execution)
- [Construcción](#building)
- [Créditos](#credits)
<a id="introduction"></a>
## Introducción
Panthes Games es un negocio ubicado en Cd. Obregón, Sonora que se dedica a vender artículos relacionados a videojugeos y a la cultura popular. Este es un punto de venta diseñado para uso interno del negocio y está desarrollado por alumnos de ITESCA que cursan la materia de ingeniería de software en la carrera de ingeniería en sistemas computacionales.
La aplicación está desarrollada con Sveltekit utilizando Typescript, un framework que usa Svelte como su UI framework. También se utiliza Tailwind CSS para estilizar el proyecto y Tauri para ejecutar la aplicación en el escritorio, con un backend en Supabase.
<a id="working-with-the-proyect"></a>
## Trabajando con el Proyecto
<a id="prerequisites"></a>
### Requisitos Prévios
Para trabajar con la versión web del proyecto, solo se requiere de Node.js. Si se desea trabajar con la versión de escritorio del proyecto usando Tauri en Windows 10/11, se requieren los siguientes componentes:
- Microsoft Visual Studio C++ Build Tools.
- Rust.
Para más información y para conocer los requisitos para macOS y Linux, favor de seguir las instrucciones listadas en <https://tauri.app/v1/guides/getting-started/prerequisites>.
<a id="recommendations"></a>
### Recomendaciones
Se recomienda utilizar un editor de código como [Visual Studio Code](https://code.visualstudio.com/) para trabajar con el proyecto, así como las siguientes extensiones:
- [Auto Rename Tag](https://marketplace.visualstudio.com/items?itemName=formulahendry.auto-rename-tag)
- [EditorConfig for VS Code](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig)
- [ESLint](https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint)
- [HTML CSS Support](https://marketplace.visualstudio.com/items?itemName=ecmel.vscode-html-css)
- [IntelliCode](https://marketplace.visualstudio.com/items?itemName=VisualStudioExptTeam.vscodeintellicode)
- [IntelliCode API Usage Examples](https://marketplace.visualstudio.com/items?itemName=VisualStudioExptTeam.intellicode-api-usage-examples)
- [Prettier - Code formatter](https://marketplace.visualstudio.com/items?itemName=esbenp.prettier-vscode)
- [rust-analyzer](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer)
- [Svelte for VS Code](https://marketplace.visualstudio.com/items?itemName=svelte.svelte-vscode)
- [Tailwind CSS IntelliSense](https://marketplace.visualstudio.com/items?itemName=bradlc.vscode-tailwindcss)
- [Tauri](https://marketplace.visualstudio.com/items?itemName=tauri-apps.tauri-vscode)
<a id="instalation"></a>
### Instalación
Para preparar el proyecto, se utilizan los siguientes comandos:
```bash
# se clona el repositorio
git clone https://github.com/diego-rascon/panther-games.git
# entramos a la carpeta
cd panther-games
# instalamos las dependencias de node.js
npm install
```
<a id="execution"></a>
### Ejecución
El proyecto puede ser ejecutado en su propia ventana utilizando Tauri o a través del navegador en un servidor local:
```bash
# ejecutando el proyecto con Tauri
npm run tauri dev
# ejecutando el proyecto en el navegador
npm run dev
```
<a id="building"></a>
### Construcción
El proyecto puede ser construido para la web o como un instalador para una aplicación nativa de escritorio con Tauri.
Actualmente Tauri solo es capaz de construir instaladores para la plataforma en la que se está usando, es por eso que el archivo que es compilado solo puede ser uno de los siguientes:
- Windwos: *-setup.exe*, *.msi*.
- macOS: *.app*, *.dmg*.
- Linux: *.deb*, *.appimage*.
```bash
# construyendo instaladores para la plataforma actual
npm run tauri build
# construyendo el proyecto para la web
npm run build
```
<a id="credits"></a>
## Créditos
La planeación y desarrollo de este software fue completamente hecha por:
- Dulce Roxanna Clark Valenzuela ([fungirox](https://github.com/fungirox)).
- José Antonio Vega Saenz ([TonyDWKR](https://github.com/TonyDWKR)).
- José Diego Rascón Amador ([diego-rascon](https://github.com/diego-rascon)).
| Punto de venta hecho con Tauri, Sveltekit y Supabase para el negocio de videojuegos Panther Games. | eslint,javascript,nodejs,pos,prettier,supabase,svelte,sveltekit,tailwindcss,tauri | 2023-04-07T17:28:17Z | 2023-05-17T15:23:06Z | 2023-05-17T15:23:06Z | 3 | 0 | 689 | 0 | 3 | 3 | null | null | Svelte |
vikyw89/pinterestClone | dev | ## This is an attempt to clone Pinterest, with a slight twist
Alpha live preview: https://vikyw89.github.io/pinterestClone/
Beta live preview: https://pinterest-clone-lemon.vercel.app/
Lighthouse score compared to interest :
## Dependencies and Libraries and some tech choices:
- supabase (for BAAS)
- because pinterest data is mostly relational
- BAAS is faster to deploy and prototype than writing backend from scratch
- downside is subscribe function in supabase / postgres aren't that good
- rpc is stored in the cloud supabase site
- Cloudinary
- for storage of image and assets
- it has cloud / edge function to resize assets and convert it to filetype that we want
- we mostly use webp and webp animated for image because browser support above 95% and file size is small
- nextJS SSG
- filesystem routing is intuitive
- it's the new recomended way to scafold react app as per react.dev
- SSG has faster initial load to client
- we use nextImage as a way to efficiently show blurhas or placeholder to prevent big layout shift in feeds
- some improvement to be made, store the image size in database because next image needs size to enable the blur placeholder (right now we use square, so there will be minimal layout shift)
- SWR for fetching and state management
- it scales better than local state
- the idea of rebuilding model for front end using redux and copying normalized database to front end, and doing JOIN operation in front end isn't appealing
- single source of truth is in the backend / db
- added additional useSyncSWR for global state using swr
- Browser image compressor
- To compress image before storing in backend
- it's lightweight and fast for images under 1MB
- no need to recreate and host backend
- TailwindCSS and daisyUI
- trying out new css framework aside from css module, bootstrap and mui
- nextJS offers it
- it has a lot of theme
- GH action
- enabled CI CD for deployment
- in the future we can have different branch for dev purpose / alpha, beta, and latest/stable automatic release and versioning.
## Database model:
outdated, but the idea holds
some improvements can be made, using only insert operation, and no delete therefore maintaining log etc
## Page Routing:
```
'/'
// home shows all pins in the background
// for unsigned user, no search button
'/pin/[pin_id]'
// pin page, show title, description, comment, pin creator stats, follow button etc
'/[user_id]'
// profile page, show user's board, unorganized board, and user stats
'/[user_id]/[board_title]'
// board page, show board's stats, members, content and recomendation
'/createPin'
// show a page to create a pin
sign in and signup will be handled in the '/' route using popup or modal
```
## Original assignment from TOP
<section id="assignment">
<h3><a href="#assignment" class="anchor-link">Assignment</a></h3>
<div class="lesson-content__panel">
<p>Replicate your favorite website as close as possible - Pinterest, Facebook, Twitter, etc. Just make sure it has lots of interesting functionality. You’ll be integrating a full array of skills into this one. If you have completed a backend course, you may use that for this project, otherwise use Firebase. This should prove that you now have all the tools and knowledge needed to build a website, just like the ones you use every day.</p>
<p>Of course, you can’t replicate every feature, and the user interface will probably be a bit clunkier. However, if you can get yourself 80% of the way there, that’s darn impressive!</p>
<ol>
<li>Set up a GitHub Repo for this project. Follow the instructions in <a href="https://www.theodinproject.com/paths/foundations/courses/foundations/lessons/git-basics" target="_blank" rel="noopener noreferrer">Git basics</a> if you need help.</li>
<li>Think about what you need to do. It’s really helpful to write your plan down on paper or whiteboard ahead of time! A few hours of thought now will save you days of coding. Try to lay it ALL out. An important part of planning is <strong>scope</strong>. You obviously can’t build the entire website (which presumably took a full team of engineers years to produce), so you’ll need to identify the site’s core functionality and the “nice-to-have” stuff. <strong>Make sure you finish the core functionality BEFORE working on the rest.</strong> If you try to do everything at once, you’ll get lost and frustrated. Trust us. Everything takes longer than you expect.</li>
<li>Roll up your sleeves and start building!</li>
<li>Try to test the high-level functionality using a suitable testing library, for example, Javascript with Jest or Rails with RSpec. Don’t get too bogged down in testing, but try and save yourself time by adding high-level tests, so you don’t need to click around 100 times every time you make a change to something that seems important.</li>
<li>Once you finish, push to GitHub and definitely submit your project below!</li>
</ol>
</div>
</section>
| A pinterest clone with a twist | css3,html5,javascript,nextjs,postgresql,react,supabase,tailwindcss,github-actions | 2023-04-01T13:54:17Z | 2023-07-26T05:51:52Z | null | 2 | 56 | 323 | 5 | 0 | 3 | null | MIT | JavaScript |
lebleb/ts-library-monorepo-starter | main | # Monorepo + TypeScript + Jest + Eslint
**This starter kit includes a TypeScript build that optimizes the build for speed, eliminating the need to build each project individually.**
This is a monorepo starter kit with TypeScript, Jest, ESLint, and Commitlint pre-configured. The main purpose of this repository is to provide a zero-config project setup for developers who want to start writing code immediately without worrying about the initial project setup.
## Features
- **Yarn 2+** package manager [Yarn](https://yarnpkg.com/)
- **Monorepo** structure with [Yarn workspaces](https://yarnpkg.com/features/workspaces)
- **TypeScript** support with [tsconfig.json](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html)
- **Jest** for unit testing with [ts-jest](https://github.com/kulshekhar/ts-jest)
- **ESLint** for code linting with [StandardJS - JavaScript Standard Style](https://standardjs.com/)
- **Commitlint** for commit message linting with [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/)
- **CI/CD** process for each PR with [GutHub Workflow](https://docs.github.com/en/actions/using-workflows/about-workflows)
- **Automatic versioning** with [Changesets](https://github.com/changesets/changesets)
- **Publishing** each package to the [NPM](https://www.npmjs.com/)
## Getting started
To use this starter kit, you need to follow these simple steps:
1. Clone this repository:
**HTTPS:**
```sh
git clone https://github.com/lebleb/ts-library-monorepo-starter
```
**SSH:**
```sh
git clone git@github.com:lebleb/ts-library-monorepo-starter.git
```
2. Install dependencies using Yarn:
```sh
cd starter-kit
yarn
```
3. Start writing your code!
## Available Scripts
In the project directory, you can run the following scripts:
### `yarn test`
Runs unit tests using Jest.
### `yarn lint`
Runs ESLint on all TypeScript files in the project.
### `yarn format`
Formats all TypeScript files in the project using [StandardJS - JavaScript Standard Style](https://standardjs.com/)
### `yarn build`
Builds the TypeScript code into the `dist` directory.
### `yarn clean`
Cleans the compiled codes and ts schema files.
## Steps to Publish a New Version of Packages Using Changesets
1. Make the necessary changes to your code and create a pull request.
2. Before the pull request is merged, run the following command to create a new changeset:
```sh
yarn changeset
```
3. Answer the questions that are prompted to describe the changes you made. The changeset will be added to the changesets/ directory.
4. Push the changeset commit to your branch.
5. When you're ready to release the new version of your package, merge your PR into the main branch.
6. The changeset library will automatically create a new pull request titled "Release [VERSION]" to release the new version of your package. Review the changes and merge the pull request.
7. Once the pull request is merged, the changeset library will automatically publish the new version of your package to the npm registry.
Using changesets makes it easy to manage package versions in your GitHub repository, and automates the process of releasing new versions to the npm registry. By following these steps, you can publish new versions of your packages quickly and efficiently, with minimal manual intervention.
## Contributing
If you want to contribute to this project, please fork the repository and create a pull request with your changes. Make sure to follow the [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/) format for your commit messages.
## License
This project is licensed under the [MIT License](LICENSE).
| This starter kit includes a TypeScript build that optimizes the build for speed, eliminating the need to build each project individually. It also includes an npm publish mechanism, making it easy to share your code with the community. | boilerplate,eslint,github-workflow,javascript,jest,monorepo,nodejs,typescript,unit-testing,changesets | 2023-04-07T13:56:15Z | 2023-05-05T13:54:34Z | 2023-04-30T08:10:49Z | 1 | 14 | 27 | 0 | 1 | 3 | null | MIT | TypeScript |
Wellington-lopes/Mario-Bros-Game | main | # Mario Game
## Description
The Mario Game is a web-based game that replicates the classic T-Rex Runner gaming experience you often find in web browsers when there's no internet connection. It is built using HTML, CSS, and JavaScript to provide an interactive and enjoyable gameplay experience.
## Gameplay
In this game, players control Mario, the iconic character from the Nintendo series, as he navigates through various levels filled with obstacles. The goal is to jump over pipes to achieve the highest score possible without hitting anything.
## Technologies Used
- **HTML:** The structure of the game is built using HTML.
- **CSS:** CSS is used for styling the game elements, making it visually appealing.
- **JavaScript:** JavaScript is responsible for the game's logic, including character movement, enemy behavior, and collision detection.
## Demo
You can play the game online by visiting the following link: [Mario Game Demo](https://mario-bros-game-puce.vercel.app/)
## Installation
If you want to run the game locally on your machine, follow these steps:
1. Clone the repository to your computer.
2. Open the project folder and launch the `index.html` file in a web browser.
3. Start playing and enjoy!
## Credits
This game was created by Wellington Lopes. Feel free to reach out for any questions or feedback.
## License
This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details.
## Acknowledgments
- Special thanks to Nintendo for creating the iconic Mario character and providing inspiration for this project.
Feel free to customize this README with your project's specific details and links.
Playing (Jump the pipes to earn points):
Image of Mario's death and restart game button:
| :video_game: The Mario Game is a web-based game that replicates the classic T-Rex Runner gaming experience you often find in web browsers when there's no internet connection. It is built using HTML, CSS, and JavaScript to provide an interactive and enjoyable gameplay experience. | css3,git,github,html5,javascript,vercel | 2023-03-29T01:03:28Z | 2023-11-07T15:49:02Z | null | 1 | 0 | 11 | 0 | 0 | 3 | null | MIT | CSS |
xvisierra/cryptock | main | # cryptock
Cryptock is a web-based project that allows users to track the live prices of various cryptocurrencies and view their profit/loss on their investments through a personalized dashboard. The project is built using HTML, CSS, and JavaScript, and it uses the CoinGecko API to retrieve real-time cryptocurrency data.
The user interface is designed to be simple and intuitive, allowing users to easily navigate through the different sections of the dashboard. Users can add their preferred cryptocurrencies to the dashboard and view real-time price updates. Additionally, they can view their profit/loss on their investments and track their overall portfolio performance.
The project is built using modern web technologies and follows best practices in web development, including responsive design and optimized performance. Cryptock aims to provide users with a comprehensive and user-friendly tool for tracking their cryptocurrency investments in real-time.
| Cryptock is a web-based project that allows users to track the live prices of various cryptocurrencies and view their profit/loss on their investments through a personalized dashboard. The project is built using HTML, CSS, and JavaScript, and it uses the CoinGecko API to retrieve real-time cryptocurrency data. | html,api,crypto,cryptocurrency,css,css3,html5,javascript,website | 2023-04-04T10:49:38Z | 2023-08-20T18:39:40Z | null | 1 | 0 | 12 | 0 | 1 | 3 | null | null | HTML |
surajaswal29/crypto-assignment | master | # crypto-assignment
<p>This is a simple application which can fetch data from the wzirx API (https://api.wazirx.com/api/v2/tickers) and can display the data on the web page, which is developed by HTML+CSS+Bootstrap and managed by Handlebars</p>
<hr>
This Project is Developed using:
<h2>Frontend: HTML, CSS, Express Template Engine (HandleBar)</h2>
<h2>Backend: Express, Nodejs</h2>
<h2>Database: MongoDB</h2>
| This is a simple application which can fetch data from the wzirx API and can display the data on the web page, which is developed by HTML+CSS+Bootstrap and managed by Handlebars | bootstrap,css,express,expressjs,handlebars,handlebars-js,html5,javascript,mongodb,nodejs | 2023-04-07T18:59:35Z | 2023-04-18T18:36:09Z | null | 1 | 1 | 9 | 0 | 0 | 3 | null | MIT | Handlebars |
daredevilevi/Digital | master | null | A Digital Agency Website created with help of https://github.com/codewithsadee by following CodewithSaddee Youtube Tutorial | agency,css,css-grid,css3,digital,html,html-css,html5,javascript,js | 2023-04-02T15:52:01Z | 2023-04-02T15:53:55Z | null | 1 | 0 | 1 | 0 | 0 | 3 | null | null | HTML |
MatinAniss/traction.js | master | # Traction.js
Simple customizable loading progress bar for nextjs and sveltekit.
# NextJS
## Install
NPM
```bash
npm install @traction.js/nextjs
```
Yarn
```bash
yarn add @traction.js/nextjs
```
PNPM
```bash
pnpm add @traction.js/nextjs
```
## Example
### \_app.tsx
```jsx
import { type AppType } from "next/app";
import Traction from "@traction.js/nextjs";
const MyApp: AppType = ({ Component, pageProps: { ...pageProps } }) => {
return (
<>
<Traction />
<Component {...pageProps} />
</>
);
};
export default MyApp;
```
# SvelteKit
## Install
NPM
```bash
npm install @traction.js/sveltekit
```
Yarn
```bash
yarn add @traction.js/sveltekit
```
PNPM
```bash
pnpm add @traction.js/sveltekit
```
## Example
### +layout.svelte
```svelte
<script>
import Traction from "@traction.js/sveltekit";
</script>
<Traction />
<slot />
```
# Traction Props
## Default Props
```jsx
<Traction color="#FF0000" incrementInterval={100} incrementAmount={10} transitionDuration={500} transitionTimingFunction="ease" />
```
## Options
`color`: The hex color of the progress bar. `"#FF0000"`
`incrementInterval`: The interval in milliseconds between each increment. `100`
`incrementAmount`: The amount of progress to increment between each increment interval. `10`
`transitionDuration`: The duration in milliseconds of the transition. `500`
`transitionTimingFunction`: The type of transition timing function. `"ease" | "linear" | "ease-in" | "ease-out" | "ease-in-out"`
| Simple customizable loading progress bar for nextjs and sveltekit. | nextjs,javascript,loading,progress,progress-bar,svelte,sveltekit,traction,typescript | 2023-03-29T11:24:08Z | 2023-04-14T00:16:12Z | null | 1 | 0 | 27 | 0 | 0 | 3 | null | MIT | TypeScript |
fabioarnold/matrix | main | null | Matrix text effect | canvas2d,effect,javascript,matrix | 2023-04-02T12:33:54Z | 2023-05-06T19:39:27Z | null | 1 | 0 | 8 | 0 | 0 | 3 | null | null | JavaScript |
bilinguator/print-bilingual-pdf | main | 
# Print Bilingual PDF
This repository contains JS scripts to open new browser window wherein paragraphs of two aligned source texts are assembled to bilingual document which can be printed into PDF file. The aligned source texts are not just plain texts but have simple and useful [specification](#aligned-text-files-specification).
## Quick start
Put the `print-bilingual-pdf` folder with all the repository contents right to the main folder of your project. Add the script tag to your HTML page:
```html
<script type="text/javascript" src="print-bilingual-pdf/scripts/print_bilingual_pdf.js"></script>
```
Specify `src` attribute if the `print_bilingual_pdf.js` script location changed. Make sure that all JS scripts presented in this repository are located in the same folder. Make sure that the [`print-bilingual-pdf/scripts/print_bilingual_pdf.js`](scripts/print_bilingual_pdf.js) script and the [`print-bilingual-pdf/css/printed_book.css`](css/printed_book.css) are co-located as presented in this repository, otherwise specify a correct location of the `printed_book.css` in the `print_bilingual_pdf.js`.
When the script is correctly plugged in to your HTML page, use the function:
```javascript
printBilingualPDF (text1, text2, lang1, lang2,
mode = 'cols', cover = '', fileName = 'bilingual_book', illustrationsFolder = '/');
```
where `text1`, `text2` - strings containing the full contents of two aligned source texts to be printed;
`lang1`, `lang2` - strings standing for ISO 639 language codes for the two texts; especially important for right-to-left written languages and hieroglyph-based languages;
`mode` - string determining if the constructed bilingual document comprises parallel columns (`'cols'`) or alternating rows (`'rows'`);
`cover` - string containing the address to the book cover; for the best fit, cover should be vertical with proportions 230mm×297mm;
`fileName` - string containing the name of the printed PDF document;
`illustrationsFolder` - string containing the location of the book illustrations if they are.
For creating the document with illustrations, move all the illustrations to one directory, name them as natural arabiс numbers like [here](demonstration/img/illustrations). For more details on illustrations in your bilingual books see the [source texts sepcification](https://github.com/bilinguator/bilingual-formats/blob/main/README.md#book-body).
## Aligned text files specification
See aligned texts specification in the [Aligned Texts](https://github.com/bilinguator/aligned-texts#aligned-text-files-specification) repository.
## Precautions and advices
These codes are browser and texts dependent. In case of big texts with big paragraphs, bugs may occur.
You can change any files, especially CSS (page size, font size and style, etc.) to improve the code execution.
If you don't want to create but you like to read bilingual books, visit [Bilinguator.com](https://bilinguator.com/).
| JS scripts to create bilingual HTML page printable to PDF. | bilingual,html,javascript,pdf,pdf-generation,print,printing,css,ebook,languages | 2023-03-28T14:05:03Z | 2023-10-29T19:57:12Z | null | 2 | 6 | 24 | 0 | 1 | 3 | null | MIT | HTML |
MeetDOD/Learning-Management-System-LMS-Frontend- | main | # Getting Started with Create React App
This project was bootstrapped with [Create React App](https://github.com/facebook/create-react-app).
## Available Scripts
In the project directory, you can run:
### `npm start`
Runs the app in the development mode.\
Open [http://localhost:3000](http://localhost:3000) to view it in your browser.
The page will reload when you make changes.\
You may also see any lint errors in the console.
### `npm test`
Launches the test runner in the interactive watch mode.\
See the section about [running tests](https://facebook.github.io/create-react-app/docs/running-tests) for more information.
### `npm run build`
Builds the app for production to the `build` folder.\
It correctly bundles React in production mode and optimizes the build for the best performance.
The build is minified and the filenames include the hashes.\
Your app is ready to be deployed!
See the section about [deployment](https://facebook.github.io/create-react-app/docs/deployment) for more information.
### `npm run eject`
**Note: this is a one-way operation. Once you `eject`, you can't go back!**
If you aren't satisfied with the build tool and configuration choices, you can `eject` at any time. This command will remove the single build dependency from your project.
Instead, it will copy all the configuration files and the transitive dependencies (webpack, Babel, ESLint, etc) right into your project so you have full control over them. All of the commands except `eject` will still work, but they will point to the copied scripts so you can tweak them. At this point you're on your own.
You don't have to ever use `eject`. The curated feature set is suitable for small and middle deployments, and you shouldn't feel obligated to use this feature. However we understand that this tool wouldn't be useful if you couldn't customize it when you are ready for it.
## Learn More
You can learn more in the [Create React App documentation](https://facebook.github.io/create-react-app/docs/getting-started).
To learn React, check out the [React documentation](https://reactjs.org/).
### Code Splitting
This section has moved here: [https://facebook.github.io/create-react-app/docs/code-splitting](https://facebook.github.io/create-react-app/docs/code-splitting)
### Analyzing the Bundle Size
This section has moved here: [https://facebook.github.io/create-react-app/docs/analyzing-the-bundle-size](https://facebook.github.io/create-react-app/docs/analyzing-the-bundle-size)
### Making a Progressive Web App
This section has moved here: [https://facebook.github.io/create-react-app/docs/making-a-progressive-web-app](https://facebook.github.io/create-react-app/docs/making-a-progressive-web-app)
### Advanced Configuration
This section has moved here: [https://facebook.github.io/create-react-app/docs/advanced-configuration](https://facebook.github.io/create-react-app/docs/advanced-configuration)
### Deployment
This section has moved here: [https://facebook.github.io/create-react-app/docs/deployment](https://facebook.github.io/create-react-app/docs/deployment)
### `npm run build` fails to minify
This section has moved here: [https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify](https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify)
| This is the frontend for LMS created using reactjs and django-rest-framework. | bootstrap5,css,html,reactjs,scss,javascript | 2023-04-05T15:22:48Z | 2023-06-21T08:49:48Z | null | 1 | 0 | 2 | 0 | 0 | 3 | null | null | JavaScript |
Skparab1/inkball | main | # Inkball • [Play](https://skparab1.github.io/inkball) • [Leaderboard](https://skparab1.github.io/inkball/leaderboard.html)
Developed by Shubham Parab, Anindit Pati, Advaita Guruprasad, Ritam Chakraborty, and Snehil Kakani
<img width="200" alt="Inkball logo" src="https://user-images.githubusercontent.com/71990977/233870117-bd24288d-91bf-40e1-992f-13288d4be7af.png">
# Features
## High quality adapting graphics
<img width="500" alt="Screen Shot 2023-04-23 at 12 55 53 PM" src="https://user-images.githubusercontent.com/71990977/233869633-66ec4ea2-1ec8-4200-9c37-648dd1111421.png">
Inkball's high quality display ensures the most immersive experience for the player. Capable of 4240*1990 pixel display, the game ensures usage of maximum capability by always rendering a near full height display - no matter the device. In addition, the game calculates live fps for each play and adjusts the game speed accordingly, ensuring a fair experience for all players.
## Feature rich game concept
<img width="500" alt="Screen Shot 2023-04-23 at 3 39 04 PM" src="https://user-images.githubusercontent.com/71990977/233869895-e5cb5b06-46a5-4cab-a45c-736f8a2ebb70.png">
A host of different game changing features enhancee both the difficulty and fun of a map.
## 32 Unique maps
<img width="500" alt="Screen Shot 2023-04-23 at 3 36 49 PM" src="https://user-images.githubusercontent.com/71990977/233869830-d7c12f19-ea26-47d8-87a3-6e76e9bd357e.png">
With 32 unique maps with a range of difficulties, users can chose between puzzle like, speed based, and other kinds of maps
## Live ranked leaderboard
<img width="500" alt="Screen Shot 2023-04-23 at 3 20 12 PM" src="https://user-images.githubusercontent.com/71990977/233869732-6c597cc8-75c0-4042-822f-5d55353bfaa8.png">
With a live ranked leaderboard, Inkball stores plays and displays them both immediately after a play, as well as on a dedicated leaderboard page, catagorized by map.
## Achievement badges
<img width="500" alt="Screen Shot 2023-04-23 at 3 41 10 PM" src="https://user-images.githubusercontent.com/71990977/233869971-3e86b87c-6134-49ac-94be-0d3c0f44327e.png">
Achievement badges allow users to display their game wins, both on their menu and on the leaderboard.
## Background Music and Sound effects
The original background music and sound effects, created by Advaita Guruprasad enhance the experience and make it immersive
# Contributers
- Developers: Shubham Parab and Ritam Chakraborty
- Design: Anindit Pati, Advaita Guruprasad, and Snehil Kakani
- Music/Sound: Advaita Guruprasad
# Software and tools
- Game in HTML, HTML Canvas, Javascript and CSS
- Leaderboard database using Deta space using base and micros
| A modern graphics-based game of Inkball | canvas,javascript | 2023-04-08T21:56:47Z | 2023-04-23T23:09:42Z | null | 4 | 1 | 68 | 0 | 0 | 3 | null | null | JavaScript |
isabelirk/tiktk | main | # Getting Started with Create React App
This project was bootstrapped with [Create React App](https://github.com/facebook/create-react-app).
## Available Scripts
In the project directory, you can run:
### `npm start`
Runs the app in the development mode.\
Open [http://localhost:3000](http://localhost:3000) to view it in your browser.
The page will reload when you make changes.\
You may also see any lint errors in the console.
### `npm test`
Launches the test runner in the interactive watch mode.\
See the section about [running tests](https://facebook.github.io/create-react-app/docs/running-tests) for more information.
### `npm run build`
Builds the app for production to the `build` folder.\
It correctly bundles React in production mode and optimizes the build for the best performance.
The build is minified and the filenames include the hashes.\
Your app is ready to be deployed!
See the section about [deployment](https://facebook.github.io/create-react-app/docs/deployment) for more information.
### `npm run eject`
**Note: this is a one-way operation. Once you `eject`, you can't go back!**
If you aren't satisfied with the build tool and configuration choices, you can `eject` at any time. This command will remove the single build dependency from your project.
Instead, it will copy all the configuration files and the transitive dependencies (webpack, Babel, ESLint, etc) right into your project so you have full control over them. All of the commands except `eject` will still work, but they will point to the copied scripts so you can tweak them. At this point you're on your own.
You don't have to ever use `eject`. The curated feature set is suitable for small and middle deployments, and you shouldn't feel obligated to use this feature. However we understand that this tool wouldn't be useful if you couldn't customize it when you are ready for it.
## Learn More
You can learn more in the [Create React App documentation](https://facebook.github.io/create-react-app/docs/getting-started).
To learn React, check out the [React documentation](https://reactjs.org/).
### Code Splitting
This section has moved here: [https://facebook.github.io/create-react-app/docs/code-splitting](https://facebook.github.io/create-react-app/docs/code-splitting)
### Analyzing the Bundle Size
This section has moved here: [https://facebook.github.io/create-react-app/docs/analyzing-the-bundle-size](https://facebook.github.io/create-react-app/docs/analyzing-the-bundle-size)
### Making a Progressive Web App
This section has moved here: [https://facebook.github.io/create-react-app/docs/making-a-progressive-web-app](https://facebook.github.io/create-react-app/docs/making-a-progressive-web-app)
### Advanced Configuration
This section has moved here: [https://facebook.github.io/create-react-app/docs/advanced-configuration](https://facebook.github.io/create-react-app/docs/advanced-configuration)
### Deployment
This section has moved here: [https://facebook.github.io/create-react-app/docs/deployment](https://facebook.github.io/create-react-app/docs/deployment)
### `npm run build` fails to minify
This section has moved here: [https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify](https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify)
| Este repositório é um projeto para um site de vídeos curtos baseado no aplicativo TikTok. | css,html,javascript,node-js,react | 2023-03-29T17:45:27Z | 2023-04-01T17:23:43Z | null | 1 | 0 | 5 | 0 | 0 | 3 | null | null | JavaScript |
Abdukhamid000/Air_lendingPage | main | # lending_page1
https://sparkling-bienenstitch-cb48bb.netlify.app/src/
| null | css3,html5,javascript | 2023-04-02T08:36:47Z | 2023-04-05T12:49:20Z | null | 1 | 0 | 12 | 0 | 0 | 3 | null | null | HTML |
dsvillalobos/DS-Spendify | main | # DS Spendify
_DS Spendify is an expense tracking app designed to simplify your financial management. With its intuitive interface and smart features, you can effortlessly track your expenses, set budgets, and receive insightful reports to take control of your spending habits._
## App Features
- User-friendly Interface.
- Expense Categorization.
- Stats with Data Visualization and Data Analysis.
- Strong Security.
- Fast Performance.
## Screenshots
## Release Notes 0.3.4
- Bug Fixes.
- Redesigned Profile Page.
| DS Spendify is an expense tracking app designed to simplify your financial management. With its intuitive interface and smart features, you can effortlessly track your expenses, set budgets, and receive insightful reports to take control of your spending habits. | css,html,javascript,pwa | 2023-04-03T01:42:40Z | 2023-10-09T00:08:08Z | null | 1 | 0 | 26 | 0 | 0 | 3 | null | null | JavaScript |
shaikhshahbaz4022/Catherene-Clone | main | # SHOPVIBE STORE
Welcome to ShopVibe Store! This is an e-commerce website built using HTML, CSS, and JavaScript. Experience a seamless shopping journey with a wide range of products and user-friendly features. Whether you're a customer or an admin, ShopVibe Store has got you covered!
### Website Deployed Link
https://shopvibe-online-shopping.netlify.app/
## Key Features
### User Side
- **Google Authentication System:** Seamlessly sign in to your account using your Google credentials for a secure and personalized experience.
- **Browse and Add Products:** Explore our vast collection of products and effortlessly add them to your cart with just a few clicks.
- **Manage Your Cart:** Remove unwanted items from your cart and conveniently update your selection as per your preferences.
- **Persistent Cart:** Never lose your cart items! ShopVibe Store utilizes local storage to save your cart items for future sessions.
- **Calculate Total Price:** Easily keep track of your expenses with the built-in functionality to calculate the total price of items in your cart.
### Admin Side
- **Product Management:** Admin users have the power to add new products to the inventory and update existing product details for accurate and up-to-date information.
- **Stock Availability:** Stay informed! Admins can easily view the available stock of products in the admin dashboard for efficient inventory management.
- **Role-Based Access Control (RBAC):** Implementing RBAC ensures authorized access and enhances security by assigning specific roles to users.
## Technologies Used
### Frontend Tech-Stacks
- HTML
- CSS
- JavaScript (Vanilla)
### Backend Tech-Stacks
- MongoDB
- Node.js
- Express
## Screenshots
### Product-page
### Add to cart
### Cart-Page
## Usage
To get started, open the project in your browser. Browse through the products by clicking on the different categories in the navigation menu. Add products to your cart by clicking the "Add to Cart" button on the product page. You can view and manage your cart by clicking on the cart icon in the navigation menu.
## Contributing
We welcome contributions to improve the project. If you encounter any bugs or issues, please open an issue on the GitHub repository.
## Project By
Shahbaz Shaikh
Join us at ShopVibe Store and enjoy a delightful shopping experience with an extensive range of products and user-friendly features. Happy shopping!
| This is an e-commerce website built using HTML, CSS, and JavaScript. The website allows users to browse through a variety of products and add them to their cart for purchase. Local storage is used to save the cart items for future sessions. | css,ecommerce,html,javascript,shopping-cart,admin-panel,expressjs,mongodb,nodejs,rbac-authorization | 2023-03-28T10:43:57Z | 2023-07-07T07:01:55Z | null | 2 | 9 | 26 | 0 | 0 | 3 | null | null | HTML |
mk-manishkumar/learning-MERN | main | # About
Within this repository, you will find a comprehensive collection of my Web Development journey. It encompasses a wide spectrum of topics, starting from the fundamental building blocks like `HTML`, `CSS`, and `JavaScript`, to more advanced technologies like `React`, `NodeJS`, `ExpressJS` and `MongoDB`. In essence, it serves as a holistic guide to mastering the `MERN` (MongoDB, Express, React, Node.js) Stack, equipping with a solid foundation and extensive knowledge in the realm of **modern** web development.
| This repository contains all my learnings related to Web Development. It encompasses a wide spectrum of topics, starting from the fundamental building blocks like HTML, CSS, and JavaScript, to more advanced technologies like React, NodeJS, ExpressJS and MongoDB. | css,flexbox,grid,html,javascript,reactjs,xml,expressjs,nodejs | 2023-04-08T17:48:32Z | 2024-04-13T17:55:11Z | null | 1 | 38 | 102 | 0 | 0 | 3 | null | null | JavaScript |
PallvaKuarweb23/ShopEasy | main | # radioactive-lip-3578-
# [Stylista](https://playful-caramel-2a397b.netlify.app/html/index.html)
It's E-commerce website Where you can buy stuff
especially for clothing stuff,It's clone of [koov's](https://www.koovs.com/) and also it's completely responsive website.
## Team Member
[Pallava Kuar(Team Leader)](https://github.com/PallavaKuarweb23)
[Krishna Vaishnav](https://github.com/KrishnaVaishnav98)
[Yogita Mane](https://github.com/Yogita2021)
[Hemant Yadav](https://github.com/Hemant142)
[Tushar Rajora](https://github.com/Tushar092)
## 🛠 Tools
1. Javascript
2. DOM
3. HTML
4. CSS
## Features
1. login
2. Signin
3. Add to Cart
4. Filter & Sort
5. Admin Side
6. Payment Page
## 👩🚒Role in the website
1. Hemant Yadav(Home Page)
2. Tushar Rajora(Product Page)
3. Pallava Kuar(Cart Page)
4. Krishna Vaishnav(Payment Page)
5. Yogita Mane (Admin Side)
## FAQ
#### is it responsing or not ??
Yes, It's totally responsive
#### Can We login or logout ??
Yes, You Can login or logout
#### Can we add to Cart without login
No, You Can't, first Have to login
#### Can I Use Debit Card For Payment
Of Course, You Can also use UPI,Debit Card and Credit Card
| An e-commerce website for kids,men,women and other ethnic fashion and lifestyle products and variety of products on the online platform | css,hmtl,javascript,mongodb | 2023-03-28T10:22:38Z | 2023-04-03T05:52:26Z | null | 6 | 35 | 74 | 10 | 2 | 3 | null | null | HTML |
rabbiyasana/MakeUpMania | main | null | Static E-commerece site with HTML,CSS andfd Bootstrap | bootstrap5,css3,html5,javascript,bootstrap5-grid | 2023-03-27T06:16:59Z | 2023-05-30T15:14:50Z | null | 5 | 25 | 94 | 0 | 0 | 3 | null | null | HTML |
sugeng-sulistiyawan/yii2-barcode-generator | main | # Yii2 Barcode Generator
The JavaScript Barcode Generator for Yii2
[](https://packagist.org/packages/diecoding/yii2-barcode-generator)
[](https://packagist.org/packages/diecoding/yii2-barcode-generator)
[](https://github.com/sugeng-sulistiyawan/yii2-barcode-generator)
[](https://scrutinizer-ci.com/g/sugeng-sulistiyawan/yii2-barcode-generator)
[](https://app.travis-ci.com/sugeng-sulistiyawan/yii2-barcode-generator)
[](https://github.com/sugeng-sulistiyawan/yii2-barcode-generator)
[](https://packagist.org/packages/diecoding/yii2-barcode-generator)
> Yii2 Barcode Generator uses [JsBarcode](https://lindell.me/JsBarcode/) <br> Demo: https://lindell.me/JsBarcode/
## Table of Contents
- [Yii2 Barcode Generator](#yii2-barcode-generator)
- [Table of Contents](#table-of-contents)
- [Instalation](#instalation)
- [Dependencies](#dependencies)
- [Usage](#usage)
- [Simple Usage](#simple-usage)
- [Advanced Usage](#advanced-usage)
## Instalation
Package is available on [Packagist](https://packagist.org/packages/diecoding/yii2-barcode-generator), you can install it using [Composer](https://getcomposer.org).
```shell
composer require diecoding/yii2-barcode-generator "^1.0"
```
or add to the require section of your `composer.json` file.
```shell
"diecoding/yii2-barcode-generator": "^1.0"
```
## Dependencies
- PHP 7.4+
- [yiisoft/yii2](https://github.com/yiisoft/yii2)
- [npm-asset/jsbarcode](https://asset-packagist.org/package/npm-asset/jsbarcode)
## Usage
> Wiki as JavaScript Code at https://github.com/lindell/JsBarcode/wiki#barcodes
### Simple Usage
```php
use diecoding\barcode\generator\Barcode;
// CODE128 (auto) is the default mode
Barcode::widget([
'value' => 'Hi world!',
]);
// CODE128
Barcode::widget([
'value' => 'Example1234',
'format' => Barcode::CODE128
]);
// CODE128A
Barcode::widget([
'value' => 'EXAMPLE\n1234',
'format' => Barcode::CODE128A
]);
// ...
```
### Advanced Usage
```php
use diecoding\barcode\generator\Barcode;
Barcode::widget([
'value' => '1234',
'format' => Barcode::PHARMACODE,
'pluginOptions' => [
'lineColor' => '#0aa',
'width' => 4,
'height' => 40,
'displayValue' => false
]
]);
// Enable encoding CODE128 as GS1-128/EAN-128.
Barcode::widget([
'value' => '12345678',
'format' => Barcode::CODE128C,
'pluginOptions' => [
'ean128' => true,
]
]);
// Change Element Tag, default svg, available svg, img, canvas
Barcode::widget([
'tag' => 'img',
'value' => '12345678',
'format' => Barcode::CODE128C,
'pluginOptions' => [
'ean128' => true,
]
]);
// Change Element Tag, add custom style element tag, hide value text
Barcode::widget([
'tag' => 'img',
'value' => '12345678',
'options' => [
'style' => "width: 4cm; height: 1cm;",
],
'pluginOptions' => [
'displayValue' => false,
],
]);
// ...
```
---
Read more docs: https://sugengsulistiyawan.my.id/docs/opensource/yii2/barcode-generator/
| The JavaScript Barcode Generator for Yii2 | barcode,barcode-generator,yii2,yii2-extension,javascript,javascript-library | 2023-04-03T15:11:44Z | 2023-05-06T04:36:14Z | 2023-04-28T03:24:43Z | 1 | 0 | 15 | 0 | 0 | 3 | null | MIT | PHP |
victor-joness/Solf1-Solucoes-Financeiras-2.0 | main | # Solf1-Solucoes-Financeiras
## 💻 Projeto
Projeto De um Sistema de Controle Financeiro Pessoal, Realizado para a Disciplina de Projeto Integrador 1 do curso de Ciências da computação na UFC.
## 🚀 Tecnologias
Esse projeto foi desenvolvido com as seguintes tecnologias:
> Front-End: React, CSS, HTML, JavaScript e algumas Bibliotecas;
> Back-End: MySql, Node.js e algumas Bibliotecas;
## 📌 Habilidades
Nesse projeto, fui capaz de:
- Trabalhar com estado, componentes;
- Fazer o uso e o estudo das seguintes bibliotecas Axios, Express, Yup, Formik, Cors, Charts.js, bcrypt, nodemon, React-Router-dom;
- Uso do banco de dados MySql WorkBench
- Feito alguns CRUDS
## :memo: Funcionalidades:
- 1 Criação de conta;✔️
- 2 Login;✔️
- 3 Logout;✔️
- 4 Edição de conta; ✔️
- 5 Remoção de conta;✔️
- 6 CRUD de receita; ✔️
- 7 CRUD de cartão de crédito; ✔️
- 8 CRUD de cartão de débito; ✔️
- 9 CRUD de categoria. Uma categoria tem apenas o nome; ✔️
- 10 CRUD de despesa; ✔️
• Na adição de despesa verificações são obrigatórias. Se a despesa for em cartão de
crédito, é necessário verificar se a despesa não ultrapassará o valor limite do cartão e se
não ultrapassou o dia de fechamento da fatura, para inclusão da despesa na fatura do
mês atual ou do mês seguinte. Caso a despesa seja em cartão de débito, deve-se verificar
se ainda existe saldo no cartão (receita do mês);
• Nas despesas pagas em cartão de crédito, o valor da prestação será incluído automaticamente nas faturas seguintes de acordo com o número de prestações em que a despesa é
dividida;✔️
- 11 Nas listagens de cada CRUD deverão existir opções para reordenação ou filtragem dos itens.
Por exemplo, as despesas listadas podem ser reordenadas pelo valor, data, categoria, etc. Além
Projeto 2
disso, as despesas são listráveis pelo mês, categoria, etc;✔️
- BackEnd
-> banco de dados (MySql) ✔️
-> Criptografia da senha no banco de dados ✔️;
## 📝 Fotos do projeto
-> https://www.figma.com/file/yi3Ul79yZayWMzAVaoalOF/Solf1?type=design&mode=design&t=ycaipchLjrlEx3de-0
## 📝 Ajustes e melhorias
O projeto ainda está em desenvolvimento e as próximas atualizações serão voltadas nas seguintes tarefas:
- [ ] Realizar testes unitários;
- [ ] Otimização;
- [ ] Melhorias no Css;
- [ ] Adição de Funcionalidades voltada pra deficientes;
- [ ] Modo preto/Branco;
- [ ] Mudar as variaveis globais para useContext;
# 👷 Como rodar
```bash
# Clonar o repositório
git clone https://github.com/victor-joness/Solf1-Solucoes-Financeiras-2.0
# Entrar numa IDE de sua preferência
# Executar o servidor ou usar um puglin que criar um servidor
```
## ⬇️ Instalando dependências
```bash
Client
$ cd Client
$ npm install or $ yarn install
$ npm start or $ yarn start
Server
$ cd Server
$ npm install or $ yarn install
$ npm start or $ yarn start
Change your mySQL database data server/index.js
```
## 🤔 Como contribuir <br/>
- Faça um fork desse repositório.
- Cria uma branch com a sua feature: `git checkout -b minha-feature`
- Faça commit das suas alterações: `git commit -m 'feat: Minha nova feature'`
- Faça push para a sua branch: `git push origin minha-feature`
- Depois que o merge da sua *pull request* for feito, você pode deletar a sua *branch*
## :mortar_board: Autores
<table align="center">
<tr>
<td align="center">
<a href="https://github.com/victor-joness">
<img src="https://i.imgur.com/vBnNiVV.png" width="150px;" alt="Foto Victor"/>
<br />
<sub><b>Victor Mesquita<sub><b>
</a>
</td>
<td align="center">
<a href="https://github.com/SamuelLopess03">
<img src="https://user-images.githubusercontent.com/85620625/195366186-541c980e-1aba-4d03-9da7-5e49e64b9d22.png" width="150px;" alt="Foto Samuel"/>
<br />
<sub><b>Samuel Lopes<sub><b>
</a>
</td>
</tr>
</table>
## 📄 Licença
Esse projeto está sob licença. Veja o arquivo [LICENÇA](LICENSE) para mais detalhes.
| Projeto De um Sistema de Controle Financeiro Pessoal, Realizado para a Disciplina de Projeto Integrador 1 do curso de Ciências da computação na UFC. | api,controle-financeiro,css,javascript,mysql,nodejs,reactjs | 2023-04-02T12:40:42Z | 2023-11-04T11:29:10Z | null | 2 | 1 | 201 | 0 | 3 | 3 | null | MIT | JavaScript |
EuJinnLucaShow/webpack-template | master | # 📦 webpack Boilerplate
[](https://opensource.org/licenses/MIT)
Sensible webpack 5 boilerplate using Babel, PostCSS and Sass.
## Installation
Clone this repo and npm install.
```bash
npm i
```
## Usage
### Development server
```bash
npm start
```
You can view the development server at `localhost:8080`.
### Production build
```bash
npm run build
```
> Note: Install [http-server](https://www.npmjs.com/package/http-server) globally to deploy a simple server.
```bash
npm i -g http-server
```
You can view the deploy by creating a server in `dist`.
```bash
cd dist && http-server
```
## Features
- [webpack](https://webpack.js.org/)
- [Babel](https://babeljs.io/)
- [Sass](https://sass-lang.com/)
- [PostCSS](https://postcss.org/)
## Dependencies
### webpack
- [`webpack`](https://github.com/webpack/webpack) - Module and asset bundler.
- [`webpack-cli`](https://github.com/webpack/webpack-cli) - Command line interface for webpack
- [`webpack-dev-server`](https://github.com/webpack/webpack-dev-server) - Development server for webpack
- [`webpack-merge`](https://github.com/survivejs/webpack-merge) - Simplify development/production configuration
- [`cross-env`](https://github.com/kentcdodds/cross-env) - Cross platform configuration
### Babel
- [`@babel/core`](https://www.npmjs.com/package/@babel/core) - Transpile ES6+ to backwards compatible JavaScript
- [`@babel/plugin-proposal-class-properties`](https://babeljs.io/docs/en/babel-plugin-proposal-class-properties) - Use properties directly on a class (an example Babel config)
- [`@babel/preset-env`](https://babeljs.io/docs/en/babel-preset-env) - Smart defaults for Babel
### Loaders
- [`babel-loader`](https://webpack.js.org/loaders/babel-loader/) - Transpile files with Babel and webpack
- [`sass-loader`](https://webpack.js.org/loaders/sass-loader/) - Load SCSS and compile to CSS
- [`sass`](https://www.npmjs.com/package/sass) - Node Sass
- [`postcss-loader`](https://webpack.js.org/loaders/postcss-loader/) - Process CSS with PostCSS
- [`postcss-preset-env`](https://www.npmjs.com/package/postcss-preset-env) - Sensible defaults for PostCSS
- [`css-loader`](https://webpack.js.org/loaders/css-loader/) - Resolve CSS imports
- [`style-loader`](https://webpack.js.org/loaders/style-loader/) - Inject CSS into the DOM
### Plugins
- [`clean-webpack-plugin`](https://github.com/johnagan/clean-webpack-plugin) - Remove/clean build folders
- [`copy-webpack-plugin`](https://github.com/webpack-contrib/copy-webpack-plugin) - Copy files to build directory
- [`html-webpack-plugin`](https://github.com/jantimon/html-webpack-plugin) - Generate HTML files from template
- [`mini-css-extract-plugin`](https://github.com/webpack-contrib/mini-css-extract-plugin) - Extract CSS into separate files
- [`css-minimizer-webpack-plugin`](https://webpack.js.org/plugins/css-minimizer-webpack-plugin/) - Optimize and minimize CSS assets
### Linters
- [`eslint`](https://github.com/eslint/eslint) - Enforce styleguide across application
- [`eslint-config-prettier`](https://github.com/prettier/eslint-config-prettier) - Implement prettier rules
- - [`prettier`](https://github.com/prettier/prettier) - Dependency for `prettier-webpack-plugin` plugin
- [`eslint-import-resolver-webpack`](https://github.com/benmosher/eslint-plugin-import/tree/master/resolvers/webpack) - Throw exceptions for import/export in webpack
## Author
- [Tania Rascia](https://www.taniarascia.com)
## License
This project is open source and available under the [MIT License](LICENSE).
| webpack | css,javascript,sass,webpack,babel | 2023-03-29T06:58:53Z | 2023-03-29T08:04:32Z | null | 18 | 0 | 68 | 0 | 0 | 3 | null | MIT | JavaScript |
gbxyz/rdap-web-client | master | # RDAP Web Client
This repository contains a simple web-based RDAP client that talks directly to RDAP servers, without using a proxy.
To see it in action, go to [client.rdap.org](https://client.rdap.org).
| A web-based RDAP client that talks directly to RDAP servers, without using a proxy. | javascript,rdap,rdap-client | 2023-03-28T13:56:39Z | 2024-05-17T20:31:11Z | null | 2 | 0 | 53 | 0 | 1 | 3 | null | NOASSERTION | HTML |
mayki21/MyGlamm_clone | main | # MYCLAMM (clone of MYGLAMM)
MyClamm is a vibrant and comprehensive online destination for all things related to ladies' fashion, lipstick, skincare, makeup, and various beauty products. This innovative website is proudly owned by Shraddha Kapoor, a renowned figure in the world of fashion and beauty.
At MyClamm, women can explore an extensive collection of premium-quality beauty products carefully curated to cater to their diverse needs and preferences. From trendy fashion pieces to a wide range of lipstick shades, skincare essentials, and makeup must-haves, this website offers an exciting assortment of products to help women enhance their natural beauty and express their unique style
# TECH STACKS
## BACKEND
* Express
* MongoDB
* Node JS
* Javascript
## FRONTEND
* HTML
* JAVASCRIPT
* CSS
# PAGES
* Home Page
* SignUp and Login
* Products Page
* Cart Page
* Payment and Checkout Page
# FUNCTIONALITIES
* Searching functionality
* Sorting by Price(low to high) & (high to low)
# Deployed Server Link
https://orchid-tuna-yoke.cyclic.app/
# Netlify Link
https://incomparable-sfogliatella-0fee79.netlify.app/
# SCREENSHOTS
## LANDING PAGE
## FOOTER SECTION
## MAKEUP PRODUCT PAGE
## LIPSTICK PRODUCT PAGE
## SKIN CARE PRODUCT PAGE
## CART PAGE
## CHECKOUT PAGE
## PAYMENT PAGE
| MyClamm is your ultimate destination for all your beauty product needs. With MyClamm, you can conveniently order beauty products online with ease. Our user-friendly platform allows you to effortlessly browse and filter products to find exactly what you're looking for. Say goodbye to the hassle of searching through endless option. | css,html,javascript,express,mongodb,mongoose,nodejs | 2023-03-28T05:11:48Z | 2023-07-25T12:35:54Z | null | 2 | 5 | 25 | 0 | 0 | 3 | null | null | JavaScript |
sriramalavalapati3/weatherapisever | main | # weatherapisever | This is basic web server by entering city name we can get weather details of perticular city | cyclic,mongodb,redis,javascript,nodejs | 2023-03-27T11:46:12Z | 2023-03-27T13:42:11Z | null | 1 | 0 | 4 | 0 | 0 | 3 | null | null | JavaScript |
narender24681/Flipkart-Clone | main | ## Flipkart Clone
Flipkart is one of the largest online retailers in India, offering a vast range of products including electronics, fashion, home appliances, and groceries. Flipkart also owns several subsidiaries including Myntra, PhonePe, and Jeeves, making it a major player in the Indian e-commerce mark
<hr/>
## Technologies Used
- HTML
- CSS
- JavaScript
- ReactJS
- React Router DOM
- Styled Components
- Chakra-UI
- Redux
- JSON Server
<hr/>
## Features
- Login and signup functionality
- Navbar for easy navigation between pages
- Product pages where all the products will be displayed
- Card page
- Checkout page
- Payment page
- JSON Server to manage the data
- Admin page to add, update, edit & update products
<hr/>
## Some Screenshots Of The Project
#### Home Page
#### Login Page
#### Products Page
#### Cart Page
#### Payment Page
#### Footer Page
#### Adimn Page
#### Admin Data
#### Admin Products
#### Admin Edit Page
<hr/>
## Packages
- Axios
- React-redux
- Redux-thunk
- styled-components
- Redux
- Chakra UI
- React-Router-Dom
- Json-Server
| Flipkart is one of the largest online retailers in India, offering a vast range of products including electronics, fashion, home appliances, and groceries. Flipkart also owns several subsidiaries including Myntra, PhonePe, and Jeeves, making it a major player in the Indian e-commerce mark | html,css,javascript,reactjs | 2023-03-28T02:11:09Z | 2023-06-07T04:39:56Z | null | 7 | 22 | 127 | 1 | 1 | 3 | null | null | JavaScript |
nikhil-pillare/GULMOHAR-flower_shop | main | # groovy-airplane-6414
# [Gulmohar-Flower-Shop](https://gulmohar-the-flower-shop.netlify.app/)
- Clone of [1-800 Flowers](https://www.1800flowers.com/)
### Contribution
A team of four people created this project over the course of five days.
#### Team Members
1. [Nikhil pilare]() (fw24_151)
2. [Aditya Choudhary](https://github.com/Aditya-Choudhary0) (fw24_753)
3. [Sourabh Mandal](https://github.com/Sourabh-2101) (fw25_095)
4. [Karan Jarwal](https://github.com/karanjarwal999) (fw24_257)
### Netlify Link
https://gulmohar-the-flower-shop.netlify.app/
### Description
The Gulmohar is a E-commerce website of flowers and gift delivery. It includes various categories and brands according to the needs of customers.
Our website offers floral arrangements, plants and unique gifts to celebrate birthdays, anniversaries, everyday occasions, and seasonal holidays, and to deliver comfort during times of grief. Backed by a caring team obsessed with service,also provides customers thoughtful ways to express themselves and connect with the most important people in their lives.
The project is built using `HTML, CSS, and JavaScript`, and is intended to be a `responsive` and visually appealing website.
### JSON SERVER
https://bored-school-uniform-bull.cyclic.app/flowers
### Tech-Stack Used
```
- HTML
- CSS
- JavaScript
```
### Usage
Gulmohar is designed to be user-friendly and easy to navigate. The website includes the following pages:
[**`Home`**](/index.html) 👨💼(Nikhil Pilare) : A landing page with information about the store and featured products and categories.
[**`Product`**](/product.html) 👨💼(Sourabh Mandal) : A page with a selection of products available for purchase.
For the data of the product we created the [JSON API](https://bored-school-uniform-bull.cyclic.app/flowers) to store the data.
then we feched the data from API and apply different filters and functionality.
We can filter our products based on our preference of the prize and rating of the product.
We can add product to our cart page by clicking on the product.
[**`Cart`**](/cart.html) 👨💼(Sourabh Mandal) : A page to customize the quantity and select the products we want to buy.
We have payment page during the checkout.
We also have `OTP generator` for a secure payment.
[**`Sign-up`**](/SignUp.html) 👨💼(Aditya Choudhary) : A page where the customer can create a new account for fast, seamless product purchases.
[**`Sign-In`**](SignIn.html) 👨💼(Aditya Choudhary) : A page where existing users can sign in so that their experience is uninterrupted.
[**`Admin`**](/admin.html) 👨💼( Karan Jawar ): A page with all the control of the products displayed on the website and the User of the site.
In admin page we have functionality like:-
1. Add Product : We can add new products just by filling the details.
2. Edit Product : Same like Add we can update the values of the product that are present.
3. Delete Product : We can Delete the product present by clicking the button and conforming.
4. User : A page giving the details about the user thst hsve signed up.
Each and every page of the website is ***`responsive`*** in nature for 3 screens i.e. `Desktop/Laptop, Tablet, and Mobile`.
This is the overall view of the website.
Contributions to groovy-airplane-6414 are welcome! If you would like to contribute, please follow these guidelines:
### Fork the repository
+ Create a new branch for your changes
+ Make your changes and commit them with clear commit messages
+ Push your changes to your fork
+ Create a pull request with a clear description of your changes
+ Credits
| The Gulmohar is a E-commerce website of flowers and gift delivery. It includes various categories and brands according to the needs of customers. | css,html,javascript | 2023-03-27T15:19:49Z | 2023-06-21T00:02:20Z | null | 5 | 29 | 72 | 0 | 3 | 3 | null | null | HTML |
kodie/growfield | main | null | A tiny, dependency-free JavaScript module for making textarea elements grow with their content. | expand,form,input,javascript,no-jquery,size,vanilla | 2023-03-30T21:12:38Z | 2023-03-30T21:15:08Z | null | 1 | 0 | 2 | 0 | 0 | 3 | null | MIT | JavaScript |
Raushan1234567/Raushan1234567.github.io | main | # Raushan1234567.github.io
https://raushan1234567.github.io/
| Welcome to my portfolio! I am Raushan Kumar, a passionate Java backend developer with a solid foundation in software engineering and a Bachelor's degree in Technology (B.Tech). | css,html,javascript | 2023-04-06T18:05:27Z | 2024-02-14T07:34:18Z | null | 1 | 0 | 26 | 0 | 0 | 3 | null | null | CSS |
raxitamathukiya/SnapZone-E-Commerce-Website | main | # SnapZone
Our Team Members
1. Raxita Mathukiya
2. Himanshu Kalal
3. Pankaj Kumar
4. Praveen Kumar
5. Sandip Bankar
- Netlify Deploy Link : `https://busy-cough-2191-fp10-063.netlify.app/
-External CSS :
For Font and Emojies
"https://use.fontawesome.com/releases/v5.5.0/css/all.css"
https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css"
-Tech Stack
-- Front End(HTML, CSS)
-- JavaScript
Home Page
Login Page
SignUp Page
Men's Product Page
Cart Page
Payment Page
Invoice Page
| The product-based website is an online marketplace featuring a wide range of consumer products. It offers a user-friendly interface with easy navigation and clear product descriptions. Responsive customer support is available to assist users with any inquiries or issues they may have. | css,html,javascript,json-server | 2023-03-27T04:50:13Z | 2023-09-13T15:02:34Z | null | 6 | 28 | 70 | 5 | 2 | 3 | null | null | HTML |
christianonoh/Bookstore | main | <a name="readme-top"></a>
<!--
HOW TO USE:
This is an example of how you may give instructions on setting up your project locally.
Modify this file to match your project and remove sections that don't apply.
REQUIRED SECTIONS:
- Table of Contents
- About the Project
- Built With
- Live Demo
- Getting Started
- Authors
- Future Features
- Contributing
- Show your support
- Acknowledgements
- License
OPTIONAL SECTIONS:
- FAQ
After you're finished please remove all the comments and instructions!
-->
<div align="center">
<!-- You are encouraged to replace this logo with your own! Otherwise you can also remove it.
<img src="murple_logo.png" alt="logo" width="140" height="auto" />
<br/> -->
[Book list app] <a name="about-project"></a>
</div>
<!-- TABLE OF CONTENTS -->
# 📗 Table of Contents
- [📖 About the Project](#about-project)
- [🛠 Built With](#built-with)
- [Tech Stack](#tech-stack)
- [Key Features](#key-features)
- [🚀 Live Demo](#live-demo)
- [💻 Getting Started](#getting-started)
- [Setup](#setup)
- [Prerequisites](#prerequisites)
- [Install](#install)
- [Usage](#usage)
- [Run tests](#run-tests)
- [Deployment](#triangular_flag_on_post-deployment)
- [👥 Authors](#authors)
- [🔭 Future Features](#future-features)
- [🤝 Contributing](#contributing)
- [⭐️ Show your support](#support)
- [🙏 Acknowledgements](#acknowledgements)
- [❓ FAQ (OPTIONAL)](#faq)
- [📝 License](#license)
<!-- PROJECT DESCRIPTION -->
# 📖 [Book list app] <a name="about-project"></a>
<!-- > Describe your project in 1 or 2 sentences. -->
**[Book list app]** is a web app so that you can store your favorite books on a digital shelf.
## 🛠 Built With <a name="built-with"></a>
### Tech Stack <a name="tech-stack"></a>
<!-- > Describe the tech stack and include only the relevant sections that apply to your project. -->
<details>
<summary>Client</summary>
<ul>
<li>html</li>
<li>css</li>
<li>javascript</li>
</ul>
</details>
<!-- Features -->
### Key Features <a name="key-features"></a>
<!-- > Describe between 1-3 key features of the application. -->
- **This app stores data from your favorite books and show them as a list**
- **[future_feature]**
- **[future_feature]**
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- LIVE DEMO -->
## 🚀 Live Demo <a name="live-demo"></a>
<!-- > Add a link to your deployed project. -->
- Not available yet
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- GETTING STARTED -->
## 💻 Getting Started <a name="getting-started"></a>
<!-- > Describe how a new developer could make use of your project. -->
To get a local copy up and running, follow these steps:
### Prerequisites
Internet connection to clone this repo
<!--In order to run this project you need:-->
<!--
Example command:
```sh
gem install rails
```
-->
### Setup
Clone this repository to your desired folder:
cd my-folder
git clone [git@github.com:christianonoh/Bookstore.git](git@github.com:christianonoh/Bookstore.git)
<!--
Example commands:
```sh
cd my-folder
git clone git@github.com:myaccount/my-project.git
```
--->
### Install
<!--Install this project with:-->
No installation needed.
<!--
Example command:
```sh
cd my-project
gem install
```
--->
### Usage
To run the project download and run locally.
<!--
Example command:
```sh
rails server
```
--->
### Run tests
<!--To run tests, run the following command:-->
No tests available.
<!--
Example command:
```sh
bin/rails test test/models/article_test.rb
```
--->
### Deployment
<!--You can deploy this project using:-->
Not available yet.
<!--
Example:
```sh
```
-->
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- AUTHORS -->
## 👥 Author <a name="authors"></a>
<!-- > Mention all of the collaborators of this project. -->
👤 **Christian Onoh**
- GitHub: [@christianonoh](https://github.com/christianonoh)
- Twitter: [@onohchristian](https://twitter.com/onohchristian)
- LinkedIn: [Christian Onoh](https://www.linkedin.com/in/christianonoh)
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- FUTURE FEATURES -->
## 🔭 Future Features <a name="future-features"></a>
<!-- > Describe 1 - 3 features you will add to the project. -->
- [ ] **[no future features planned]**
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- CONTRIBUTING -->
## 🤝 Contributing <a name="contributing"></a>
Contributions, issues, and feature requests are welcome!
Feel free to check the [issues page](https://github.com/christianonoh/Bookstore/issues).
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- SUPPORT -->
## ⭐️ Show your support <a name="support"></a>
<!-- > Write a message to encourage readers to support your project-->
Thanks for your time! I'm always happy to know how to improve this project!
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- ACKNOWLEDGEMENTS -->
## 🙏 Acknowledgments <a name="acknowledgements"></a>
<!-- > Give credit to everyone who inspired your codebase.-->
Thanks for pushing so hard Microverse, I'm amazed of what can I do now!
<p align="right">(<a href="#readme-top">back to top</a>)</p>
<!-- FAQ (optional)
## ❓ FAQ (OPTIONAL) <a name="faq"></a>
> Add at least 2 questions new developers would ask when they decide to use your project.
- **[Question_1]**
- [Answer_1]
- **[Question_2]**
- [Answer_2]
<p align="right">(<a href="#readme-top">back to top</a>)</p> -->
<!-- LICENSE -->
## 📝 License <a name="license"></a>
This project is [MIT](/LICENSE) licensed.
<!-- _NOTE: we recommend using the [MIT license](https://choosealicense.com/licenses/mit/) - you can set it up quickly by [using templates available on GitHub](https://docs.github.com/en/communities/setting-up-your-project-for-healthy-contributions/adding-a-license-to-a-repository). You can also use [any other license](https://choosealicense.com/licenses/) if you wish._ -->
<p align="right">(<a href="#readme-top">back to top</a>)</p>
| Bookstore web application for all book enthusiasts! Keep track of your favorite books. This app makes it easy to manage your virtual library from anywhere, anytime. | accessibility,css,dom-manipulation,html,javascript | 2023-03-27T14:44:37Z | 2023-03-28T12:37:09Z | null | 1 | 1 | 18 | 0 | 0 | 3 | null | MIT | JavaScript |
Aberratio/choose-station | master | # Fuel Refueling Optimization Application
This application is designed to optimize fueling for drivers based on their preferences and fuel type requirements.
## Introduction
The fuel market in Poland is subject to continuous changes. In recent years, one of the main factors affecting fuel prices in Poland has been changes in the tax system, especially the increase in excise duty on fuels that took place in 2019, as well as the ongoing armed conflict on our eastern border since February 2022. In addition, the situation in the international market and the unstable geopolitical situation, especially in the Middle East, affects fuel prices in the domestic market, resulting in a lack of stabilization. Another price-forming factor that has occurred recently is high inflation in Poland, which is only slightly balanced by market concerns about the occurrence of a recession.
Many companies engaged in fuel sales operate in Poland, which introduces significant price differentiation. Additionally, many gas stations offer various promotions and discounts, which also affects their price. Therefore, choosing the gas station at which refueling for a given car owner will be financially most advantageous can be difficult and time-consuming.
## Motivation
Fuel purchase for a car consumes a significant portion of the budgets of many Polish families, which is particularly severe in the current increase in the prices of most products. One of the more frequently used ways to optimize fuel expenses is to choose a gas station where the cost of refueling will be the lowest. This is not an easy task because, in addition to the price per liter of fuel, the cost of travel and network preferences also needs to be taken into account. Considering the frequency of refueling (on average, once a week), this task is also time-consuming. Usually, drivers have their favorite gas stations and do not check fuel prices at others, or they go to the nearest gas station or choose the first one they encounter, where the fuel price is lower than a certain amount.
## Key Aspects
- Lack of a single source providing information on prices at all gas stations. They can be collected from many different, highly dispersed websites and applications (e.g., Yanosik, Google Maps, https://cenapaliw.pl/).
- Lack of tools for calculating the costs of driving to and from gas stations.
- Prices change dynamically, so a one-time calculation of these costs is not a permanent solution.
- Each refueling person has different needs and pays attention to different aspects when choosing a gas station.
- Each car has different fuel consumption in the city and requires different fuel.
## Goal
Minimizing the total fueling cost.
Total fueling cost = refueling price + travel cost
- **Refueling price** - we want to minimize it in the context of the required type of fuel, its price, and the distance from the gas station.
- **Travel cost** - to and from the gas station, assuming that the ride will take place on the same type of fuel that the driver intends to refuel at the same price as the planned refueling.
## Criteria
- **Preferred stations** - some drivers have fuel cards for specific networks or prefer coffee from certain stations. The application will prioritize these stations if they are available.
- **Excluded stations** (when there are no preferred stations) - some drivers may boycott certain stations for reasons such as political views, quality of fuel, or past unpleasant experiences.
- **Fuel type** - the selected station must offer the fuel required by the driver. Some stations do not sell Pb98 gasoline or premium fuel.
- **Distance** - the station must be within the 20 closest to the starting point, with distance being defined as the sum of the distance to the station and the distance back to the starting point.
- **Total fueling cost** - the cost of fueling must be the lowest of all calculated costs while maintaining the other criteria.
## Problem of selecting a fuel station
The set of stations *S ∈ { 1, 2, ..., 20 }* is the closest to the starting point of the fuel station. Each station *S* has the following information:
- Current fuel prices (in Polish Zloty (PLN) per liter of fuel);
- The total distance to and from the starting point (in kilometers).
Each driver *K* enters:
- Required fuel type (*mandatory*);
- Required amount of fuel (*mandatory*);
- Fuel consumption in the city for their car (*mandatory*);
- Preferred stations (*optional*);
- Excluded stations (*optional*, only if no preferred stations are selected).
The problem is to select a station from the set S for driver K that has the lowest total fuel cost after taking into account the criteria entered by driver *K*.
### Aggregated data on fuel prices at gas stations
The data on fuel prices is collected from many different, widely dispersed websites and applications (e.g., Yanosik, Google Maps, https://cenapaliw.pl/).
### Heuristics
**Heuristic I** - We exclude stations from the set S that do not offer the fuel type entered by driver K.
**Heuristic II** - If driver K has entered preferred stations, we exclude all other stations from the set S.
**Heuristic III** - If driver K has not entered preferred stations and has entered excluded stations, we exclude from the set S all stations that have been excluded.
### Optimization algorithm
**Step 1:** We apply all three heuristics to the set S.
**Step 2:** For the remaining stations in set S, we calculate the total cost of traveling to and from the station to the starting point, taking into account the fuel price at the station, the fuel type selected by driver K, and the average city fuel consumption for the car to be fueled by driver K.
**Step 3:** We rank the stations based on the total fuel cost (from lowest to highest). If two stations have the same total fuel cost, the station with the shorter total distance will be ranked higher.
| This application is designed to optimize fueling for drivers based on their preferences and fuel type requirements. | javascript,react | 2023-03-29T18:19:18Z | 2023-04-01T10:30:09Z | 2023-04-01T07:49:51Z | 2 | 1 | 18 | 0 | 0 | 3 | null | null | JavaScript |
Id-Yuu/SPA-Front | main | 
## SPA-Front
#### Single Page Application Front-End Reactjs
> This repo contains the results of slicing UI from the Figma Project for leveling up my, our, or your coding skills with hands-on design challenges.
***
#### Check ```Branch``` for the new update
1. [Starter-SPA](https://github.com/Id-Yuu/SPA-Front/tree/01-Starter-SPA)
2. [Faceless Login Page](https://github.com/Id-Yuu/SPA-Front/tree/02-faceless-login-page)
3. [Pricy](https://github.com/Id-Yuu/SPA-Front/tree/03-Pricy)
#### Tech Stack
- React and React-Router
- Sass
- TailwindCSS
- Vitejs
#### Contribute to this repository.
- [Contribute](https://github.com/Id-Yuu/SPA-Front/blob/main/CONTRIBUTING.md)
| This repo contains the results of slicing UI from Figma Project | learn-to-code,personal-project,reactjs,responsive,figma-to-code,javascript,landing-page,sass,design-to-code,tailwindcss | 2023-03-27T04:46:50Z | 2023-06-08T18:13:27Z | null | 1 | 2 | 23 | 0 | 1 | 3 | null | null | null |
bitkarrot/satsconverter | main | # Satsconverter
A Basic Bitcoin to Fiat converter with price feeds from Coindesk.
# FastAPI + Vercel
This app runs on FastAPI on Vercel
## To install
```sh
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
```
## To run this app locally
```sh
uvicorn src.app:app --reload
```
Your application is now available at `http://localhost:8000`.
| A Basic Bitcoin to Fiat converter - not currently maintained | fastapi,python,bitcoin,javascript,satoshis,hacktoberfest | 2023-03-30T00:29:14Z | 2024-05-06T21:13:40Z | null | 3 | 16 | 75 | 4 | 7 | 3 | null | null | Python |
BillStephens2022/my_portfolio | main | # Project-Portfolio<br>
## Description
This is a web app built with REACT and custom CSS/SCSS to showcase my project portfolio.
See screenshot below:
## Table of Contents
- [Installation](#installation)
- [Usage](#usage)
- [License](#license)
- [Contributing](#contributing)
- [Tests](#tests)
- [Questions](#questions)
## Installation
deployed app URL: https://billstephens2022.github.io/my_portfolio/
## Usage
go to the URL above and navigate to Portfolio page to see my projects
## License
This application is covered under the MIT License.
<br>For more information: https://opensource.org/licenses/MIT
## Contributing
N/A
## Tests
N/A
## Questions
Contact Info<br>
GitHub user name: BillStephens2022<br>
Link to GitHub profile: https://github.com/BillStephens2022<br>
Email: stephensbill17@gmail.com
| My personal portfolio site, built with React.js and SCSS. Features my skills, a page showing my project portfolio which can be filtered by type using React state, my resume (which is downloadable as a pdf), and a functioning contact form. | css,css3,html,html5,javascript,react,react-hooks,react-props,react-router,reactjs | 2023-04-04T19:54:59Z | 2024-04-05T19:57:11Z | null | 1 | 7 | 134 | 0 | 0 | 3 | null | null | CSS |
vikaspotluri123/simple-mfa | main | <center>
# Simple MFA
**Effortlessly add MFA to your app**
</center>
## Sound intriguing?
Check out the docs! https://github.vikaspotluri.me/simple-mfa/
| SimpleMfa is a javascript library designed to minimize the complexity of adding MFA to your app. | javascript,mfa,multifactor-authentication,two-factor-authentication | 2023-03-29T02:45:39Z | 2024-05-20T05:16:06Z | null | 1 | 112 | 240 | 1 | 0 | 3 | null | MIT | JavaScript |
Vipin-Goyal/Piano-Music-App | master | null | Piano-Music_App | css3,html5,index,javascript,music,music-player,notes,packages,script,styled-components | 2023-04-04T14:20:13Z | 2023-04-04T14:21:29Z | null | 1 | 0 | 1 | 0 | 0 | 3 | null | null | HTML |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.