I’ve done this before. I bet you have too. The quickest way to wreck your relationships is to blurt out every thought in your head, no stopping, no thinking. It’s like spilling tea on a white shirt—it stains fast. When you talk without a pause, your relationships stop feeling safe and start feeling like a fight waiting to happen.

When you let every feeling pour out, it’s not just words. It’s pain. Saying stuff like “You’re so lazy” or “I’m sick of you” doesn’t disappear. It stays, like a scratch on your favorite table. I once got mad at my sister for borrowing my jacket without asking. “You’re so selfish!” I yelled. It wasn’t true—I was just annoyed about something else. But she looked so hurt, and we barely talked for days. That was on me, all because I didn’t wait a moment to calm down.

Those quick, mean words usually show what you’re feeling—like if you’re tired or stressed. But to the other person, it feels like you’re attacking them. They start to keep their distance, not because they don’t love you, but because they don’t want to get hurt again. Your family and friends aren’t there to take your bad moods—they deserve kindness.

If you keep saying whatever pops into your head, it makes people act differently around you. Your friend might stop telling you personal stuff because they’re scared you’ll snap. Your brother might avoid you to skip an argument. Even family dinners can feel tense, like everyone’s waiting for you to say something sharp. What used to be a cozy space turns into a place where people are careful around you.

I noticed this with a guy I work with. He’d always speak his mind, like saying “That’s a dumb idea” in meetings. He didn’t mean to be rude, but people stopped talking to him as much. It made me think about how my own words might push people away if I’m not careful.

So, how do you fix this? It’s not about hiding how you feel or acting fake. It’s about taking a tiny second—a deep breath, maybe counting to three—before you talk. That little break is like catching a ball before it hits the ground. It lets you think, Is this what I want to say? Will it help or make things worse?

I started doing this after too many times saying “I’m sorry” for stuff I didn’t mean. When I’m about to get mad, I take a breath or drink some water. Sometimes I say, “Hold on, I need a sec.” It’s not perfect, and I still mess up, but it’s helped a lot. My talks with friends feel easier, like we’re on the same team. It shows I care about their feelings, not just getting my point across.

Here’s what’s worked for me, and maybe it’ll work for you:

1. Name What You Feel: Think to yourself, “I’m mad” or “I’m upset.” It’s like putting a name on a pet—it makes it less wild.

2. Talk About Yourself: Instead of “You never help,” say “I’m feeling stressed.” It’s less like pointing a finger.

3. Fix It Fast: If you say something mean, stop and say, “Wait, let me say that better.” It’s okay to make mistakes.

4. Practice All the Time: Try waiting a second when you’re annoyed, like if someone cuts you off in traffic. It’s like training for the big moments.

5. Say Sorry for Real: If you hurt someone, don’t just say “Whatever.” Say, “I’m sorry, I’ll try not to do that again.” It means a lot.

Your family, friends, and the people you care about make life better. They’re worth taking care of. When you stop and think before you speak, you’re not just avoiding a fight—you’re showing you value them. You’re building trust and making your relationships a place where everyone feels safe. Thats the safe place everyone should have for others.

Next time you want to let everything out, take a breath. Think about the connection you want to keep, not the one you might break. It’s a small thing that changes a lot. Your loved ones will see it, and you’ll feel good knowing you’re keeping things strong.

I’ve seen that real friends, the ones who truly care about you, are rare. They’re happy when you do well and stick by you when things get tough. But then there are others—fake friends—who act like they’re happy for you but deep down, they’re not. They smile and say nice things when you succeed, but inside, they’re jealous. They keep an eye on everything you do, waiting for you to mess up. If you’re in trouble or struggling, they secretly feel happy, even though they act all supportive on the outside. It’s like they’re wearing a mask, pretending to be someone they’re not.

I saw a reel the other day that said something interesting. It said that if your close friends, ones you’ve known for years, suddenly drift away or stop talking to you for no clear reason, it might be the universe’s plan. It’s like life puts you in situations where you see their true face. The mask falls off, and you realize who they really are.

Honestly, I don’t fully believe in this whole “universe planning things” idea. It sounds a bit too filmy for me. But these kinds of experiences do make you think. They make you look at the people in your life and wonder who’s real and who’s just acting.

This is where karma fits in. Karma isn’t just about what you do—it’s also about what’s in your heart. People who secretly enjoy your problems or get jealous of your success are creating bad karma for themselves. Life has a way of balancing things out, and they’ll face the consequences someday. On the other hand, when you’re kind, honest, and supportive, you create good karma, and good things come back to you.

So, what’s the takeaway? First, give time some time—it always shows you who’s genuine. Second, don’t feel bad when someone’s true colors come out. Think of it as a chance to make space for better people in your life. And most importantly, focus on your own karma. Be a good friend, be real, and let life take care of the rest.

In the end, karma is like a mirror—it shows who you really are. As we go through life and deal with all kinds of people, it’s this mirror that helps us find true friends and live a better, happier life.

Thats another way of adulting and realising that we’re bound with Karmic bondage and letting things happen the way they are.

What do you think about karma? Have you ever had a friend whose real face came out later? Share your thoughts, let’s talk!

I remembered how, as a child, visiting the bank used to feel so exciting. I would look around with curiosity—at the staff, their shiny cabins, the various forms, and everything else. I still recall their logo and a large piece of art that used to hang there.

Today, however, there were changes in the bank’s surroundings. But I didn’t notice them, as my attention was glued to my phone. It made me realize how much I’ve dulled my ability to observe and engage with the present moment.

Being present means being fully aware of what’s happening around you—paying attention to every detail, every feeling, and understanding how you react to it. This awareness doesn’t come easily, but with daily practice, it can grow.

The truth is, we often ignore the present and lose ourselves in artificial distractions—like endlessly scrolling through our phones. This habit pulls us away from experiencing the real world.

To sense something new, our mind needs to be steady and alert, but very few people have this quality today.

If we think about it, can we notice something new in places we visit regularly? I believe we can, but what we notice will change with age and perspective.

Your intelligence is determined by how sharp your observation is and how deeply you engage with what you observe. That’s why the key is to observe the observer—yourself. When you do this, you’ll gain a whole new perspective on life

What has been your experience?

When we think positively, we automatically feel better. On the other hand, if we constantly dwell on thoughts like, “I am unhappy” or “My life is full of problems,” we start embodying that negativity. Osho, in one of his books, mentioned that if a person repeatedly tells themselves for 15 days, “I am sick,” they will actually fall ill. This is because 90% of illnesses are mental, not physical.

