🌙 Dark Mode

🎨 React Styling - Complete Guide

Day 20-21: Master karo React mein styling ke saare tarike!

📚 Introduction - React Styling Kya Hai?

Dekho dosto, React mein styling karna matlab hai apne components ko sundar aur attractive banana. Jaise hum apne ghar ko decorate karte hain, waise hi React components ko bhi style karna padta hai. Lekin React mein styling ke bahut saare tarike hain - traditional CSS se lekar modern styled-components tak!

Definition: React Styling refers to the various methods and approaches used to apply CSS styles to React components, ranging from traditional CSS files to CSS-in-JS solutions.
🎯

Multiple Approaches

Global CSS, CSS Modules, Styled Components, aur bahut kuch!

⚡

Performance

Optimized styling for faster load times

🔧

Flexibility

Choose karo jo tumhare project ke liye best hai

📱

Responsive

Mobile se desktop tak perfect display

🎨 Styling Methods - Sabhi Tarike

1️⃣ Global CSS - Traditional Approach

Ye sabse purana aur simple tarika hai! Isme hum normal CSS file banate hain aur use import kar lete hain. Jaise traditional websites mein karte the, waise hi. Lekin iska ek problem hai - saare styles global ho jate hain, matlab kisi bhi component mein apply ho sakte hain.

Global CSS: A traditional styling approach where CSS rules are defined in separate .css files and imported into components, making styles available globally across the application.

📦 Setup & Installation

1 Create React App mein already included hai!
2 CSS file banao aur import karo:
/* styles.css */
.button {
    background-color: #61dafb;
    color: white;
    padding: 10px 20px;
    border: none;
    border-radius: 5px;
    cursor: pointer;
}

.button:hover {
    background-color: #4fa8c5;
}

/* App.js */
import './styles.css';

function App() {
    return <button className="button">Click Me</button>;
}

🎮 Live Demo - Global CSS

Global CSS Styled Box

Ye box global CSS se styled hai!

✅ Advantages

  • Simple aur easy to understand
  • Traditional CSS knowledge use kar sakte ho
  • Quick setup, no extra configuration
  • Browser caching ka benefit

❌ Disadvantages

  • Name collision ka risk
  • Global scope issues
  • Dead code elimination difficult
  • Component-specific styling hard

2️⃣ CSS Modules - Scoped Styling

CSS Modules ek game-changer hai! Isme har component ki apni CSS file hoti hai aur wo automatically scoped ho jati hai. Matlab ek component ki styling dusre component ko affect nahi karegi. Ye Create React App mein by default supported hai!

CSS Modules: A CSS file in which all class names and animation names are scoped locally by default, preventing naming conflicts and ensuring component-level encapsulation.

📦 Setup & Installation

1 Create React App mein built-in hai - koi installation nahi chahiye!
2 File naming convention: ComponentName.module.css
3 Import karo aur use karo:
/* Button.module.css */
.button {
    background-color: #e1bee7;
    color: #4a148c;
    padding: 12px 24px;
    border: 2px solid #9c27b0;
    border-radius: 8px;
    font-weight: bold;
}

.button:hover {
    background-color: #ce93d8;
    transform: scale(1.05);
}

/* Button.js */
import styles from './Button.module.css';

function Button() {
    return <button className={styles.button}>Click Me</button>;
}

/* Multiple classes */
<div className={`${styles.card} ${styles.active}`}>Content</div>

🎮 Live Demo - CSS Modules

CSS Module Styled Box

Ye box CSS Modules se styled hai - completely scoped!

✅ Advantages

  • Local scope - no naming conflicts
  • Component-specific styling
  • Easy to maintain
  • Works with existing CSS knowledge

❌ Disadvantages

  • Extra file for each component
  • Class name syntax thoda different
  • Dynamic styling limited
  • Build step required

3️⃣ Styled Components - CSS-in-JS Magic

Ye sabse popular CSS-in-JS library hai! Isme tum JavaScript ke andar hi CSS likh sakte ho. Bahut powerful hai kyunki tum props ke basis pe dynamic styling kar sakte ho. Tagged template literals ka use karte hain isme.

Styled Components: A CSS-in-JS library that allows you to write actual CSS code to style components using tagged template literals, enabling dynamic styling based on props and automatic critical CSS injection.