In an interview, Shah Rukh Khan shared that every morning he tells himself, “I am the best!” He explained that life throws so many challenges at him, and he has no one to rely on for support. So, he motivates himself to stay strong. This highlights the importance of not becoming a slave to negativity, toxic people, or bad environments.

No situation in life has the power to enslave us unless we let it. Even in toxic relationships, we have the ability to free ourselves. However, this doesn’t mean we label everything as toxic or give up when patience is needed. Every situation must be critically analyzed and evaluated.

Nothing should have the power to control us. We are born with limitless potential. Like a dragon, we have the strength to soar high and overcome negative situations that try to limit us. We can burn away anything that restricts us.

A dragon cannot be caged or forced to perform in a circus because a dragon is not a slave.

Most students gave answers like seeing the tree, its leaves, and flowers. However, Arjuna replied that he could only see the bird’s eye. We all know this story, but what do we learn from it?

Lately, I’ve noticed something about myself — my mood changes a lot, and it’s affecting my daily life.

Some days, I’m very focused. I work seriously and think about what I need to achieve, not just for the day but for the whole year. On such days, I feel motivated and clear about my goals.

But there are days when I feel completely unmotivated and meaningless. Even office work feels like a burden, and I end up sitting idle, scrolling through my phone for hours, wasting the entire day.

Then there are a few days when I keep listening to songs or some Urdu poetry. I spend hours on YouTube, listening to anything I can find and thinking deeply about it. On these days, I manage to do some work, but not much.

At times, I binge-watch movies or series, one after another, and lose one or two days completely. These kinds of mood swings aren’t helpful at all.

A few months ago, I made a plan to start exercising. Surprisingly, I went to the gym consistently for three months without breaking the momentum. There were days when I skipped it but I made sure that the flow of the workout would not get disturbed over the weeks. Despite work and other responsibilities, I never got tired or skipped a session. I felt proud of myself for staying so disciplined.

Through this, I realized something important: no matter what happens in life, we shouldn’t let it affect us too much. It means there can be a lot of things that might happen at the professional and personal level. There can be days of excitement and boredom or some frustrations and depression but you should keep a balance of that particular emotion very clearly.

If we decide to reset our minds daily and stay committed, we can achieve our goals.

If you truly want to do something, you have to keep other things in control and not let them overwhelm you. That’s the key to maintaining balance, and when you do that, everything starts falling into place.

This might be another sign of maturity that people hold while growing old. I have seen my parents or some people who react very normally to moments of frustration and have never seen their breakdown. This doesn’t mean that they never did, but their threshold was very high.

So the bottom line is to forget the world and just focus on that one single thing which you want the most. If you do it, then everything else will work out. The reward of that one thing will be much higher than the rest of the scrap. So you have to figure out every other thing that’s draining your energy is the ONE or Its just the odd one for you. I hope it makes sense.

This made me think: what do we really need to be happy? We often think we need a lot, but when you break it down, the most important things are actually quite few.

In the past, people said the basics for a good life were food, clothing, and shelter. But today, it feels like we need so much more—a good job, a decent salary, and a lifestyle that’s better than those around us. We chase after all sorts of luxuries, from the latest gadgets to fancy vacations. But if we get caught up in this race, we might miss out on what truly makes us happy.

The movie is set in Japan, where many people live alone due to high living costs and demanding work hours. The main character, Hirayama, is one of these people. He lives in a small room in the city, but he seems perfectly content. His life shows that happiness doesn’t come from having more—it comes from appreciating what you already have.

Hirayama isn’t sad or lonely. Every day, he wakes up, looks at the sky, and smiles, grateful for another day. He loves photography and finds joy in taking pictures of the world around him. Even though he’s been doing it for years, he still sees something new and beautiful every day.

He also loves music, especially vintage records. He doesn’t care about how much they’re worth—he treasures them for the joy they bring him. There’s a touching scene where his niece, who comes from a wealthy family, visits him. She’s fascinated by his simple, peaceful life, even though she’s used to luxury.

Watching *Perfect Days* felt like a peaceful escape. It pulls you into a different world, where happiness isn’t about having more stuff or impressing others. Some parts of the movie might feel slow or repetitive, but that’s part of its charm. It shows how Hirayama finds joy in his daily routine, never getting bored but instead finding new enthusiasm each day.

The final scene of the movie is especially moving, filled with deep emotions and meaning. I won’t give it away, but it’s a moment that leaves a lasting impression.

If you’re looking for a movie that’s different from the usual, *Perfect Days* is worth your time. It’s not just entertainment—it’s a gentle reminder to appreciate the simple things in life. If you’re someone who enjoys finding deeper meaning in stories, this movie will speak to you. Thanks for reading—hope you enjoy the movie.

Every notification and mindless scrolling on our phones keeps us engaged, but it drains our energy. Every thumbnail we see on YouTube, every news article, or random video takes away some of our energy. All this information is like garbage that drains our energy. We get exhausted quickly and can't even realize why we're so tired.

Our brains have a limited capacity and get tired easily. It demands extra energy to process all this information. So, we end up eating more, which can lead to weight gain. Our minds need rest. I realized this when I felt sleepy without reason. Also, I found that my productivity is higher when I take an afternoon nap and resume work after it.

Because our brains get tired in the first half of the day, they need some recharge to work efficiently. Nowadays, our minds need to be empty to think about new ideas or feel good experiences in nature. The taste of the first bite of our meal, the first sip of morning coffee, is always special. Our minds should be empty and curious enough to feel it. If we're taking these things for granted, our minds need to be emptied.

The first step to emptying our minds is realizing we don't need to know everything. So, be selective about online content. Unfollow accounts that don't add value and set boundaries for consumption. Secondly, do physical activities or take a 30-minute walk daily. Engage in real things like observing the sky or listening to different noises.

Listen to mindful music with no words or songs. Silent music can calm our minds. Also, listen to songs we like and sing along. This is my favorite activity, and I do it first thing in the morning while brushing my teeth. Don't use headphones; play it loudly for a different impact.

Clearing clutter from our minds is essential for our well-being. When we let go of irrelevant information, we make space for what truly matters. We can focus better, make decisions more easily, and enjoy life more fully. Emptying our minds doesn't mean we stop thinking; it means we think more clearly and intentionally.

He said that he has so many titles and grand slams and won almost 80% of the matches over the past twenty-plus years or so but if you look at his point score then you’ll realize that he has secured only 54% of them. So even if after scoring only half of the chances of winning the game, he was able to produce such a great winning ratio over the longer run.

This reminds me of Pareto’s Principle where he says that 20% of the goals produce 80% of the impact in life. He derived it from the fact that 80% of the properties and land in Italy is owned by the 20% super influential people. This law is applicable to all the other aspects of life as well.

It simply means that if you focus on the things that are very important and can produce maximum outcomes in life are really worth doing.

In our lives, the maximum impact is produced by the two factors that are an excellent career and prime health. If you have a great career then you become financially strong enough. As long as you are in great health then nothing can stop you from working hard. All the other factors are secondary and hardly matter.

If you are working on some top-notch technologies which are having great potential rather than the traditional ones then definitely you can earn in the maximum bracket.

There are some projects that produce the maximum revenue for the company rather than the other ones. Similarly, only a few people in the team create a major impact and drive the project.

It is said that 80% of the wealth is concentrated by the super wealthy people that are barely 20%.

So at the personal level, It doesn't matter if you’re an introvert and don't have many friends or you can't swim or drive or cook. It doesn't matter if you know financial growth options or not spiritual enough or don't have any hobby. These things are also important but only when you have the first two or three things such as career, health, and family very strong.

As long as you have supportive parents, loved ones, and family, there’s nothing that matters at all. If you don't like your job then can switch to another one. If your relationship is not working enough then can build the new one. If you don't have enough friends then can create some more for sure.

Even though we have a large circle of friends, there are usually only a couple of people who help us during tough times. It's important to rely on those who are there for us. People can be busy with other commitments and may not always be available, even if they want to help. Additionally, the individuals who provide support may change over different phases of life, so it's beneficial to have multiple reliable friends.

I have lost 2 Kg of weight in the last three months just by doing 12 hours of intermittent fasting and 30 minutes of walking daily. I just changed my meal timings of dinner and tried to maintain the 14-hour gap till I take something in the morning. So, usually, I fail but somehow I manage to maintain the 12-hour window. This is very simple and easy to follow and produces maximum outcomes.

So, the bottom line is to create only twenty percent of skills and techniques that will give you 80% of the understanding and expertise in that subject. Identify the two expenses that cost you the maximum salary. Spend your time on those things that will give you maximum satisfaction rather than chasing multiple things at a time.

Well, this was my perspective and the same rule can be applied to multiple things in life. That's all for now, Thanks for reading!

Whenever you see any such kind of advertisement of Biryani or Spicy chat then we get the craving for it so naturally. Suddenly something happens and your mouth becomes watery even if you just think of it.

So did you ever notice what happens in your brain?

There is something that triggers your emotional impulse which results in some action.

All the e-commerce giants like Amazon are spending millions of dollars to create these triggers.

This particular thing is very relative and varies from person to person, so if you’re not conscious enough then you’ll get affected by it easily.

So the most important thing here is to be conscious and alert about all these triggers.

You have to be very resilient and robust about it and make your mind so calm and composed that nothing could trigger you.

There can be a number of examples when external factors impact you so bad that you get lost in it. I have experienced a few such incidents in my life when I got driven by that particular situation. Later, when I look back at those things, I realize that I could have responded differently.

I had gone to a restaurant which was full of people sitting in the groups and I was all alone. I was so embarrassed to sit on the table with no one around me and I could barely take my head up from my mobile. I took my whole meal by just looking at the mobile and somehow ran away from that place.

Later, when I analyzed the same situation critically, I realized that there was no need to get that much embarrassed at all. So the next time when I went to the same restaurant and everything was the same but I did not turn up to my mobile and was sitting quite calmly and composed. No one was even looking at me and I was having so different assumptions in my mind.

The same kind of thing happens if you happen to go to watch a movie all alone. You will realize it if you have been in such a situation. It looks easy but takes real guts.

So the bottom line is to develop such kind of confidence and be immune to all the personal triggers.

The same happens when you see some advertising for some trendy sneakers and clothes and you can't resist visiting that particular portal.

Even when you listen to some music or song then it creates some form of pleasure in your mind and you just get carried away with it for a moment. This can be used as a great tool to calm and relax your mind consciously.

So, instead of getting blown away by such triggers, we should take charge of our minds and can become mindful.

It's a practice and you will achieve it when done consciously. The goal is to be so calm and relaxed as if you've taken some drug shots.

If you're able to understand what I'm trying to say then nothing will disturb you. Just pause for a moment and try to identify what signal its passing to your brain.

There's no drug or no situation or no single thing in this world which can surpass your consciousness and that's the beauty of the brain. This is how you can make your mind ice cold. That's all for now!

Usually, I’m very bad with my workout routine and all but last year I was very serious.

I had followed it actively because I had some backlog of health debt so had no other option.

After a few months, I had some other priorities and I did not continue it. The other priority was my laziness and perhaps I gave much more importance to it.

Also, I thought why should I take some extra time and effort to build my physique unless its not much required. I dont want to go somewhere and do some modelling-like stuff so I will just be focused on my primary work more. If I were to be a model then definitely I would have made six pack abs and all other things.

Sometimes this is how i justify my excuses and avoid that extra push and run away from new challenges. Later I realized I wanted to learn a new hobby and that was playing guitar. I could have learned it earlier in my college days as well. I missed it and I regret it now.

Again I thought I should have taken the other stream of engineering and my life would have been so different by now. Then I thought I should have taken the offer of the other company instead of the current one and so on.

We always think about the other path that we didnt follow and keep on wondering how it would have made a difference to our lives. Most of the time we end up regretting the decisions we didnt take.

But Its always not the same case but our perception that the grass would have been greener on the other side. We never consider that some decisions were wrong at that time and you chose the right ones.

Also, we should not blame ourselves regarding the choices we made even if did not turn in our fever. Nobody is perfect and has the ability to do all things perfectly all the time.

There’s a Japanese concept of living a meaningful life known as ‘Wabi-Sabi’. It means we should not run behind the unrealistic pursuit of perfection and materialistic wealth. It simply means that you only need the bare minimum and not the perfect one.

It means there’s a beauty in the imperfection and accept the most natural phase of life. The sea shells are not perfectly carved yet they are beautiful. The cactus and palm trees are not perfect as per the standards but still, they are adored by a lot of people. Just accept the way you are today becuase you’re in the most authentic and natural state of life.

When we accept ourselves with all the imperfection then we become aware of our limitations. Then we dont set the unrealistic expectations and dont stress about it. This is the zone where growth happens. So, we should seek for the excellence and not for the perfection. This is how you can break that chain of regret and accept yourself the way you are.

So the bottom line is to never regret about anything and being more kind to yourself because you are real and beautiful!

It used to follow object based programming paradigm which is also known as OOPs concept. Recently around 2015 they launched ES6 features which gained popularity due to some drastic change in the structure of the language. After that a lot more features have been released in the ES series until ES14 which was last year in June 2023.

So, lets explore some of the cool features of ECMAScript community that completely changed the game of Javascript development and made it one of the most loved and used language on Stackoverflow survey of last seven years.