📦 Installation Steps

1 Install styled-components:
npm install styled-components
2 Import aur use karo:
import styled from 'styled-components';
3 Optional: VS Code Extension install karo

vscode-styled-components - syntax highlighting ke liye

import styled from 'styled-components';

// Basic styled component
const Button = styled.button`
    background-color: ${props => props.primary ? '#61dafb' : '#gray'};
    color: white;
    padding: 12px 24px;
    border: none;
    border-radius: 8px;
    font-size: 16px;
    cursor: pointer;
    transition: all 0.3s ease;

    &:hover {
        transform: translateY(-2px);
        box-shadow: 0 5px 15px rgba(0,0,0,0.2);
    }

    &:disabled {
        opacity: 0.5;
        cursor: not-allowed;
    }
`;

// Extending styles
const PrimaryButton = styled(Button)`
    background-color: #61dafb;
    font-weight: bold;
`;

// Using with props
function App() {
    return (
        <>
            <Button primary>Primary Button</Button>
            <Button>Secondary Button</Button>
            <PrimaryButton>Extended Button</PrimaryButton>
        </>
    );
}

// Theming support
import { ThemeProvider } from 'styled-components';

const theme = {
    colors: {
        primary: '#61dafb',
        secondary: '#282c34',
    }
};

const ThemedButton = styled.button`
    background: ${props => props.theme.colors.primary};
`;

function App() {
    return (
        <ThemeProvider theme={theme}>
            <ThemedButton>Themed Button</ThemedButton>
        </ThemeProvider>
    );
}

🎮 Live Demo - Styled Components

Styled Component Box

Dynamic styling with props!

✅ Advantages

  • Dynamic styling with props
  • Automatic critical CSS
  • No class name bugs
  • Easy theming support
  • Server-side rendering ready

❌ Disadvantages

  • Extra library dependency
  • Learning curve for syntax
  • Runtime overhead (small)
  • Debugging can be tricky

4️⃣ Emotion - Performant CSS-in-JS

Emotion bhi ek powerful CSS-in-JS library hai! Ye styled-components jaisi hai lekin thodi zyada flexible aur performant. Isme do tarike hain styling karne ke - styled API aur css prop. Bahut fast hai aur bundle size bhi chota hai!

Emotion: A performant and flexible CSS-in-JS library that provides both styled component API and css prop approach, with excellent performance characteristics and smaller bundle size compared to alternatives.

📦 Installation Steps

1 Install Emotion packages:
npm install @emotion/react @emotion/styled
2 For css prop, add JSX pragma:
/** @jsxImportSource @emotion/react */
3 Or configure in tsconfig.json/jsconfig.json:
{
  "compilerOptions": {
    "jsxImportSource": "@emotion/react"
  }
}
/** @jsxImportSource @emotion/react */
import { css } from '@emotion/react';
import styled from '@emotion/styled';

// Method 1: css prop
const buttonStyle = css`
    background-color: #b2dfdb;
    color: #004d40;
    padding: 12px 24px;
    border: 2px solid #00796b;
    border-radius: 8px;
    cursor: pointer;
    
    &:hover {
        background-color: #80cbc4;
    }
`;

function App() {
    return <button css={buttonStyle}>Click Me</button>;
}

// Method 2: styled API
const Button = styled.button`
    background-color: #b2dfdb;
    color: #004d40;
    padding: 12px 24px;
    border: 2px solid #00796b;
    border-radius: 8px;
`;

// Method 3: Object styles
const objectStyle = css({
    backgroundColor: '#b2dfdb',
    color: '#004d40',
    padding: '12px 24px',
    '&:hover': {
        backgroundColor: '#80cbc4'
    }
});

// Composition
const baseButton = css`
    padding: 12px 24px;
    border-radius: 8px;
`;

const primaryButton = css`
    ${baseButton}
    background-color: #61dafb;
    color: white;
`;

✅ Advantages

  • Excellent performance
  • Smaller bundle size
  • Multiple styling approaches
  • Great TypeScript support
  • Framework agnostic

❌ Disadvantages

  • JSX pragma configuration needed
  • Less popular than styled-components
  • Documentation can be confusing

5️⃣ Tailwind CSS - Utility-First Framework