1. let and const Declarations:

   • let and const declarations provide block-scoped variables, meaning they are only accessible within the block (typically enclosed in curly braces {}). This contrasts with var, which has function scope or global scope. let variables can be reassigned, while const variables are constants whose value cannot be changed after initialization.

   • Variables declared using the var keyword are scoped to the function in which they are created, or if created outside of any function, to the global object. let and const are block scoped, meaning they are only accessible within the nearest set of curly braces (function, if-else block, or for-loop).

       /**
        * All variables are accessible within functions.
        */
       function variableScope() {
     
         var x = 10;
         let y = 20;
         const z = 30;
     
         console.log(x); // 10
         console.log(y); // 20
         console.log(z); // 30
       }
     
       console.log(x); // ReferenceError: x is not defined
       console.log(y); // ReferenceError: y is not defined
       console.log(z); // ReferenceError: z is not defined
     
       variableScope();
     

       /**
        * var declared variables are accessible anywhere in the function scope.
        */
       if (true) {
         var a = 10;
         let b = 20;
         const c = 30;
       }
     
       console.log(a); // 10
       console.log(b); // ReferenceError: b is not defined
       console.log(c); // ReferenceError: c is not defined
     

     var allows variables to be hoisted, meaning they can be referenced in code before they are declared. let and const will not allow this, instead throwing an error.

       console.log(a); // undefined
       var a = 'foo';
     
       console.log(b); // ReferenceError: can't access lexical declaration 'b' before initialization
       let b = 'baz';
     
       console.log(c); // ReferenceError: can't access lexical declaration 'c' before initialization
       const c = 'bar';
     

     Redeclaring a variable with var will not throw an error, but 'let' and 'const' will.

       var a = 'foo';
       var a = 'bar';
       console.log(a); // "bar"
     
       let b = 'baz';
       let b = 'qux'; // Uncaught SyntaxError: Identifier 'b' has already been declared
     

     let and const differ in that let allows reassigning the variable's value while const does not.

       // This is ok.
       let a = 'foo';
       a = 'bar';
       console.log(a); // bar
     
       // This causes an exception.
       const b = 'baz';
       b = 'qux';
       console.log(b) // TypeError: Assignment to constant variable.
     

2. Arrow Functions:

   • Arrow functions provide a concise syntax for writing functions. They have implicit return if the function body is a single expression. Arrow functions also lexically bind this, meaning they inherit the this value from the surrounding code, which helps avoid issues with traditional function expressions.

   • Arrows is a new syntax for functions, which brings several benefits:

     • Arrow syntax automatically binds this to the surrounding code's context

     • The syntax allows an implicit return when there is no body block, resulting in shorter and simpler code in some cases

     • Last but not least, => is shorter and simpler than function, although stylistic issues are often subjective

Example 01: Arrow Function with No Argument

If a function doesn't take any argument, then you should use empty parentheses.

        let greet = () => console.log('Hello');
        greet(); // Hello

Example 02: Arrow Function with One Argument

If a function has only one argument, you can omit the parentheses.

        let greet = x => console.log(x);
        greet('Hello'); // Hello

Example 03: Arrow Function as an Expression

You can also dynamically create a function and use it as an expression.

        let age = 25;

        let welcome = (age < 18) ?
          () => console.log('Baby') :
          () => console.log('Adult');

        welcome(); // Adult

Example 04: Multiline Arrow Functions

If a function body has multiple statements, you need to put them inside curly brackets {}.

        let area = (r) => {
          const pi = 3.14;
          return pi * r * r;
        }

        let result = area(10);
        console.log(result); // 314

Note: Unlike regular functions, arrow functions do not have their own this. The value of this inside an arrow function remains the same throughout the lifecycle of the function and is always bound to the value of this in the closest non-arrow parent function.

3. Template Literals:

   • Template literals allow embedding expressions within string literals using ${} syntax. This enables multi-line strings without the need for concatenation and provides a convenient way for string interpolation.

4. Destructuring Assignment:

   • Destructuring assignment allows extracting values from arrays or objects into distinct variables using a syntax that mirrors the structure of the array or object. This feature simplifies code and makes it more readable, especially when working with complex data structures.

5. Default Parameters:

   • ES6 allows specifying default values for function parameters. If a parameter is not provided or is undefined, the default value will be used instead. This feature helps avoid the need for verbose checks for undefined values within functions.

6. Rest and Spread Operators:

   • The rest parameter (...args) allows collecting remaining arguments into an array, which is useful when working with functions that can accept a variable number of arguments. The spread operator (...arr) spreads elements of an iterable (like an array) into individual elements, facilitating tasks such as concatenation, copying, or passing array elements as function arguments.

7. Classes:

   • ES6 introduced class syntax, which provides a more familiar and intuitive way to create objects and define their behaviors. Classes support constructor methods, instance methods, static methods, inheritance, and super calls, making object-oriented programming in JavaScript more accessible.

8. Modules:

   • ES6 modules provide a standardized way to organize code into reusable and maintainable components. Modules encapsulate functionality and can export variables, functions, or classes for use in other modules. Import statements allow importing these exported functionalities into other modules, promoting modular code development.

These features represent just a portion of the enhancements introduced in ES6. They significantly improved JavaScript's expressiveness, readability, and maintainability, empowering developers to write more efficient and structured code. Additionally, ES6 laid the foundation for subsequent ECMAScript versions, which continue to expand and refine the language.

1. map():

   • Use Case: Transforming data in an array.

   • Example: Converting an array of Celsius temperatures to Fahrenheit.

       javascriptCopy codeconst celsiusTemperatures = [0, 10, 20, 30, 40];
       const fahrenheitTemperatures = celsiusTemperatures.map(temp => (temp * 9/5) + 32);
       // fahrenheitTemperatures: [32, 50, 68, 86, 104]
     

   • Often, you may need to transform data in an array into a different format.

       javascriptCopy codeconst products = [
           { name: 'Shirt', price: 20 },
           { name: 'Jeans', price: 30 },
           { name: 'Shoes', price: 50 }
       ];
     
       const prices = products.map(product => product.price);
       // prices: [20, 30, 50]
     

   • Rendering Lists: When working with frameworks like React, mapping over an array to render components is a common use case.

       javascriptCopy codeconst items = ['Apple', 'Banana', 'Orange'];
     
       const itemList = items.map((item, index) => <li key={index}>{item}</li>);
     

   • Generating IDs: You can generate unique IDs for array elements.

       javascriptCopy codeconst data = ['John', 'Doe', 'Alice'];
     
       const withIDs = data.map((item, index) => ({ id: index, name: item }));
       // withIDs: [{ id: 0, name: 'John' }, { id: 1, name: 'Doe' }, { id: 2, name: 'Alice
     

2. filter():

   • Use Case: Filtering out elements from an array based on a condition.

   • Example: Filtering out even numbers from an array.

       javascriptCopy codeconst numbers = [1, 2, 3, 4, 5];
       const evenNumbers = numbers.filter(num => num % 2 === 0);
       // evenNumbers: [2, 4]
     

• Data Filtering: Filtering out data based on specific criteria.

    javascriptCopy codeconst numbers = [10, 20, 30, 40, 50];
  
    const filtered = numbers.filter(num => num > 25);
    // filtered: [30, 40, 50]
  

• Search Filtering: Filtering search results based on user input.

    javascriptCopy codeconst users = ['Alice', 'Bob', 'Charlie', 'David'];
  
    function filterUsers(query) {
        return users.filter(user => user.toLowerCase().includes(query.toLowerCase()));
    }
  
    const filteredUsers = filterUsers('b');
    // filteredUsers: ['Bob']
  

• Removing Invalid Data: Filtering out invalid or empty entries from an array.

    javascriptCopy codeconst data = [null, undefined, 0, '', 'Hello', 42];
  
    const validEntries = data.filter(Boolean);
    // validEntries: ['Hello', 42]
  

3. reduce():

   • Use Case: Aggregating data in an array into a single value.

   • Example: Calculating the total sum of values in an array.

       javascriptCopy codeconst numbers = [1, 2, 3, 4, 5];
       const sum = numbers.reduce((acc, curr) => acc + curr, 0);
       // sum: 15
     

4. forEach():

   • Use Case: Iterating over each element of an array.

   • Example: Logging each element of an array.

       javascriptCopy codeconst fruits = ['apple', 'banana', 'orange'];
       fruits.forEach(fruit => console.log(fruit));
       // Output: apple, banana, orange
     

5. find():

   • Use Case: Finding a specific element in an array.

   • Example: Finding the first even number in an array.

       javascriptCopy codeconst numbers = [1, 2, 3, 4, 5];
       const found = numbers.find(num => num % 2 === 0);
       // found: 2
     

6. some():

   • Use Case: Checking if at least one element meets a condition.

   • Example: Checking if an array contains at least one negative number.

       javascriptCopy codeconst numbers = [1, 2, -3, 4, 5];
       const hasNegative = numbers.some(num => num < 0);
       // hasNegative: true
     

7. every():

   • Use Case: Checking if all elements meet a condition.

   • Example: Checking if all elements in an array are positive.

       javascriptCopy codeconst numbers = [1, 2, 3, 4, 5];
       const allPositive = numbers.every(num => num > 0);
       // allPositive: true
     

8. includes():

   • Use Case: Checking if an array contains a specific value.

   • Example: Checking if an array contains a certain string.

       javascriptCopy codeconst fruits = ['apple', 'banana', 'orange'];
       const hasBanana = fruits.includes('banana');
       // hasBanana: true
     

9. slice():

   • Use Case: Extracting a portion of an array.

   • Example: Getting the first three elements of an array.

       javascriptCopy codeconst numbers = [1, 2, 3, 4, 5];
       const firstThree = numbers.slice(0, 3);
       // firstThree: [1, 2, 3]
     

10. Array.from() Method:

    • Description: Creates a new array from an array-like or iterable object.

        javascriptlet str = 'JavaScript';
        let newArray = Array.from(str);
        console.log(newArray);
      

    • Output: ['J', 'a', 'v', 'a', 'S', 'c', 'r', 'i', 'p', 't']2.

11. Array.of() Method:

    • Description: It creates an array with the specified elements. In ES5, when a single numeric value gets passed in the array constructor, then it will create an array of that size. Array.of() is a new way of creating an array which fixes this behavior of ES5.

      By using this method, if you are creating an array only with a single numeric value, then it will create an array only with that value instead of creating the array of that size.

        javascriptlet singleValueArray = Array.of(42);
        console.log(singleValueArray);
      

    • Output: [ 42 ]

These examples demonstrate the practical use of each array method to manipulate data and perform common operations on arrays in JavaScript.

In this blog, we will cover several important points related to pipes in Angular, which are as follows:

- What is a pure pipe?

- What is an async pipe?

- What kind of data can be used with async pipe?

- How can you create a custom pipe?

- How does the async pipe prevent memory leaks?

- What is the difference between pure and impure pipes?

Pure Pipe:

1. Pure pipes are ideal for scenarios where the transformation of data does not rely on any mutable state or side effects. Here are some key points about pure pipes:

   • Statelessness: Pure pipes should not maintain any internal state. Their output solely depends on their input parameters.

   • Deterministic: Pure pipes are deterministic, meaning they produce the same output for the same input every time they are called. This property is crucial for Angular's change detection mechanism to work efficiently.

   • Performance Optimization: Angular can optimize the performance of pure pipes by caching the results of previous transformations and only re-evaluating the pipe when its input values change.

   • Marking as Pure: In Angular, you declare a pipe as pure by setting the pure property to true in the @Pipe decorator.

Async Pipe:

The async pipe is specifically designed to work with asynchronous data sources like observables and promises. Here's what you need to know about async pipes:

• Subscription Management: The async pipe subscribes to the observable or promise passed to it and automatically unsubscribes when the component is destroyed. This behavior prevents memory leaks by ensuring that subscriptions are cleaned up.

• Handling Observable Streams: For observables, the async pipe emits the latest value emitted by the observable stream. It automatically triggers change detection when a new value is emitted.

• Promise Resolution: For promises, the async pipe resolves the promise and emits the resolved value.

• Simplifies Template Code: The async pipe simplifies template code by handling the subscription and unwrapping the asynchronous data source, making the template cleaner and easier to read.

Custom Pipes:

Creating custom pipes allows you to encapsulate complex transformation logic and reuse it across your application. Here's how you create a custom pipe in Angular:

• Implement PipeTransform: Your custom pipe class must implement the PipeTransform interface, which requires you to define a transform method.

• @Pipe Decorator: Decorate your custom pipe class with the @Pipe decorator, providing a name for your pipe. This name is used to reference the pipe in your templates.

• Transformation Logic: Implement the transformation logic inside the transform method. This method takes the input value and optional parameters and returns the transformed value.

• Registering the Pipe: Ensure that your pipe is registered in an Angular module's declarations array or the exports array if you plan to use it in other modules.