Tailwind CSS ek revolutionary approach hai! Isme pre-defined utility classes hote hain jo tum directly HTML mein use karte ho. Custom CSS likhne ki zarurat nahi padti. Bahut fast development hoti hai isse aur consistent design bhi milta hai!

Tailwind CSS: A utility-first CSS framework that provides low-level utility classes to build custom designs without writing custom CSS, promoting rapid development and consistent design systems.

📦 Installation Steps

1 Install Tailwind CSS:
npm install -D tailwindcss postcss autoprefixer
2 Initialize Tailwind:
npx tailwindcss init -p
3 Configure tailwind.config.js:
module.exports = {
  content: [
    "./src/**/*.{js,jsx,ts,tsx}",
  ],
  theme: {
    extend: {
      colors: {
        primary: '#61dafb',
      }
    },
  },
  plugins: [],
}
4 Add Tailwind directives to CSS:
/* index.css */
@tailwind base;
@tailwind components;
@tailwind utilities;
5 Start using Tailwind classes!
// Basic usage
function Button() {
    return (
        <button className="bg-blue-500 hover:bg-blue-700 text-white 
                          font-bold py-2 px-4 rounded 
                          transition duration-300 ease-in-out
                          transform hover:scale-105">
            Click Me
        </button>
    );
}

// Responsive design
function Card() {
    return (
        <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-4">
            <div className="bg-white p-6 rounded-lg shadow-md">
                Card 1
            </div>
        </div>
    );
}

// Dark mode support
function DarkModeExample() {
    return (
        <div className="bg-white dark:bg-gray-800 
                       text-black dark:text-white">
            Content
        </div>
    );
}

// Custom classes with @apply
/* styles.css */
@layer components {
    .btn-primary {
        @apply bg-blue-500 hover:bg-blue-700 text-white 
               font-bold py-2 px-4 rounded;
    }
}

🎮 Live Demo - Tailwind-like Styling

Tailwind-Style Box

Utility classes se styled!

✅ Advantages

  • Rapid development
  • Consistent design system
  • No naming conventions needed
  • Purge unused CSS automatically
  • Responsive design easy

❌ Disadvantages

  • HTML can look cluttered
  • Learning curve for class names
  • Build configuration required
  • Custom designs need extension

6️⃣ UI Libraries - Ready-Made Components

Agar tum jaldi kaam karna chahte ho, to UI libraries best hain! Material UI, Chakra UI, Ant Design - ye sab pre-built components dete hain jo already styled hote hain. Tum bas import karo aur use karo. Customization bhi kar sakte ho!

UI Component Libraries: Pre-built, customizable component libraries that provide ready-to-use styled components following specific design systems, significantly speeding up development time.

📦 Material UI (MUI) Installation

1 Install MUI:
npm install @mui/material @emotion/react @emotion/styled
2 Install icons (optional):
npm install @mui/icons-material
3 Add Roboto font to index.html:
<link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Roboto:300,400,500,700&display=swap" />
// Material UI Example
import { Button, TextField, Card, CardContent } from '@mui/material';
import { ThemeProvider, createTheme } from '@mui/material/styles';
import DeleteIcon from '@mui/icons-material/Delete';

const theme = createTheme({
    palette: {
        primary: {
            main: '#61dafb',
        },
        secondary: {
            main: '#ff6b6b',
        }
    },
});

function App() {
    return (
        <ThemeProvider theme={theme}>
            <Card>
                <CardContent>
                    <TextField 
                        label="Name" 
                        variant="outlined" 
                        fullWidth 
                        margin="normal"
                    />
                    <Button 
                        variant="contained" 
                        color="primary"
                        startIcon={<DeleteIcon />}
                    >
                        Submit
                    </Button>
                </CardContent>
            </Card>
        </ThemeProvider>
    );
}

📦 Chakra UI Installation

1 Install Chakra UI:
npm install @chakra-ui/react @emotion/react @emotion/styled framer-motion
2 Wrap app with ChakraProvider:
import { ChakraProvider } from '@chakra-ui/react';

function App() {
    return (
        <ChakraProvider>
            {/* Your app */}
        </ChakraProvider>
    );
}
// Chakra UI Example
import { Button, Input, Box, Stack, useColorMode } from '@chakra-ui/react';

function App() {
    const { colorMode, toggleColorMode } = useColorMode();
    
    return (
        <Box p={8} bg={colorMode === 'light' ? 'white' : 'gray.800'}>
            <Stack spacing={4}>
                <Input placeholder="Enter name" size="lg" />
                <Button colorScheme="blue" size="lg">
                    Submit
                </Button>
                <Button onClick={toggleColorMode}>
                    Toggle {colorMode === 'light' ? 'Dark' : 'Light'}
                </Button>
            </Stack>
        </Box>
    );
}

📦 Ant Design Installation

1 Install Ant Design:
npm install antd
2 Import CSS in index.js or App.js:
import 'antd/dist/reset.css';
// Ant Design Example
import { Button, Input, Card, Space } from 'antd';
import { DeleteOutlined, SearchOutlined } from '@ant-design/icons';

function App() {
    return (
        <Card title="User Form" style={{ width: 400 }}>
            <Space direction="vertical" style={{ width: '100%' }}>
                <Input 
                    placeholder="Enter name" 
                    prefix={<SearchOutlined />}
                    size="large"
                />
                <Button 
                    type="primary" 
                    icon={<DeleteOutlined />}
                    size="large"
                    block
                >
                    Submit
                </Button>
            </Space>
        </Card>
    );
}

📦 Material UI

Google's Material Design

  • Comprehensive components
  • Great documentation
  • Large community
  • Accessibility built-in

⚡ Chakra UI

Simple & Modular

  • Easy to customize
  • Excellent DX
  • Built-in dark mode
  • Lightweight

🐜 Ant Design

Enterprise-grade

  • Rich component set
  • Professional look
  • i18n support
  • TypeScript ready

📱 Responsive UI Patterns

Aaj kal har device pe website chalti hai! Mobile, tablet, laptop, desktop - sabke liye responsive design banana bahut zaroori hai. Media queries, flexbox, aur grid ka use karke hum responsive layouts bana sakte hain.

Responsive Design: An approach to web design that makes web pages render well on a variety of devices and window or screen sizes, using flexible layouts, images, and CSS media queries.
// CSS Media Queries
.container {
    display: grid;
    grid-template-columns: repeat(4, 1fr);
    gap: 20px;
}

@media (max-width: 1024px) {
    .container {
        grid-template-columns: repeat(2, 1fr);
    }
}

@media (max-width: 768px) {
    .container {
        grid-template-columns: 1fr;
    }
}

// Tailwind Responsive Classes
<div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-4">
    <div>Item 1</div>
    <div>Item 2</div>
</div>

🎮 Responsive Grid Demo

Window resize karo aur dekho kaise layout change hota hai!

Box 1
Box 2
Box 3
Box 4

🌙 Dark Mode Implementation

Dark mode ab har app mein hona chahiye! Users ko choice deni chahiye ki wo light ya dark theme use karein. CSS variables, context API, ya localStorage ka use karke implement kar sakte hain.

Dark Mode: A color scheme that uses light-colored text and UI elements on dark backgrounds, reducing eye strain in low-light conditions and potentially saving battery on OLED screens.

📦 Dark Mode Implementation Methods

1 CSS Variables Method (Recommended)
2 Styled Components ThemeProvider
3 Chakra UI useColorMode Hook
4 Tailwind Dark Mode Classes
// Method 1: CSS Variables Approach
:root {
    --bg-color: #ffffff;
    --text-color: #333333;
}

[data-theme="dark"] {
    --bg-color: #1a1a1a;
    --text-color: #e0e0e0;
}

body {
    background-color: var(--bg-color);
    color: var(--text-color);
}

// React Implementation
function App() {
    const [theme, setTheme] = useState('light');
    
    useEffect(() => {
        document.documentElement.setAttribute('data-theme', theme);
        localStorage.setItem('theme', theme);
    }, [theme]);
    
    const toggleTheme = () => {
        setTheme(theme === 'light' ? 'dark' : 'light');
    };
    
    return (
        <button onClick={toggleTheme}>
            Toggle {theme === 'light' ? '🌙' : '☀️'}
        </button>
    );
}

// Method 2: Styled Components
import { ThemeProvider } from 'styled-components';

const lightTheme = {
    bg: '#ffffff',
    text: '#333333',
};