Creating Custom Pipes: To create a custom pipe in Angular, you need to implement the PipeTransform interface and its transform method. This method takes an input value and optional parameters, applies some transformation, and returns the transformed value. You also need to decorate your class with @Pipe decorator to make it a pipe. Here's a basic example:

    import { Pipe, PipeTransform } from '@angular/core';

    @Pipe({
      name: 'myCustomPipe'
    })
    export class MyCustomPipe implements PipeTransform {
      transform(value: any, ...args: any[]): any {
        // Implement your transformation logic here
        return transformedValue;
      }
    }

Preventing Memory Leaks with Async Pipe:

The async pipe in Angular automatically unsubscribes from the observable or promise when the component using the pipe is destroyed. This prevents memory leaks because it ensures that subscriptions are cleaned up when no longer needed. This behavior is one of the reasons why the async pipe is recommended for handling asynchronous data streams in Angular applications.

Difference between Pure and Impure Pipes:

• Pure Pipes: As mentioned earlier, pure pipes are stateless and produce the same output for the same input every time. They are generally more efficient because Angular can optimize them by caching the result of previous transformations. Pure pipes are denoted by the pure: true option in the @Pipe decorator.

• Impure Pipes: Impure pipes, on the other hand, can have internal state and may not produce the same output for the same input. They are called more frequently as Angular doesn't cache their results. Impure pipes are useful when the transformation depends on changing external factors, such as user input or state changes. Impure pipes are denoted by the pure: false option in the @Pipe decorator. However, it's recommended to use pure pipes whenever possible for better performance.

Here are some examples of Angular pipes. For more information, refer to the official Angular documentation. In conclusion, understanding the distinction between pure and impure pipes is essential for optimizing Angular applications' performance and efficiency. Pure pipes are recommended for scenarios where output depends solely on input values, while impure pipes are suitable for cases involving external dependencies or state changes.

This kind of external motivation doesn't work. It can not fuel your mind for a longer time. In case it does then also remains for a very short time. So instead of looking for another round of drug shots, you can rely on self-motivation as it lasts for a prolonged time.

So the quote said this -

So when I think about it, I find a few things are relevant and applicable to all of us. Every random quote written by someone can not be the universal truth. It's just another take by that particular person.

The world is not completely divided into black and white. Nothing can be completely wrong and completely right at the same time. There’s always a gray area that exists and that's the beauty of life.

I have seen people struggling in their dream company with the highest paycheck. It doesn't mean that they are not happy or sad. It means that they have their moment of ups and downs in the journey. They have their struggles and lucrative rewards as well.

Some people are insecure about their careers even after passing from the premium institutes. Some are not happy even after getting that prestigious scholarship from the university. And there can be a few people who are still happy doing their normal 9-5 Job as well. It's just a matter of time and perception that makes you happy. It's a circle of musical chairs. You will experience all the shades of life and everyone has to go through it and there is no choice.

In today's world, social media often presents us with perfectly curated images and illusions. This can lead us to believe that everything in life should be flawless, whether it's our careers, relationships, physical appearances, or social circles.

There seems to be an unspoken pressure to strive for an unattainable standard of perfection. But the reality is that perfection is just an illusion.

In reality, nothing in this world is flawless from the outset. It is through our efforts, perseverance, and acceptance of imperfection that we create beauty and meaning in our lives.

The only choice we can make is to change our mindset and be resilient to all the odds. Nothing is perfect or imperfect in this world. We have to make it perfect by taking all the efforts consistently.

You can't lose weight and build a great physic by just sitting idle at home. It takes at least 3 to 6 months of disciplined workouts and diet.

Similarly, a perfect marriage doesn't exist but can be achieved by making generous efforts, understanding, and after some timely sacrifices. The same goes for a great friendship, I realized this when I was talking to one of my best friends who has been there with me for the last 20 years.

So, the bottom line is, that the world is not black and white. There’s always a grey area that exists. Also, there are all shades of a rainbow that exists and we all live in there. Also, nothing is hard in this world if it's done properly. Every situation is temporary whether it's happiness or pain. Embrace the anxiety and understand the universal laws of the world. Just follow the two words, BE BOLD!

1. EU Remote Jobs:

   • Specializing in remote job opportunities within the European Union, this platform is your go-to resource for location-independent roles across diverse tech sectors.

2. Jobteaser:

   • Ideal for graduates exploring job opportunities in Europe, Jobteaser provides a platform that caters to entry-level positions, making it a great resource for those starting their tech careers.

3. Eurojobs:

   • Offering a broad range of job listings across various sectors in Europe, Eurojobs is a comprehensive platform for tech professionals looking for diverse opportunities.

4. No Fluff Jobs:

   • Focused exclusively on IT job opportunities in Europe, No Fluff Jobs streamlines your search for coding, development, and IT-related roles.

5. JobsinNetwork:

   • Providing access to a network of job sites across Europe, JobsinNetwork connects tech professionals with a wide range of job opportunities.

6. EURES (European Job Mobility Portal):

   • As a public service initiative, EURES offers access to job opportunities across the European Union, making it an invaluable resource for tech professionals seeking mobility.

7. Europelanguagejobs:

   • Tailored for individuals with language skills, Europelanguagejobs provides job listings with a language focus, offering tech roles that require linguistic expertise.

8. StepStone:

   • Widely used across Europe and especially in Germany, StepStone is a popular job site that features a variety of tech roles, providing a comprehensive job search experience.

9. Jobs IE:

   • A popular job portal in Ireland covering different industries, Jobs IE is an excellent resource for tech professionals exploring opportunities in the Irish market.

10. The Local Jobs:

    • Providing local job listings in various European countries, The Local Jobs is a valuable platform for tech enthusiasts seeking region-specific opportunities.

So as to conclude this comprehensive guide to Europe's dynamic remote job landscape, you're well on your way to unlocking exciting opportunities.

Remember, remote work offers the flexibility to shape your career on your terms. Whether you're a seasoned professional or just starting, these platforms open doors to a wealth of possibilities.

Bookmark this guide, explore the featured platforms, and embark on your journey towards a fulfilling remote career in the heart of Europe.

Here's to your success and the limitless potential that remote work brings!

It can be the developers' nightmare to tackle tiny issues once you deploy the application and check the performance. So here are some of the areas where you should pay attention from the very early stage of development.

Modify the Codebase:

• Code Splitting: Unleash the power of modularity by breaking your code into smaller, on-demand chunks using dynamic imports. This minimizes initial load times and enhances responsiveness.

• Lazy Loading: Further streamline initial load by deferring the loading of non-critical components until they're actually needed. React's lazy loading feature, often paired with code splitting, proves invaluable here.

Bundle Size Reduction:

• Bundle Analysis: Gain a clear understanding of your bundle composition using tools like Webpack Bundle Analyzer. Identify and eliminate unnecessary dependencies and large libraries to reduce overall size.