const darkTheme = {
    bg: '#1a1a1a',
    text: '#e0e0e0',
};

function App() {
    const [isDark, setIsDark] = useState(false);
    
    return (
        <ThemeProvider theme={isDark ? darkTheme : lightTheme}>
            {/* Your app */}
        </ThemeProvider>
    );
}

// Method 3: Chakra UI
import { useColorMode } from '@chakra-ui/react';

function App() {
    const { colorMode, toggleColorMode } = useColorMode();
    
    return (
        <Button onClick={toggleColorMode}>
            Toggle {colorMode === 'light' ? 'Dark' : 'Light'}
        </Button>
    );
}

// Method 4: Tailwind CSS
// Enable dark mode in tailwind.config.js
module.exports = {
    darkMode: 'class', // or 'media'
    // ...
}

// Use dark: prefix
<div className="bg-white dark:bg-gray-800 text-black dark:text-white">
    Content
</div>

🎮 Dark Mode Demo

Upar right corner mein button se dark mode toggle karo!

Current theme automatically changes karta hai!

✨ Best Practices - Pro Tips

Yahan kuch important tips hain jo tumhe production-ready apps banane mein help karengi:

🎯

Consistent Naming

BEM methodology ya consistent naming convention follow karo

🔄

Reusable Styles

Common styles ko variables ya mixins mein store karo

⚡

Performance

Unused CSS remove karo, critical CSS inline karo

♿

Accessibility

Color contrast, focus states, aur ARIA labels use karo

📦

Component Structure

Styles ko components ke saath co-locate karo

🎨

Design System

Colors, spacing, typography ko standardize karo

// Design Tokens Example
const theme = {
    colors: {
        primary: '#61dafb',
        secondary: '#282c34',
        success: '#4caf50',
        error: '#f44336',
    },
    spacing: {
        xs: '4px',
        sm: '8px',
        md: '16px',
        lg: '24px',
        xl: '32px',
    },
    typography: {
        fontFamily: "'Segoe UI', sans-serif",
        fontSize: {
            sm: '12px',
            md: '16px',
            lg: '20px',
            xl: '24px',
        },
    },
};

💼 Interview Questions - Practice Karo!

Yahan 7 important interview questions hain jo tumse puchhe ja sakte hain. Click karke answers dekho!

Q1: What is the difference between CSS Modules and regular CSS? Easy

Answer:

Regular CSS: Global scope mein hota hai, saare classes globally available hote hain, naming conflicts ho sakte hain.

CSS Modules: Local scope mein hota hai, har component ki apni scoped classes hoti hain, automatically unique class names generate hote hain.

// Regular CSS
import './styles.css';
<div className="button">Click</div>

// CSS Modules
import styles from './Button.module.css';
<div className={styles.button}>Click</div>

Key Point: CSS Modules prevent naming collisions and provide component-level encapsulation.

Q2: Explain CSS-in-JS and its advantages over traditional CSS. Medium

Answer:

CSS-in-JS: JavaScript ke andar CSS likhne ka approach hai. Libraries like styled-components aur Emotion iska use karti hain.

Advantages:

  • ✅ Dynamic Styling: Props ke basis pe styles change kar sakte ho
  • ✅ Scoped Styles: Automatically component-specific hote hain
  • ✅ No Class Name Bugs: Unique class names automatically generate hote hain
  • ✅ Dead Code Elimination: Unused styles automatically remove ho jate hain
  • ✅ Critical CSS: Only required CSS load hota hai
const Button = styled.button`
    background: ${props => props.primary ? 'blue' : 'gray'};
    color: white;
    padding: 10px 20px;
`;

Q3: How would you implement dark mode in a React application? Medium

Answer:

Dark mode implement karne ke multiple approaches hain:

1. CSS Variables Approach:

// Define CSS variables
:root {
    --bg-color: #fff;
    --text-color: #333;
}

[data-theme="dark"] {
    --bg-color: #1a1a1a;
    --text-color: #e0e0e0;
}

// React component
function App() {
    const [theme, setTheme] = useState('light');
    
    useEffect(() => {
        document.documentElement.setAttribute('data-theme', theme);
        localStorage.setItem('theme', theme);
    }, [theme]);
    
    return (
        <button onClick={() => setTheme(theme === 'light' ? 'dark' : 'light')}>
            Toggle Theme
        </button>
    );
}