• Minification and Compression: Shrink file sizes by minifying JavaScript, CSS, and HTML using tools like UglifyJS and Gzip. This leads to faster transmission and rendering.

Image Optimization:

• Optimized Images: Ensure images are appropriately compressed and optimized before usage. Embrace responsive images and the srcset attribute for device-specific loading, further enhancing efficiency.

Reducing Unnecessary Renders:

• Memoization: Cache the results of expensive function calls with techniques like memoization, effectively preventing redundant re-renders. React.memo and useMemo hooks offer valuable assistance in this area.

Handling Large Data Sets:

• Virtualization: Tackle performance issues associated with large lists or tables by implementing virtualization. Libraries like react-virtualized and react-window render only visible items, significantly boosting performance.

Server-Side Rendering (SSR):

• Initial Content on Server: Optimize time to first paint by rendering initial page content on the server, reducing client-side workload. SSR proves particularly beneficial for SEO and initial load speed.

Production Build Optimization:

• Production-Ready Code: Guarantee the use of React's production build for deployment, benefiting from pre-configured optimizations such as minification and the removal of development-only code.

Continuous Monitoring and Profiling:

• Performance Monitoring: Employ tools like Lighthouse, Google PageSpeed Insights, or New Relic to meticulously monitor performance and pinpoint areas for further enhancement.

• Profiling: Identify specific bottlenecks and tailor optimization strategies accordingly using React's built-in Profiler or external performance profiling tools.

Hope these areas of improvement are enough to understand the importance of the optimization. This could save you from a long bug list. Cheers!

Here are the top five ways to remove the duplicates without hassle.

1. Using the brute force approach, the simplest one and beginner-friendly. You just need to iterate two loops and check the adjacent elements for equality.

    var array = [10, 20, 20, 30, 10, 30, 40, 58, 31, 32, 31]
   
    var unique = [];
   
    for (let i = 0; i < array.length; i++) {
       let isDuplicate = false;
       for (let j = i+1; j < array.length; j++) {
          if(array[i]==array[j]){
             isDup=true
             break;
          }
       }
       if(!isDuplicate){
          unique.push(array[i])         
       }
    }
   
    console.log(unique)
   

2. It can also be done using the filter method where the comparison between the first index of the element and the current index of the element has to be the same.

   Here, the indexOf() method returns the first index of the element.

    var array = [ 10, 30, 10, 20, 30, 40, 10]
   
    for(let i =0; i<array.length; i++){
        console.log(array.indexOf(i))
    }
   
    Num  |IndexOf| Iterator
    10   | 0     | 0
    30   | 1     | 1
    10   | 0     | 2
    20   | 3     | 3
    30   | 1     | 4
    40   | 5     | 5
    10   | 0     | 6
   

   So, we just have to compare the first index should be the same index of that element whenever it occurs in the array.

    function removeDuplicates2(array){
       let unique = array.filter((el, index)=>{
          return(array.indexOf(el) === index)
       })
       console.log("Unique Arrays", unique)
    }
   
    removeDuplicates2([0, 0, 1, 1, 1, 2, 2, 3, 3, 4]);
   

3. Also, there's a shortest method from ES6 that can give you an array with unique values.

    function removeDuplicates3(array){
       let unique = [..new Set(array)]
       console.log("Unique Arrays", unique)
    }
   
    removeDuplicates3([0, 0, 1, 1, 1, 2, 2, 3, 3, 4]);
   

4. You can create a separate array and check if the element exists in that array or not.

    function removeDuplicates4(array){
       let unique = []
       array.forEach((el, index)=>{
        if(!unique.includes(el)){
            unique.push(el)
        }
       })
       console.log("Unique Arrays", unique)
    }
   
    removeDuplicates4([0, 0, 1, 1, 1, 2, 2, 3, 3, 4]);
   

5. The last but not the least is the reduce method from ES6 again. This method has a callback function with two parameters such as accumulater and current element.

   Also, we have to define the initial value of the accumulater as the blank array. The condition would be to check the element exists in the accumulator or not, and if doesn't exist then it will return -1.

    function removeDuplicates5(array){
       let unique = array.reduce((acc, current)=>{
          if(acc.indexOf(current) === -1){
             acc.push(current)
          }
          return acc
       },[])
       console.log("Unique Arrays", unique)
    }
   
    removeDuplicates5([0, 0, 1, 1, 1, 2, 2, 3, 3, 4]);
   

   So, that's it for now, hope you found this article useful for your learning journey, If its beneficial for you then dont forget to click the upvote button. It will motivate me to write more. Cheers!

There are a lot more courses available in Udemy with a very great content. The prices are also very reasonable and it takes a very less amount that is equivalent to buying a pizza for you!

The best form of investment is the one that you do on yourself and learning is the most effective area out of it. So I don't hesitate to buy any course wherever it's available.

The real problem arises when you go on purchasing the courses and don't complete it anymore. Once you start a specific tutorial you get the most of the resistance to it.

You don't like to learn it because it's very low dopamine action and our mind is addicted to the cheap dopamine levels that we get from social media.

Social media including Twitter is the cheapest form of dopamine providers if you don't use it wisely. It's like the slow poison to your mind.

So here are some of the hacks that you can do it overcome it.

• Start the tutorial and try to watch it without doing anything

• If you try to write some notes in the first place then your mind is very reluctant to do it and you end up doing nothing.

• So start very slowly to adapt to learning in the initial days and keep the resistance lower in your mind.

• Follow the 4X pattern and don't expect that you'll understand everything in the first iteration.

• Try to follow the four iterations or repetition of the same tutorial back and forth strictly.

• You would have done it more than 50% of your capacity.

• Thus you can achieve at least more than half of your potential if you just keep your patience instead of just giving up.

• After that you can change the gear and accelerate more. Now you'll be fearless about that topic and you'll get self-motivation to do more.

This has worked really well in my case. You don't need to follow multiple tutorials from every platform or every channel from Youtube.

Once you get a basic understanding of the concepts, try to build things on your own. Just roll up your sleeves and get your hands dirty.

No one has ever learned to swim just by reading books or by sitting outside the pool. So just buckle up and get on the ride.

Hope this is useful! Cheers!

React application is compatible with lots of open-source libraries. When it comes to authentication there are plenty of them but we can proceed with react-google-login

So, we'll discuss the steps to integrate the same in your react app.

1. Create Client Id for OAuth login from the developer console here - https://console.cloud.google.com/

   

2. Create the project with all the details.

   

3. After that, select the created project. Now head towards the left sidebar menu and click on the APIs & Services > OAuth consent screen menu as shown below:

   

4. On the next screen, select the External radio option and hit create.

   

5. Fill up all the details as shown below and complete it further.

   

6. Now, open the left sidebar and select the OAuth option as mentioned.

   

   7. Now, add the details as mentioned.

   

Now, you will abel to see the client Id that can be used in the component.

Once, you're done with this process, you need to create the React app with these steps.

1. Create the new app

   npx create-react-app react-portal-app

2. Install the bootstrap library

   npm install bootstrap --save

3. Now, install the react-google-login package that will provide the functionalities.

   npm install react-google-login

4. Create the google component under the src folder as - googlebutton.component.js and add the following code

    import React, { Component } from "react";
    import { GoogleLogin, GoogleLogout } from "react-google-login";
   
    // You have to replace this client ID as per your app from Google console
    const CLIENT_ID =
      "827529413912-celsdkun_YOUR_API_KEY_lsn28.apps.googleusercontent.com";
   
    class GoogleLoginComponent extends Component {
      constructor() {
        super();
        this.state = {
          isLoggedIn: false,
          userInfo: {
            name: "",
            emailId: "",
          },
        };
      }
   
      // Success Handler
      responseGoogleSuccess = (response) => {
        console.log();
        let userInfo = {
          name: response.profileObj.name,
          emailId: response.profileObj.email,
        };
        this.setState({ userInfo, isLoggedIn: true });
      };
   
      // Error Handler
      responseGoogleError = (response) => {
        console.log(response);
      };
   
      // Logout Session and Update State
      logout = (response) => {
        console.log(response);
        let userInfo = {
          name: "",
          emailId: "",
        };
        this.setState({ userInfo, isLoggedIn: false });
      };
   
      render() {
        return (
          <div className="row mt-5">
            <div className="col-md-12">
              {this.state.isLoggedIn ? (
                <div>
                  <h1>Welcome, {this.state.userInfo.name}</h1>
   
                  <GoogleLogout
                    clientId={CLIENT_ID}
                    buttonText={"Logout"}
                    onLogoutSuccess={this.logout}
                  ></GoogleLogout>
                </div>
              ) : (
                <GoogleLogin
                  clientId={CLIENT_ID}
                  buttonText="Sign In with Google"
                  onSuccess={this.responseGoogleSuccess}
                  onFailure={this.responseGoogleError}
                  isSignedIn={true}
                  cookiePolicy={"single_host_origin"}
                />
              )}
            </div>
          </div>
        );
      }
    }
    export default GoogleLoginComponent;
   

   This component will provide the google sign in and sign out options.

5. Add the selector of the component in your app.js file

    import { Component } from "react";
    import "./App.css";
    import "../node_modules/bootstrap/dist/css/bootstrap.min.css";
    import GoogleLoginComponent from "./googlebutton.component";
   
    class App extends Component {
   
      render() {
        return (
          <div className="App container">
            <h2>Welcome to React App!</h2>
            <GoogleLoginComponent />
          </div>
        );
      }
    }
    export default App;
   

Finally, you can start the app with npm start and its Boom!

You have to be careful while mentioning your URLs in the OAuth configuration, sometimes it takes some time for the configuration at google API end. Once its done, you can start to explore the different parameters that comes in the response.

If you liked it then please share it and hit the like button because,

A person who feels appreciated will do more than expected! Happy coding :)

To integrate Facebook authentication and login in React application, there are multiple libraries available, so we are going to use the 'react-facebook-login' one.

First, you need to have a Facebook account and then you can go to the Developer console here- https://developers.facebook.com/apps

Now, you can create a new app from the button

After that, you can start with any of the options which provide a different range of data, but for our scope as of now, you can select "Business".

Now, you can select the app name as per your convenience like 'react-login-app', and proceed further to create app.

Now your app is ready with the APP ID as shown on the menu bar.

Again you have to click settings > basic > add platform at the bottom of the page. Then you'll able to see this popup and select the web option.

Once you select the web option, select the 'add platform' at the bottom and add the url as shown.

now, we can start with the integration of the same with React app.

1. First, create React app

    npx create-react-app react-facebook-login-app
   

2. Then move inside the app folder with the command:

   cd react-facebook-login-app

3. Install bootstrap library package

   npm install bootstrap --save

4. Now, install the react-facebook-login package

   npm install react-facebook-login

5. Create Facebook login component as FacebookLoginComponent.js

    import React, { useState } from "react";
    import FacebookLogin from "react-facebook-login";
    import "./App.css";
   
    function FacebookLoginComponent() {
      const [login, setLogin] = useState(false);
      const [data, setData] = useState({});
      const [picture, setPicture] = useState("");
   
      const responseFacebook = (response) => {
        console.log(response);
        // Login failed
        if (response.status === "unknown") {
          alert("Login failed!");
          setLogin(false);
          return false;
        }
        setData(response);
        setPicture(response.picture.data.url);
        if (response.accessToken) {
          setLogin(true);
        } else {
          setLogin(false);
        }
      };
      const logout = () => {
        setLogin(false);
        setData({});
        setPicture("");
      };
   
      return (
        <div className="container">
          {!login && (
            <FacebookLogin
              appId="569720507786195"
              autoLoad={false}
              fields="name,email,picture"
              scope="public_profile,email,user_friends"
              callback={responseFacebook}
              icon="fa-facebook"
            />
          )}
   
          {login && (
            <div className="card">
              <div className="card-body">
                <img className="rounded" src={picture} alt="Profile" />
                <h5 className="card-title">{data.name}</h5>
                <p className="card-text">Email ID: {data.email}</p>
                <a href="#" className="btn btn-danger btn-sm" onClick={logout}>
                  Logout
                </a>
              </div>
            </div>
          )}
        </div>
      );
    }
   
    export default FacebookLoginComponent;
   

   Now, you have to replace the appId with yours one.

6. Add the selector to this component in app.js file.

    import './App.css';
    import '../node_modules/bootstrap/dist/css/bootstrap.min.css';
    import FacebookLoginComponent from './facebooklogin.component';
   
    function App() {
      return (
        <div className="App">
           <h1>Facebook Login Tutorial in React App</h1> 
   
           <FacebookLoginComponent />
   
        </div>
      );
    }
   
    export default App;
   

   1. Run the application with npm start

      and check on http://localhost:3000

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1673654978696/eb13afa5-05c5-4cb9-ad50-43222df066fc.png align="center")

That's it. you can check out the example here-

%[https://codesandbox.io/s/react-facebook-login-example-6369em?file=/src/FacebookLoginComponent.js] 

https://codesandbox.io/s/react-facebook-login-example-6369em?file=/src/FacebookLoginComponent.js

Happy coding, Thank you!