2. Context API Approach: Global theme state manage karne ke liye

3. Styled Components ThemeProvider: Theme object pass karne ke liye

Q4: What are the performance implications of different styling approaches? Hard

Answer:

Performance Comparison:

  • Global CSS: Fastest - static files, browser caching, no runtime overhead
  • CSS Modules: Fast - compile-time processing, no runtime cost
  • Styled Components: Small runtime overhead - styles generate hote hain runtime pe, but critical CSS injection se optimize hota hai
  • Tailwind CSS: Fast after purging - unused classes remove ho jate hain build time pe

Optimization Tips:

  • ✅ Code splitting use karo
  • ✅ Critical CSS inline karo
  • ✅ Unused styles purge karo
  • ✅ CSS minification enable karo
  • ✅ Server-side rendering consider karo

Q5: Explain the concept of CSS-in-JS and compare styled-components with Emotion. Hard

Answer:

Styled-Components:

  • ✅ More popular, larger community
  • ✅ Better documentation
  • ✅ Tagged template literals syntax
  • ❌ Slightly larger bundle size

Emotion:

  • ✅ Better performance
  • ✅ Smaller bundle size
  • ✅ Multiple styling approaches (css prop + styled API)
  • ✅ Framework agnostic
  • ❌ Less popular
// Styled-Components
import styled from 'styled-components';
const Button = styled.button`
    color: blue;
`;

// Emotion - styled API
import styled from '@emotion/styled';
const Button = styled.button`
    color: blue;
`;

// Emotion - css prop
/** @jsxImportSource @emotion/react */
import { css } from '@emotion/react';
<button css={css`color: blue;`}>Click</button>

Q6: How do you handle responsive design in React applications? Medium

Answer:

Multiple Approaches:

1. CSS Media Queries:

.container {
    display: grid;
    grid-template-columns: repeat(4, 1fr);
}

@media (max-width: 768px) {
    .container {
        grid-template-columns: 1fr;
    }
}

2. Tailwind Responsive Classes:

<div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4">
    Content
</div>

3. JavaScript Window Resize:

const [isMobile, setIsMobile] = useState(window.innerWidth < 768);

useEffect(() => {
    const handleResize = () => {
        setIsMobile(window.innerWidth < 768);
    };
    window.addEventListener('resize', handleResize);
    return () => window.removeEventListener('resize', handleResize);
}, []);

4. React Responsive Library: useMediaQuery hook use karo

Q7: What factors should you consider when choosing a styling solution for a React project? Hard

Answer:

Key Factors to Consider:

  • 1. Project Size: Small projects ke liye simple CSS, large projects ke liye CSS-in-JS ya Tailwind
  • 2. Team Experience: Team ko kya pata hai? Traditional CSS ya modern approaches?
  • 3. Performance Requirements: Critical performance needs? Static CSS best hai
  • 4. Dynamic Styling Needs: Bahut dynamic styling chahiye? CSS-in-JS use karo
  • 5. Bundle Size: Bundle size important hai? Emotion ya Tailwind consider karo
  • 6. Development Speed: Fast development? UI libraries ya Tailwind use karo
  • 7. Maintenance: Long-term maintenance? CSS Modules ya styled-components
  • 8. SSR Requirements: Server-side rendering? CSS-in-JS libraries SSR support karte hain

Decision Matrix:

  • 🎯 Simple Project: Global CSS or CSS Modules
  • 🎯 Component Library: Styled-components or Emotion
  • 🎯 Rapid Development: Tailwind CSS or UI Library
  • 🎯 Enterprise App: CSS Modules + Design System

📝 Summary - Quick Recap

Toh dosto, humne kya seekha?

🎨 Multiple Approaches

Global CSS, CSS Modules, Styled Components, Emotion, Tailwind - har ek ka apna use case hai

⚡ Performance Matters

Right approach choose karo project requirements ke according

📱 Responsive Design

Media queries aur flexible layouts se har device pe perfect display

🌙 Modern Features

Dark mode, theming, aur dynamic styling implement karna seekha

Remember: Koi ek "best" approach nahi hai - project requirements, team experience, aur performance needs ke basis pe decision lo. Practice karo aur experiment karo different approaches ke saath!