Forem: bappasaha

Hooks001: Use State Hook

bappasaha — Sun, 03 Aug 2025 06:49:38 +0000

2.0 React Hooks:

👍Github Code:

📚Article To Read Link
⭐ Simple CRUD Using useState Hook

React hooks are introduced in 2019 in react version 16.8_+
Hooks can not be used inside class component.

What hooks solved?

State
Life Cycle Method
Duplicate Code
Sharing Same Logic

Hook Rules

Hook is used in top level.

useState hook

const [todo,setTodo]=useState()

এখানে, প্রথম ইনডেক্সে থাকবে ভেরিয়েবল (todo) এবং দ্বিতীয় ইনডেক্সে থাকবে ফাংশন (setTodo)
This hook return an array.

আমরা একটি অ্যারে থেকে মান গুলি নিতে চাইব, এবং আমাদের অ্যারে ডিস্ট্রাকচারিং করতে হবে that is অবজেক্ট ডিস্ট্রাকচারিং করার মত।

অবজেক্ট ডিস্ট্রাকচারিং:


 const  state={
        todo:' ',
        warning:null
    }
 const {todo,warning}=state

Array ডিস্ট্রাকচারিং:

const array=[‘bappa’,’appa’,’totot’];
const [a,b,c]=array; // a=’bappa’ consol log

✅ Example:1 where useState take object as argument

  const [todo, setTodo] = useState({
    title: " ",
    description: " ",
  });

Solution code is

import React from "react";
import { useState } from "react";

export default function Example1Todo() {
  const [todo, setTodo] = useState({
    title: " ",
    description: " ",
  });

//   const handleChangeInput = (e) => {};

  const { title, description } = todo;
  return (
    <div>
      <hr />
      <h4>Example1 too</h4>
      <p style={{ backgroundColor: "yellow" }}>Title:{title}</p>
      <br />
      <input
        type="text"
        value={title}
        onChange={(e) =>
          setTodo({
            ...todo,
            title: e.target.value,
          })
        }
      />
      <br />
      <br />
      <textarea
        placeholder="enter your text"
        name="text"
        value={description}
        onChange={(e) =>
          setTodo({
            ...todo,
            description: e.target.value,
          })
        }
      />
      <hr />
    </div>
  );
}

Refactor of the code is

import React, { useState } from "react";

export default function Example1Todo() {
  const [todo, setTodo] = useState({
    title: "",
    description: "",
  });

  const handleInputChange = (e) => {
    const { name, value } = e.target;
    setTodo({
      ...todo,
      [name]: value, // this will dynamically update value
    });
  };

  const { title, description } = todo;

  return (
    <div>
      <hr />
      <h4>Example1 Todo</h4>
      <p style={{ backgroundColor: "yellow" }}>Title: {title}</p>
      <br />
      <input
        type="text"
        name="title"
        value={title}
        onChange={handleInputChange}
      />
      <br />
      <br />
      <textarea
        placeholder="Enter your text"
        name="description"
        value={description}
        onChange={handleInputChange}
      />
      <hr />
    </div>
  );
}

Example:2 where useState take previous value as argument

  const [todo, setTodo] = useState(0);

This is not the good practice

import React, { useState } from 'react'

function Counter() {

    const [count, setCount]=useState(0)
    return (
        <div>
            {count}
            <p>
                <button

                type='button'
                onClick={()=>setCount(count+1)}
                >
                    Add 1
                </button>
            </p>
        </div>
    )
}

export default Counter

This is the good practice

<button

    type='button'
    onClick={()=>setCount((prevState)=>prevState+1)}
    >
    Add 1
    </button>

// good practice

    // let j =0;
    // const addTen=()=>{
    //     while(j<10){
    //         setCount(
    //             (prevState)=>prevState+1
    //         );
    //         j++;
    //     }
    // }

Make Bikash app using Go

bappasaha — Thu, 22 May 2025 18:05:14 +0000

🚀 Learn Any Programming Language Faster — by Building Simple, Practical Projects! 🧠💻

Today, I built a simple USSD-based Bikash (mobile banking) console app in Go (Golang).

🔍 This basic app includes:

✅ Variables and data types

🔄 Loops and conditional logic

📥 User input handling

📤 Console output

📦 Function modularity

🚀 Step-by-Step: How I Developed My Simple Bikash App in Go
✅ Started with basic functionality: Display welcome message and show a simple menu.

🧠 Used if-else statements: Handled user choices like checking balance, cash in, and cash out.

✔️ Added validation: Ensured users can’t cash in or out with invalid amounts (e.g., negative or zero).

🔁 Introduced a loop: Used a for loop to keep the app running without restarting it.

🛑 Added exit condition: Allowed users to exit the app gracefully using a menu option.

🔄 Replaced if-else with switch: Made the code cleaner and easier to manage.

🔲 Run:

cd BikashApp
go run bikash.go

I want to make a simple bikash app which we see in our real life
by typing *247#.

🔲 Final full code

// Run: go run bikash.go

package main

import "fmt"

func main() {

    accountBalance := 1000.00



    // Ask user to dial *247# before starting
    var ussdInput string
    fmt.Print("Please dial *247# to start your transaction: ")
    fmt.Scan(&ussdInput)

    if ussdInput != "*247#" {
        fmt.Println("Invalid USSD code. Exiting...")
        return
    }

    fmt.Println("Welcome to Fake-Bikash App")
    fmt.Println("-------------------------")

    for {
        fmt.Println("What do you want to do?")
        fmt.Println("1. Check Your Balance")
        fmt.Println("2. Cash In")
        fmt.Println("3. Cash Out")
        fmt.Println("4. Exit Fake-Bikash App")

        var choice int
        fmt.Print("Enter your option: ")
        fmt.Scan(&choice)
        // fmt.Println("You have selected option:", choice)

        switch choice {
        case 1:
            fmt.Printf("You Balance is : %.2f Tk\n", accountBalance)
        case 2:
            //user cash in
            fmt.Print("Enter your Cash in amount: ")
            var cashInAmount float64
            fmt.Scan(&cashInAmount)
            fmt.Printf("You entered: %.2f Tk\n", cashInAmount)

            if cashInAmount <= 0 {
                fmt.Println("Invalid amount! Please enter a amount greater than 0.")
                // return;
                continue
            }

            accountBalance = accountBalance + cashInAmount
            fmt.Printf("Balanced Updated!Current balance is: %.2f Tk\n", accountBalance)
        case 3:
            //user cash out
            fmt.Print(("Enter your Cash out amount: "))
            var cashOutAmount float64
            fmt.Scan((&cashOutAmount))

            if cashOutAmount <= 0 {
                fmt.Println("Invalid amount! Please enter a amount greater than 0.")
                continue
            }

            if cashOutAmount > accountBalance {
                fmt.Println("Insufficient balance!")
                // return
                continue
            }

            accountBalance = accountBalance - cashOutAmount
            fmt.Printf("Balanced Updated!Current balance is: %.2f Tk\n", accountBalance)
        default:
            fmt.Println("-----Thanks for chosing Fake-Bikash App----")
            return

        }

    }

}

output:


❯ go run bikash.go
Please dial *247# to start your transaction: 77878
Invalid USSD code. Exiting...
❯ clear
❯ go run bikash.go
Please dial *247# to start your transaction: *247#
Welcome to Fake-Bikash App
-------------------------
What do you want to do?
1. Check Your Balance
2. Cash In
3. Cash Out
4. Exit Fake-Bikash App
Enter your option: 1
You Balance is : 1000.00 Tk
What do you want to do?
1. Check Your Balance
2. Cash In
3. Cash Out
4. Exit Fake-Bikash App
Enter your option: 2
Enter your Cash in amount: 200
You entered: 200.00 Tk
Balanced Updated!Current balance is: 1200.00 Tk
What do you want to do?
1. Check Your Balance
2. Cash In
3. Cash Out
4. Exit Fake-Bikash App
Enter your option: 1
You Balance is : 1200.00 Tk
What do you want to do?
1. Check Your Balance
2. Cash In
3. Cash Out
4. Exit Fake-Bikash App
Enter your option: 3
Enter your Cash out amount: -90
Invalid amount! Please enter a amount greater than 0.
What do you want to do?
1. Check Your Balance
2. Cash In
3. Cash Out
4. Exit Fake-Bikash App
Enter your option: 3
Enter your Cash out amount: 1100
Balanced Updated!Current balance is: 100.00 Tk
What do you want to do?
1. Check Your Balance
2. Cash In
3. Cash Out
4. Exit Fake-Bikash App
Enter your option: 1
You Balance is : 100.00 Tk
What do you want to do?
1. Check Your Balance
2. Cash In
3. Cash Out
4. Exit Fake-Bikash App
Enter your option: 4
-----Thanks for chosing Fake-Bikash App----

Basic task

package main

import "fmt"

func main(){
    fmt.Println("Welcome to Bikash App");
    fmt.Println("What do you want to do?");
    fmt.Println("1. Check Your Balance");
    fmt.Println("2. Cash In");
    fmt.Println("3. Cash Out");
    fmt.Println("4. Exit Bikash App");
}

Next I implemnt if-else based on user choice.

//Run: go run bikash.go

package main

import "fmt"

func main() {

    accountBalance :=1000.00;

    fmt.Println("Welcome to Fake-Bikash App")
    fmt.Println("-------------------------")
    fmt.Println("What do you want to do?")
    fmt.Println("1. Check Your Balance")
    fmt.Println("2. Cash In")
    fmt.Println("3. Cash Out")
    fmt.Println("4. Exit Fake-Bikash App")

    var choice int
    fmt.Print("Enter your option: ")
    fmt.Scan(&choice)
    // fmt.Println("You have selected option:", choice)

    if choice == 1 {
        fmt.Printf("You Balance is : %.2f Tk\n", accountBalance);
    }else if choice == 2 {

        //user cash in
        fmt.Print("Enter your Cash in amount: ");
        var cashInAmount float64;
        fmt.Scan(&cashInAmount,)
        fmt.Printf("You entered: %.2f Tk\n", cashInAmount)

        accountBalance=accountBalance+cashInAmount;
        fmt.Printf("Balanced Updated!Current balance is: %.2f Tk\n", accountBalance);
    }else if choice==3 {
        fmt.Print(("Enter your Cash out amount: "))
        var cashOutAmount float64;
        fmt.Scan((&cashOutAmount));

        accountBalance=accountBalance-cashOutAmount;
        fmt.Printf("Balanced Updated!Current balance is: %.2f Tk\n", accountBalance);
    }else{
        fmt.Println("Exiting Fake-Bikash App")

    }
}

Add Vaditation for cash in and cash out part

// Run: go run bikash.go
package main

import "fmt"

func main() {

    accountBalance := 1000.00

    fmt.Println("Welcome to Fake-Bikash App")
    fmt.Println("-------------------------")

    fmt.Println("What do you want to do?")
    fmt.Println("1. Check Your Balance")
    fmt.Println("2. Cash In")
    fmt.Println("3. Cash Out")
    fmt.Println("4. Exit Fake-Bikash App")

    var choice int
    fmt.Print("Enter your option: ")
    fmt.Scan(&choice)
    // fmt.Println("You have selected option:", choice)

    if choice == 1 {
        fmt.Printf("You Balance is : %.2f Tk\n", accountBalance)
    } else if choice == 2 {

        //user cash in
        fmt.Print("Enter your Cash in amount: ")
        var cashInAmount float64
        fmt.Scan(&cashInAmount)
        fmt.Printf("You entered: %.2f Tk\n", cashInAmount)

        if cashInAmount <= 0 {
            fmt.Println("Invalid amount! Please enter a amount greater than 0.")
            return
        }

        accountBalance = accountBalance + cashInAmount
        fmt.Printf("Balanced Updated!Current balance is: %.2f Tk\n", accountBalance)
    } else if choice == 3 {
        fmt.Print(("Enter your Cash out amount: "))
        var cashOutAmount float64
        fmt.Scan((&cashOutAmount));


        if cashOutAmount <=0{
            fmt.Println("Invalid amount! Please enter a amount greater than 0.")
        };

        if cashOutAmount > accountBalance {
            fmt.Println("Insufficient balance!")
            return
        }

        accountBalance = accountBalance - cashOutAmount
        fmt.Printf("Balanced Updated!Current balance is: %.2f Tk\n", accountBalance)
    } else {
        fmt.Println("Exiting Fake-Bikash App")

    }
}

Add for loop so that i can selete option as much as i need

// Run: go run bikash.go
package main

import "fmt"

func main() {

    accountBalance := 1000.00

    for i := 0; i < 5; i++ {
        fmt.Println("Welcome to Fake-Bikash App")
        fmt.Println("-------------------------")

        fmt.Println("What do you want to do?")
        fmt.Println("1. Check Your Balance")
        fmt.Println("2. Cash In")
        fmt.Println("3. Cash Out")
        fmt.Println("4. Exit Fake-Bikash App")

        var choice int
        fmt.Print("Enter your option: ")
        fmt.Scan(&choice)
        // fmt.Println("You have selected option:", choice)

        if choice == 1 {
            fmt.Printf("You Balance is : %.2f Tk\n", accountBalance)
        } else if choice == 2 {

            //user cash in
            fmt.Print("Enter your Cash in amount: ")
            var cashInAmount float64
            fmt.Scan(&cashInAmount)
            fmt.Printf("You entered: %.2f Tk\n", cashInAmount)

            if cashInAmount <= 0 {
                fmt.Println("Invalid amount! Please enter a amount greater than 0.")
                return
            }

            accountBalance = accountBalance + cashInAmount
            fmt.Printf("Balanced Updated!Current balance is: %.2f Tk\n", accountBalance)
        } else if choice == 3 {
            fmt.Print(("Enter your Cash out amount: "))
            var cashOutAmount float64
            fmt.Scan((&cashOutAmount))

            if cashOutAmount <= 0 {
                fmt.Println("Invalid amount! Please enter a amount greater than 0.")
            }

            if cashOutAmount > accountBalance {
                fmt.Println("Insufficient balance!")
                return
            }

            accountBalance = accountBalance - cashOutAmount
            fmt.Printf("Balanced Updated!Current balance is: %.2f Tk\n", accountBalance)
        } else {
            fmt.Println("Exiting Fake-Bikash App")

        }
    }

}

Add infinite time to run the loop and add condition for loop break


// Run: go run bikash.go
package main

import "fmt"

func main() {

    accountBalance := 1000.00;

    fmt.Println("Welcome to Fake-Bikash App")
    fmt.Println("-------------------------")

    for  {
        fmt.Println("What do you want to do?")
        fmt.Println("1. Check Your Balance")
        fmt.Println("2. Cash In")
        fmt.Println("3. Cash Out")
        fmt.Println("4. Exit Fake-Bikash App")

        var choice int
        fmt.Print("Enter your option: ")
        fmt.Scan(&choice)
        // fmt.Println("You have selected option:", choice)

        if choice == 1 {
            fmt.Printf("You Balance is : %.2f Tk\n", accountBalance)
        } else if choice == 2 {

            //user cash in
            fmt.Print("Enter your Cash in amount: ")
            var cashInAmount float64
            fmt.Scan(&cashInAmount)
            fmt.Printf("You entered: %.2f Tk\n", cashInAmount)

            if cashInAmount <= 0 {
                fmt.Println("Invalid amount! Please enter a amount greater than 0.")
                // return;
                continue
            }

            accountBalance = accountBalance + cashInAmount
            fmt.Printf("Balanced Updated!Current balance is: %.2f Tk\n", accountBalance)
        } else if choice == 3 {
            fmt.Print(("Enter your Cash out amount: "))
            var cashOutAmount float64
            fmt.Scan((&cashOutAmount))

            if cashOutAmount <= 0 {
                fmt.Println("Invalid amount! Please enter a amount greater than 0.")
            }

            if cashOutAmount > accountBalance {
                fmt.Println("Insufficient balance!")
                return
            }

            accountBalance = accountBalance - cashOutAmount
            fmt.Printf("Balanced Updated!Current balance is: %.2f Tk\n", accountBalance)
        } else {
            fmt.Println("-----Thanks for chosing Fake-Bikash App----")
            break;

        }
    }

}

Add switch case

// Run: go run bikash.go
package main

import "fmt"

func main() {

    accountBalance := 1000.00

    fmt.Println("Welcome to Fake-Bikash App")
    fmt.Println("-------------------------")

    for {
        fmt.Println("What do you want to do?")
        fmt.Println("1. Check Your Balance")
        fmt.Println("2. Cash In")
        fmt.Println("3. Cash Out")
        fmt.Println("4. Exit Fake-Bikash App")

        var choice int
        fmt.Print("Enter your option: ")
        fmt.Scan(&choice)
        // fmt.Println("You have selected option:", choice)

        switch choice {
        case 1:
            fmt.Printf("You Balance is : %.2f Tk\n", accountBalance)
        case 2:
            //user cash in
            fmt.Print("Enter your Cash in amount: ")
            var cashInAmount float64
            fmt.Scan(&cashInAmount)
            fmt.Printf("You entered: %.2f Tk\n", cashInAmount)

            if cashInAmount <= 0 {
                fmt.Println("Invalid amount! Please enter a amount greater than 0.")
                // return;
                continue
            }

            accountBalance = accountBalance + cashInAmount
            fmt.Printf("Balanced Updated!Current balance is: %.2f Tk\n", accountBalance)
        case 3:
            //user cash out
            fmt.Print(("Enter your Cash out amount: "))
            var cashOutAmount float64
            fmt.Scan((&cashOutAmount))

            if cashOutAmount <= 0 {
                fmt.Println("Invalid amount! Please enter a amount greater than 0.")
                continue
            }

            if cashOutAmount > accountBalance {
                fmt.Println("Insufficient balance!")
                // return
                continue
            }

            accountBalance = accountBalance - cashOutAmount
            fmt.Printf("Balanced Updated!Current balance is: %.2f Tk\n", accountBalance)
        default:
            fmt.Println("-----Thanks for chosing Fake-Bikash App----")
            return

        }

    }

}

## Optimized Final version Code

go
package main

import "fmt"

var accountBalance float64 =1000.00
func main(){

// var ussdInput string
// fmt.Print("Please dial *247# to start your transaction: ")
// fmt.Scan(&ussdInput)

// if ussdInput != "*247#" {
//  fmt.Println("Invalid USSD code. Exiting...")
//  return
// }

fmt.Println("Welcome to Fake-Bikash App")
fmt.Println("-------------------------")

for {
    showMenu()
    var choice int
    fmt.Scan(&choice)

    switch choice {
    case 1:
        checkBalance()
    case 2:
        cashIn()
    case 3:
        cashOut()
    case 4:
        fmt.Println("-----Thanks for choosing Fake-Bikash App----")
        return
    default:
        fmt.Println("Invalid choice. Please try again.")
    }
}

}

func showMenu(){
fmt.Println("What do you want to do?")
fmt.Println("1. Check Your Balance")
fmt.Println("2. Cash In")
fmt.Println("3. Cash Out")
fmt.Println("4. Exit Fake-Bikash App")
}

func checkBalance(){
fmt.Printf("Your Balance is: %.2f Tk\n", accountBalance)
}

func cashIn() {
var amount float64
fmt.Print("Enter your Cash In amount: ")
fmt.Scan(&amount)

if !isValidAmount(amount) {
    return
}

accountBalance += amount
fmt.Printf("Balance Updated! Current balance is: %.2f Tk\n", accountBalance)

}

func cashOut() {
var amount float64
fmt.Print("Enter your Cash Out amount: ")
fmt.Scan(&amount)

if !isValidAmount(amount) {
    return
}

if amount > accountBalance {
    fmt.Println("Insufficient balance!")
    return
}

accountBalance -= amount
fmt.Printf("Balance Updated! Current balance is: %.2f Tk\n", accountBalance)

}

func isValidAmount(amount float64) bool {
if amount <= 0 {
fmt.Println("Invalid amount! Please enter an amount greater than 0.")
return false
}
return true
}

Redux Best Practice

bappasaha — Sat, 16 Nov 2024 15:44:33 +0000

Redux Best Practices

00.Three Principles of Redux

1: Single source of truth
- The global state of your application is stored in an object tree within a single store.
2: State is read-only
- The only way to change the state is to emit an action, an object describing what happened.
3: Changes are made with pure functions
- To specify how the state tree is transformed by actions, you write pure reducers.

A. Priority Rule [Essential | Medium Priority ]

🔥 Do Not Mutate State
- Actual mutation of state values should always be avoided, both inside reducers and in all other application code.
🔥 Reducers Must Not Have Side Effects
- only depend on their state and action arguments, and should only calculate andreturn a new state value based on those arguments.
- The purpose of this rule is to guarantee that reducers will behave predictably when called.
- They must not execute any kind of asynchronous logic (AJAX calls, timeouts, promises), generate random values (Date.now(), Math.random()), modify variables outside the reducer, or run other code that affects things outside the scope of the reducer function.
🔥 Do Not Put Non-Serializable Values in State or Actions
- Avoid putting non-serializable values such as Promises, Symbols, Maps/Sets, functions, or class instances into the Redux store state or dispatched actions.
- This ensures that capabilities such as debugging via the Redux DevTools will work as expected. It also ensures that the UI will update as expected.
🔥 Only One Redux Store Per App

B. Priority Rules: [ Strongly Recommended | Higher Priority]

🔥Use Redux Toolkit for Writing Redux Logic
🔥Use Immer for Writing Immutable Updates
🔥Structure Files as Feature Folders with Single-File Logic
🔥Put as Much Logic as Possible in Reducers:
- try to put as much of the logic for calculating a new state into the appropriate reducer, rather than in the code that prepares and dispatches the action
🔥Reducers Should Own the State Shape
🔥Name State Slices Based On the Stored Data
- Your object should look like {users: {}, posts: {}}, rather than {usersReducer: {}, postsReducer: {}}.
🔥Organize State Structure Based on Data Types, Not Components
🔥Treat Reducers as State Machines
- state machines", where the combination of both the current state and the dispatched action determines whether a new state value is actually calculated
🔥 Normalize Complex Nested/Relational State
🔥 Keep State Minimal and Derive Additional Values
🔥 Write Meaningful Action Names
🔥 Allow Many Reducers to Respond to the Same Action
🔥 Avoid Dispatching Many Actions Sequentially
🔥 Use the React-Redux Hooks API
- Prefer using the React-Redux hooks API (useSelector and useDispatch) as the default way to interact with a Redux store from your React components
🔥 Use the Redux DevTools Extension for Debugging
- Configure your Redux store to enable debugging with the Redux DevTools Extension. It allows you to view:
  - The history log of dispatched actions
  - The contents of each action
  - The final state after an action was dispatched
  - The diff in the state after an action
  - The function stack trace showing the code where the action was actually dispatched

In addition, the DevTools allows you to do "time-travel debugging", stepping back and forth in the action history to see the entire app state and UI at different points in time.
Redux was specifically designed to enable this kind of debugging, and the DevTools are one of the most powerful reasons to use Redux.

C. Priority Rules: [ Recommended | Low priority ]

🔥 Write Action Types as domain/eventName
🔥 Write Actions Using the Flux Standard Action Convention
- Should always put their data into a payload field
- May have a meta field for additional info
- May have an error field to indicate the action represents a failure of some kind
🔥 Use Action Creators
🔥 Use RTK Query for Data Fetching

Simple CRUD using React useState( ) hook.

bappasaha — Sat, 16 Nov 2024 07:50:47 +0000

This is done using React typeScript

Here I use three useState to make the operation.
I showed the refctor version where I use only one useState hook

Three useState ()

import React, { useState } from 'react';

// Define the type for a Todo
interface Todo {
  id: number;
  title: string;
}

const defaultTodos=[{
    id:123456789,
    title:"Bappa Saha Bapi"
},
{
    id:12345678900,
    title:"Partho Saha Bapi"
}]

const BasicTodo= () => {

  const [todos, setTodos] = useState<Todo[]>(defaultTodos);
  const [title, setTitle] = useState<string>('');
  const [editId, setEditId] = useState<number | null>(null);

  // Function to add or update a todo
  const handleSubmit = (e: React.FormEvent<HTMLFormElement>) => {
    e.preventDefault();
    if (editId !== null) {
      // Update existing todo
      setTodos(todos.map(todo => (todo.id === editId ? { ...todo, title } : todo)));
      setEditId(null);
    } else {
      // Add new todo
      const newTodo: Todo = { id: Date.now(), title };
      setTodos([...todos, newTodo]);
    }
    setTitle('');
  };

  // Function to delete a todo
  const handleDelete = (id: number) => {
    setTodos(todos.filter(todo => todo.id !== id));
  };

  // Function to edit a todo
  const handleEdit = (todo: Todo) => {
    setTitle(todo.title);
    setEditId(todo.id);
  };

  return (
    <div style={{ padding: '20px' }}>
      <h1>Todo List</h1>
      <form onSubmit={handleSubmit}>
        <input
          type="text"
          value={title}
          onChange={(e) => setTitle(e.target.value)}
          placeholder="Enter todo title"
          required
        />
        <button type="submit">{editId !== null ? 'Update' : 'Add'}</button>
      </form>
      <ul>
        {todos.map(todo => (
          <li key={todo.id}>
          {todo.title} {" "}
            <button  onClick={() => handleEdit(todo) style={{padding:'5px 20px',margin:'10px'}}}>Edit</button>
            <button  onClick={() => handleDelete(todo.id)} style={{padding:'5px 20px'}}>Delete</button>
          </li>
        ))}
      </ul>
    </div>
  );
};

export default BasicTodo;

🔥 Refactor One useState ()

import React, { useState } from 'react';

const App = () => {
  // State to hold todos and input fields in one object
  const [state, setState] = useState({
    todos: [],
    title: '',
    editId: null,
  });

  // Function to add or update a todo
  const handleSubmit = (e) => {
    e.preventDefault();
    const { todos, title, editId } = state;

    if (editId !== null) {
      // Update existing todo
      setState({
        ...state,
        todos: todos.map(todo => (todo.id === editId ? { ...todo, title } : todo)),
        title: '',
        editId: null,
      });
    } else {
      // Add new todo
      const newTodo = { id: Date.now(), title };
      setState({
        ...state,
        todos: [...todos, newTodo],
        title: '',
      });
    }
  };

  // Function to delete a todo
  const handleDelete = (id) => {
    setState({
      ...state,
      todos: state.todos.filter(todo => todo.id !== id),
    });
  };

  // Function to edit a todo
  const handleEdit = (todo) => {
    setState({
      ...state,
      title: todo.title,
      editId: todo.id,
    });
  };

  return (
    <div style={{ padding: '20px' }}>
      <h1>Todo List</h1>
      <form onSubmit={handleSubmit}>
        <input
          type="text"
          value={state.title}
          onChange={(e) => setState({ ...state, title: e.target.value })}
          placeholder="Enter todo title"
          required
        />
        <button type="submit">{state.editId !== null ? 'Update' : 'Add'}</button>
      </form>
      <ul>
        {state.todos.map(todo => (
          <li key={todo.id}>
            {todo.title}
            <button onClick={() => handleEdit(todo)}>Edit</button>
            <button onClick={() => handleDelete(todo.id)}>Delete</button>
          </li>
        ))}
      </ul>
    </div>
  );
};

export default App;

JavaScript asked interview code

bappasaha — Thu, 14 Nov 2024 07:27:56 +0000

todo:1 [Math Random]

লুডু খেলায় আমরা কিভাবে ১ থেকে ৬ সংখ্যা randomly print করতে পারি ।

function getRandomNumber(min, max){
    return Math.floor(Math.random() *(max-min +1)) + min;
}

console.log(getRandomNumber(1,6));

// another way
const random1 =((Math.random()*10)+1);
const random2 =Math.floor(((Math.random()*7)));
console.log(random1)  // print 1-6
console.log(random2) // print 1-6

Get random id or Reverse id

const id = Math.random().toString().split(".")[1];
const id1 =crypto.randomUUID();
const revId = id.split("").reverse().join("");
const revId1 = id1.split("").reverse().join("");

console.log(id," | ",revId)  // 6024356929627508  |  8057269296534206
console.log(id1, " | ",revId1) // 83fdaf7b-ec0b-49f3-b161-0f5c78c81d41  |  14d18c87c5f0-161b-3f94-b0ce-b7fadf38


const  num =12345;
const r =Number(num.toString().split("").reverse().join(""));
console.log(num, "|||" ,r)  // 12345 ||| 54321

Reverse Sting

let str1 ="bappasaha"
const reverse =str1.split("").reverse().join("");
console.log(str1, "<->",reverse)  // bappasaha <-> ahasappab


let str ="b-a-p-p-a";
console.log(str.split("-")) ;
console.log(str.split("-").join(","));

todo:2- [sort ( ) ] সবার নাম কিভাবে Alphabetically সাজাতে পারি ।

সবার নাম কিভাবে Alphabetically সাজাতে পারি ।

const std = ["bappa","kaoa","dafda","apple"];
console.log(std.sort());

How to sort roll number low to high

const rollNumebers = [40, 100, 1, 5, 25, 10];

function myFuc(a,b){
    return a-b;
};
console.log(rollNumebers.sort(myFuc)) // [ 1, 5, 10, 25, 40, 100 ]


//shortcut
const rollNumebers = [40, 100, 1, 5, 25, 10];
console.log(rollNumebers.sort((a,b)=>{return a-b})) // assending
console.log(rollNumebers.sort((a,b)=>{return b-a})) //decending

todo: 3- [filter ( )] find the duplicate and Unique number and string from an array

find the duplicate number from an array


// const arr = ["bappa", "appa", "cappa", "bappa"];

// const item = arr.forEach((item, index, arr) => console.log("items:",item));
// const d = arr.filter((item, index) => console.log(arr.indexOf(item) !==index));
// const i = arr.filter((item, index) => console.log(arr.indexOf(index)));


const numbers =[1,2,4,5,6,6,1,5,76,,89,76,90,25];

const duplicate =numbers.filter((value,index, array)=>{
    return array.indexOf(value)!==index;
});

console.log(duplicate);


const arr = ["bappa", "appa", "cappa", "bappa"];
const duplicates = arr.filter((item, index) => arr.indexOf(item) !== index);
console.log(duplicates); // Output: ["bappa"]

find the unique number from an array

const numbers1 =[1,2,4,5,6,6,1,5,76,,89,76,90,25];

const unique =numbers.filter((value,index, array)=>{
    return array.indexOf(value)===index;
});
console.log('---');
console.log(unique);

const arr = ["bappa", "appa", "cappa", "bappa"];
const uniqueItems = arr.filter((item, index) => arr.indexOf(item) === arr.lastIndexOf(item));
console.log(uniqueItems); // Output: ["appa", "cappa"]

todo:-4 How many vowels in sentence

const vowels =["a","e","i","o","u","A","E","I","O","U"];

const countVowel=(sentence)=>{
    let count =0;
    const letters =Array.from(sentence);
    letters.forEach((letter)=>{
        if(vowels.includes(letter)){
            count++;
        }
    })
    return count;

};

console.log(countVowel("I love Bangladesh"));

todo:-5 Leap year or Not

function isLeapyear(year){
    if(year%400 ===0 || ((year %4 ===0) && (year % 100 !==0))){
        console.log(`${year} is Leap year`);
    }
    else 
        console.log('not');
};

isLeapyear(2020);

todo:-6: how many time "bappa" word is used in the sentence and what is the first position where bappa word is used?

This type of problem is solved by using regular expression

regular exp er vittore search string ta dibo
ig flag ta dibo.
jotogulo ans pabo ta ekta array tai array er length tai ans

solve:
first position mane search() ta dilei hbe

const sentence ="There is a dreamy boy nameed Bappa.There is a dreamy boy nameed bappa.There is a dreamy boy nameed bappa.There is a dreamy boy."

const matches =sentence.match(/bappa/ig);
const occurances =matches? matches.length : 0;
console.log(matches, occurances)


let position =sentence.search(/bappa/i);
position= position>=0 ? position : "not found";
console.log(position)

todo:7 input: linearSearch(['a','b','c','d','c'], 'c'); output: 2 or 'not found' ; problem: linearSearch() টি function implement করে দেখান ।

function linearSearch(arr,value){

    const length =arr.length;
    for(let i =0; i<length; i++){
        if(arr[i]===value){
            return i;
        }
    }
    return "not found";
}

console.log(linearSearch(['a','b','c','d','c'], 'c'));

todo:8- find out the max big string from an array and show the index of the string

function longestString(names){
    let longestWord ='';
    for(n of names){
        if(n.length > longestWord.length){
            longestWord =n;
        }
    }
    return [longestWord, names.indexOf(longestWord)]

}

const nameArray=['Bappa saha', 'learn with bappa','akash','akash mohajoon','dad'];

console.log(longestString(nameArray));

todo:9- ১ -১০০ পর্যন্ত যেই সংখ্যা গুলো ৩,৫ এবং ৩,৫ উভয় সংখ্যা দিয়ে বিভাজ্য তা বের কর

function fooBar(number){

    for (let i =1; i<=number; i++){
        if(i%3===0 && i%5===0){
            console.log(`${i} is fooBar number`);
        }
        else if(i%3===0){
            console.log(`${i} is divied by 3`);
        }
        else if(i%5 ===0){
            console.log(`${i} is divied by 5`)
        }
        else{
            console.log(`${i} is not  divied by 3 or 5`);
        }
    }
}

console.log(fooBar(100))

todo:10- Remove falsy values from array and object

Array থেকে কিভাবে 'falsy value' খুঁজে বের করে বাদ দিতে পারি?
```
falsy values are: 6 types
false, undefined, null, '', NaN, 0
solve: using filter()
```

const mixedArr =[
    "bws",
    undefined,
    "learn with bappa",
    0,
    false,
    "",
    "apple",
    null,
    40,
    "k",
    true,
    "Thanks all",
    NaN
];


const trueArray =mixedArr.filter(element=>{
    if(element){
        return true;
    }else{
        return false
    }
})
console.table(trueArray) 


// another way

const  trueArray1 =mixedArr.filter(Boolean)
console.table(trueArray1)

Object থেকে কিভাবে 'falsy value' খুঁজে বের করে বাদ দিতে পারি?

const obj ={

    a:"bws",
    b:undefined,
    c:"learn with bappa",
    d:0,
    e:false,
    f:"",
    g:"apple",
    h:null,
    i:40,
    j:"k",
    k:true,
    l:"Thanks all",
    m:NaN
};

const trutyObj =function(obj){
    for(let i in obj){
        if(!obj[i]){
            delete obj[i];
        }
    }
    return obj;
}

console.log(trutyObj(obj))

Open-Closed Principle (OCP)-Part-2

bappasaha — Mon, 11 Nov 2024 07:08:04 +0000

🔥02A-Open-Closed Principle (OCP)

The Open-Closed Principle (OCP) is one of the five SOLID principles of object-oriented design. It states that software entities (classes, modules, functions, etc.) should be open for extension but closed for modification. This means that you should be able to add new functionality to existing code without altering its source code.

Key Concepts

Closed for Modification:
- Existing code should not be changed when adding new features. This helps avoid introducing bugs and maintains the stability of the system.
- New features getting added to the software component should not have to modify the existing code.
Open for Extension:
- New functionalities can be added through new code, allowing the system to grow without modifying existing components.

Real-World Analogy

A practical analogy to understand OCP is the Nintendo Wii [Joy Stick] tool gaming console:

The Wii console comes with a basic controller and allows for various accessories (like the Wii Zapper and steering wheel) to be added without modifying the console itself.
This design ensures that users can enhance their gaming experience without needing to alter the core system.

Benefits of OCP

Maintainability: Reduces the risk of bugs by keeping existing code untouched.
Scalability: Facilitates easy addition of new features as requirements evolve.
Reusability: Encourages the reuse of existing modules and classes in different contexts.

Implementation Example in Java

To illustrate OCP in practice, consider a scenario where you need to compare areas of different shapes:

Without OCP

class Square {
    int height;
    int area() { return height * height; }
}

class OpenOpenExample {
    public int compareArea(Square a, Square b) {
        return a.area() - b.area();
    }
}

This approach requires modification if a new shape (like Circle) is introduced.

With OCP

By using an interface:

interface Shape {
    int area();
}

class Circle implements Shape {
    int radius;
    int area() { return (int)(Math.PI * radius * radius); }
}

class Square implements Shape {
    int height;
    int area() { return height * height; }
}

class OpenClosedExample {
    public int compareArea(Shape a, Shape b) {
        return a.area() - b.area();
    }
}

In this design, you can add new shapes without modifying existing code, adhering to the Open-Closed Principle.

Conclusion

The Open-Closed Principle encourages developers to design systems that are robust and adaptable.

By focusing on extending functionality rather than modifying existing code, developers can create more maintainable and scalable applications.

In future sessions, we will explore practical coding examples that demonstrate OCP in action.

🔥02B-ওপেন-ক্লোজড প্রিন্সিপল: কোড উদাহরণ

পরিচিতি

আমরা একটি কোড উদাহরণ দেখব যা এই নীতির বাস্তবায়নকে চিত্রিত করবে।

প্রেক্ষাপট

ধরি, One State একটি বীমা কোম্পানি যা মূলত স্বাস্থ্য বীমার সাথে জড়িত। তাদের বীমা গণনা একটি Java লাইব্রেরিতে কোড করা হয়েছে।

কোড স্নিপেট

এখানে একটি কোড স্নিপেট রয়েছে যা প্রিমিয়াম ডিসকাউন্ট ক্যালকুলেশন দেখায়:

class InsurancePremiumDiscountCalculator {
    public double calculatePremiumDiscountPercent(HealthInsuranceCustomerProfile profile) {
        if (profile.isLoyalCustomer()) {
            return 10.0; // Loyal customer discount
        }
        return 0.0; // No discount
    }
}

HealthInsuranceCustomerProfile ক্লাসে একটি isLoyalCustomer() পদ্ধতি রয়েছে যা সত্য (true) ফেরত দেয় যদি গ্রাহক একজন বিশ্বস্ত গ্রাহক হয়, অন্যথায় মিথ্যা (false) ফেরত দেয়।

নতুন চ্যালেঞ্জ

ধরি, One State কোম্পানি একটি নতুন গাড়ি বীমা কোম্পানি অধিগ্রহণ করে এবং তাদের ট্যাগলাইন পরিবর্তন করে: "আপনার স্বাস্থ্য এবং গাড়ি বীমার জন্য সবকিছু"। এখন আমাদের গাড়ি বীমার ডিসকাউন্টও সমর্থন করতে হবে।

নতুন ক্লাস যোগ করা

আমরা একটি নতুন ক্লাস যুক্ত করি: VehicleInsuranceCustomerProfile। এটি HealthInsuranceCustomerProfile এর মতো এবং এর isLoyal() পদ্ধতি রয়েছে।

class VehicleInsuranceCustomerProfile {
    public boolean isLoyal() {
        // Logic to determine loyalty
    }
}

সমস্যা

এখন আমাদের InsurancePremiumDiscountCalculator ক্লাসটি পরিবর্তন করতে হবে, কারণ এর calculate পদ্ধতি বর্তমানে শুধুমাত্র HealthInsuranceCustomerProfile অবজেক্ট গ্রহণ করে।

OCP লঙ্ঘন

নতুন বৈশিষ্ট্য যোগ করার জন্য আমাদের বিদ্যমান কোডে পরিবর্তন করতে হচ্ছে, যা ওপেন-ক্লোজড প্রিন্সিপলের বিরুদ্ধে যায়।
যদি আমরা বাড়ির বীমাও সমর্থন করতে চাই, তাহলে আবার কোড পরিবর্তন করতে হবে।

ডিজাইন পুনর্গঠন

আমরা আমাদের ডিজাইনটি পুনর্গঠন করি:

CustomerProfile নামে একটি নতুন ইন্টারফেস তৈরি করি।
এই ইন্টারফেসে একটি মাত্র পদ্ধতি থাকবে: isLoyalCustomer()।
উভয় HealthInsuranceCustomerProfile এবং VehicleInsuranceCustomerProfile ক্লাস এই সাধারণ ইন্টারফেসটি বাস্তবায়ন করবে।

interface CustomerProfile {
    boolean isLoyalCustomer();
}

class HealthInsuranceCustomerProfile implements CustomerProfile {
    public boolean isLoyalCustomer() {
        // Logic for health insurance loyalty
    }
}

class VehicleInsuranceCustomerProfile implements CustomerProfile {
    public boolean isLoyalCustomer() {
        // Logic for vehicle insurance loyalty
    }
}

নতুন ক্যালকুলেটর ক্লাস

এখন InsurancePremiumDiscountCalculator ক্লাসের পদ্ধতি পরিবর্তন করি:

class InsurancePremiumDiscountCalculator {
    public double calculatePremiumDiscountPercent(CustomerProfile profile) {
        if (profile.isLoyalCustomer()) {
            return 10.0; // Loyal customer discount
        }
        return 0.0; // No discount
    }
}

সুবিধা

এখন আমরা যদি বাড়ির বীমার জন্য একটি নতুন ক্লাস তৈরি করি, যেমন HomeInsuranceCustomerProfile, এটি শুধুমাত্র CustomerProfile ইন্টারফেসটি বাস্তবায়ন করবে।
আমাদের InsurancePremiumDiscountCalculator ক্লাসে কোনো পরিবর্তন করতে হবে না।

উপসংহার

আমরা দেখেছি কিভাবে ডিজাইন পুনর্গঠন করে ওপেন-ক্লোজড প্রিন্সিপল অনুযায়ী কাজ করা যায়। প্রথমে ডিজাইনটি OCP অনুসরণ করছিল না, কিন্তু পুনর্গঠনের মাধ্যমে এটি OCP-র সাথে সামঞ্জস্যপূর্ণ হয়ে উঠেছে।

এখন ডিজাইনটি ভবিষ্যতের এক্সটেনশনের জন্য আরও শক্তিশালী এবং কার্যকরী।

এটি ছিল ওপেন-ক্লোজড প্রিন্সিপলের একটি উদাহরণ।

🔥02C-Key Takeaways from the Open-Closed Principle Code Example

Introduction

We will summarize the key takeaways from the previous code example that illustrated the Open-Closed Principle (OCP).

Principal Benefits of the New Design

Ease of Adding New Features
- The primary benefit of adhering to the Open-Closed Principle is the ease with which new features can be added to the system.
- This ease translates into cost savings for development and testing.

Cost Savings Explained

If we do not follow OCP, adding new features often requires modifying existing code.
Each modification increases the time spent on testing and quality assurance to ensure that no new bugs are introduced into the existing codebase.
In contrast, when following OCP, testing new code is simpler and less time-consuming than running a full regression test suite on existing code.
This principle is well-known among QA testers, who emphasize its importance in maintaining software quality.

Additional Benefits

Decoupling of Components
- By redesigning our system to conform to OCP, we inadvertently achieved a higher degree of loose coupling between components.
- This decoupling aligns with the Single Responsibility Principle (SRP), as each component now has a clearer purpose and responsibility.

Interconnectedness of SOLID Principles

It is crucial to understand that the SOLID principles are intertwined and interdependent.
They are most effective when applied together, providing a holistic approach to software design.

Cautionary Note

Do Not Follow OCP Blindly:
- While OCP is beneficial, blindly applying it can lead to an excessive number of classes, complicating your overall design.
- For instance, if you need to fix a bug and believe that modifying existing code is necessary for an effective fix, do so without hesitation.
- Avoid overhauling your design solely for bug fixes unless you notice recurring issues that could be mitigated by a redesign.

Subjective Application of OCP

Deciding when and where to apply the Open-Closed Principle is subjective rather than objective.
Use your judgment based on the specific context of your project.

Conclusion

Re-designed code to make it follow OCP
Following OCP can lead to cost benifits in the long run.
OPC and SRP can work together to achieve a better design.
Do not apply the OCPblindly and introduce unwanted complexity to your code.

The lessons learned from our code example related to the Open-Closed Principle. Understanding these key takeaways will help you apply OCP effectively in your future designs.

Single Responsibility Principle-Part-1

bappasaha — Sun, 10 Nov 2024 17:02:27 +0000

🔥A1-Single Responsibility Principle (SRP) - Overview

SOLID এর 'S' হল Single Responsibility Principle, যা সাধারণত SRP নামে পরিচিত।

SRP কি?

Single Responsibility Principle বলছে যে 'প্রতিটি সফটওয়্যার উপাদানের একটি এবং শুধুমাত্র একটি দায়িত্ব থাকা উচিত'। [component should have one and only one responsibility']

[component should have one and only one (responsibility) reason to change]

যখন আমরা সফটওয়্যার উপাদান বলি, তখন যদি আমরা একটি অবজেক্ট-অরিয়েন্টেড প্রোগ্রামিং ভাষা যেমন C++ এর প্রসঙ্গে কথা বলি, তবে আমাদের প্রথম মনে পড়ে একটি C++ ক্লাস।

কিন্তু এটি লক্ষ্য করা গুরুত্বপূর্ণ যে সফটওয়্যার উপাদানের ধারণাটি একটি পদ্ধতি, ফাংশন বা এমনকি একটি মডিউলকেও নির্দেশ করতে পারে। তাই নিয়মটি বলছে যে একটি সফটওয়্যার উপাদানের শুধুমাত্র একটি দায়িত্ব থাকা উচিত।

উদাহরণ

আমাদের কাছে একটি ছবি আছে যা এটি ব্যাখ্যা করতে সাহায্য করবে। এটি একটি Swiss Army Knife। আপনি জানেন, একটি Swiss Army Knife বিভিন্ন কার্যকরী সরঞ্জামের সমন্বয়, প্রতিটি একটির আলাদা উদ্দেশ্য রয়েছে। এতে আপনি ক্যান ওপেনার থেকে শুরু করে মিনি কাঁচি বা স্ক্রু ড্রাইভার পর্যন্ত কিছু পেতে পারেন।

যদিও Swiss Army Knife একটি বহুমুখী সরঞ্জাম এবং খুব চাহিদাসম্পন্ন, সফটওয়্যারের ক্ষেত্রে নিয়মগুলি পরিবর্তিত হয়। যদি আপনি Swiss Army Knife কে একটি সফটওয়্যার উপাদান হিসেবে ভাবেন, তবে এটি Single Responsibility Principle লঙ্ঘন করে কারণ এতে একাধিক দায়িত্ব রয়েছে।

What does SRP recommend?

SRP সুপারিশ করে যে আমাদের কাছে এমন একটি ছুরি থাকা উচিত যার একমাত্র দায়িত্ব কাটার কাজ করা। এটি ক্যান ওপেনার বা স্ক্রু ড্রাইভার হিসেবে ব্যবহার করা যাবে না; এটি শুধুমাত্র কাটার জন্য ব্যবহৃত হবে।

🔥A2-Single Responsibility Principle (SRP) - Detailed Overview

পরিচিতি

Here Single Responsibility Principle (SRP) এই নীতিটি কিভাবে তৈরি হয়েছে তা নিয়ে বিস্তারিত আলোচনা করব।

Square ক্লাসের উদাহরণ

দেখুন, এখানে একটি ক্লাস আছে যার নাম Square। এতে ৪টি মেথড রয়েছে: calculateArea(), calculatePerimeter(), draw(), এবং rotate()।

calculateArea এবং calculatePerimeter ফাংশনগুলি সঠিকভাবে কাজ করে, অর্থাৎ তারা একটি বর্গের পাশে দেওয়া দৈর্ঘ্য অনুযায়ী এর এলাকা এবং পরিধি গণনা করে।
draw() ফাংশনটি স্কোয়ারের চিত্রটি প্রদর্শনে রেন্ডার করে এবং এটি ব্যবহৃত ডিসপ্লের ধরন অনুযায়ী বিভিন্ন কোড প্রবাহ রয়েছে।
rotate() ফাংশনটি স্কোয়ারের চিত্রটি ঘুরিয়ে দেয় এবং এটি আবার ডিসপ্লেতে রেন্ডার করে।

Cohesion কি?

এই কোড স্নিপেটের প্রসঙ্গে, আমরা একটি নতুন ধারণা শিখব যার নাম Cohesion। সফটওয়্যার জগতে, কোহেশন হল বিভিন্ন অংশের মধ্যে সম্পর্কের ডিগ্রি।

উদাহরণ:

একটি অগোছালো আবর্জনার কৌটো দেখুন। এখানে বিভিন্ন ধরনের জিনিস রয়েছে যেমন প্লাস্টিকের ক্যান, বিয়ারের বোতল, কাগজের বর্জ্য ইত্যাদি। এগুলোর মধ্যে সম্পর্ক খুঁজে পাওয়া কঠিন।

কিন্তু যখন এগুলো আলাদা করা হয়, তখন একটি হলুদ বিনে প্লাস্টিকের বোতলগুলি দেখা যায়। যদিও বোতলগুলি একরকম নয়, তবে তাদের মধ্যে একটি সাধারণ সম্পর্ক রয়েছে: তারা সব প্লাস্টিকের তৈরি।

Cohesion এর সংজ্ঞা অনুযায়ী, অগোছালো আবর্জনার কৌটোর বিষয়বস্তুতে কম কোহেশন রয়েছে, এবং প্রতিটি আলাদা আবর্জনার কৌটোর বিষয়বস্তুতে উচ্চ কোহেশন রয়েছে।

Square ক্লাসে কোহেশন

Square ক্লাসের মেথডগুলোর দিকে তাকালে:

calculateArea এবং calculatePerimeter মেথডগুলি একে অপরের সাথে ঘনিষ্ঠভাবে সম্পর্কিত, কারণ তারা বর্গের পরিমাপ নিয়ে কাজ করে। তাই তাদের মধ্যে উচ্চ কোহেশন রয়েছে।
draw() এবং rotate() মেথডগুলি স্কোয়ারের চিত্র রেন্ডারিং নিয়ে কাজ করে, তাই তাদের মধ্যে উচ্চ কোহেশন রয়েছে।

কিন্তু যদি আপনি সমস্ত মেথডকে একসাথে বিবেচনা করেন, তবে কোহেশনের স্তর কম। উদাহরণস্বরূপ, calculatePerimeter() মেথডটি draw() মেথডের সাথে ঘনিষ্ঠভাবে সম্পর্কিত নয় কারণ তারা সম্পূর্ণ ভিন্ন দায়িত্ব নিয়ে কাজ করে।

সমাধান

এখন আমি কিছু পরিবর্তন করব যাতে কোহেশনের স্তর বাড়ানো যায়। আমি draw এবং rotate মেথডগুলিকে একটি আলাদা ক্লাসে স্থানান্তর করব, যার নাম হবে SquareUI।

এভাবে, যদিও আমি মেথডগুলোকে দুইটি ক্লাসে ভাগ করেছি, আমি প্রতিটি ক্লাসে কোহেশনের স্তর বাড়িয়েছি।

Square ক্লাসে এখন দুটি মেথড ঘনিষ্ঠভাবে সম্পর্কিত, কারণ তারা বর্গের পরিমাপ নিয়ে কাজ করে।
SquareUI ক্লাসে দুটি মেথডও ঘনিষ্ঠভাবে সম্পর্কিত, কারণ তারা বর্গের গ্রাফিক রেন্ডারিং নিয়ে কাজ করে।

Coupling কি?

Coupling হল বিভিন্ন সফটওয়্যার উপাদানের মধ্যে আন্তঃনির্ভরতায় স্তর। [Coupling is defined as the level of inter dependency between various software components.]

Loose Coupling helps attain better adherence to the single responsibility principle

Student ক্লাস উদাহরণ

এখন আমরা একটি Student ক্লাস দেখি। এর মধ্যে একটি মেথড হল save() যা ছাত্র ক্লাসকে সিরিয়ালাইজড ফর্মে রূপান্তরিত করে এবং ডাটাবেসে সংরক্ষণ করে।

যদি আপনি ভবিষ্যতে MySQL থেকে MongoDB তে চলে যান, তবে বেশিরভাগ কোড পরিবর্তন করতে হবে। তাই Student ক্লাসটি ডাটাবেস স্তরের সাথে শক্তভাবে যুক্ত।

সমাধান

আমরা ডাটাবেস সম্পর্কিত কোডটিকে একটি নতুন Repository ক্লাসে স্থানান্তর করব।

এভাবে আমরা শক্ত সংযোগ অপসারণ করেছি এবং এটিকে দুর্বল করেছি। এখন যদি আমরা অন্তর্নিহিত ডাটাবেস পরিবর্তন করি, Student ক্লাসটি পরিবর্তন বা পুনঃসংকলনের প্রয়োজন নেই; শুধুমাত্র Repository ক্লাস পরিবর্তন করতে হবে।

উপসংহার

আমরা দুটি ধারণা দেখেছি - Cohesion এবং Coupling।

আমরা দেখেছি যে Low Chohesion is Bad
Single Responsibility Principle সর্বদা High Cohesion সমর্থন করে।
আমরা দেখেছি যে শক্ত সংযোগ খারাপ।
Single Responsibility Principle সর্বদা Loose Cupling সুপারিশ করে।

সুতরাং সর্বদা উচ্চ কোহেশন [High Cohesion] এবং দুর্বল সংযোগের [Loose Cupling] দিকে লক্ষ্য রাখুন। when ever we working on SRP

🔥A3-Single Responsibility Principle (SRP) - Modified Definition

পরিচিতি

আমরা সংজ্ঞাটির একটি নতুন দৃষ্টিভঙ্গি দেখব।

নতুন সংজ্ঞা

মূল নীতি বলে: 'প্রতিটি সফটওয়্যার উপাদানের একটি এবং শুধুমাত্র একটি দায়িত্ব থাকা উচিত'।
এখন আমরা 'দায়িত্ব' শব্দটির পরিবর্তে 'পরিবর্তনের কারণ' (reason to change) শব্দটি ব্যবহার করব।

তাহলে নতুন সংজ্ঞা হবে: 'প্রতিটি সফটওয়্যার উপাদানের একটি এবং শুধুমাত্র একটি পরিবর্তনের কারণ থাকা উচিত'।

[component should have one and only one reason to change]

পরিবর্তনের কারণ কি?

In the words of the Greek Philosopher - Heraclitus . "The only thing that is constant is change"
it always keeps changing in Software industry

উদাহরণ

আমরা পূর্ববর্তী সেশনের Student ক্লাসটি ব্যবহার করব। ধরুন এই ক্লাসটি একটি সফটওয়্যার মডিউলের অংশ যা ইতিমধ্যে উৎপাদনে রয়েছে।

পরিবর্তনের সম্ভাব্য কারণ:

ছাত্র আইডির ফরম্যাটে পরিবর্তন
ছাত্র নামের ফরম্যাটে পরিবর্তন
প্রযুক্তিগত দলের পরামর্শ অনুযায়ী ডাটাবেস ব্যাকএন্ডে পরিবর্তন

আমরা তিনটি পরিবর্তনের কারণ চিহ্নিত করেছি।

SRP এর সমস্যা

যদি একটি সফটওয়্যার উপাদানে একাধিক পরিবর্তনের কারণ থাকে, তবে তার পরিবর্তনের ফ্রিকোয়েন্সি বাড়বে। প্রতিটি পরিবর্তন বাগ প্রবেশের সম্ভাবনা বাড়ায়, যা পুনঃপরীক্ষণের জন্য সময় এবং অর্থ ব্যয় করে।

সমাধান

আমরা পূর্ববর্তী যে পদক্ষেপ নিয়েছিলাম, তা আবার গ্রহণ করব। ডাটাবেস অপারেশনগুলি আলাদা Repository ক্লাসে স্থানান্তর করব।

ক্লাস বিভাজন:

Student ক্লাস: ২টি পরিবর্তনের কারণ থাকবে।
Repository ক্লাস: ১টি পরিবর্তনের কারণ থাকবে।

যদিও Student ক্লাসে ২টি কারণে সমস্যা রয়েছে, তবে যদি তারা ঘনিষ্ঠভাবে সম্পর্কিত হয়, তবে তাদের একত্রিত করা যেতে পারে। উদাহরণস্বরূপ, "ছাত্রের প্রোফাইলে পরিবর্তন" বলা যেতে পারে।

©️ Bappa Saha Bapi

Docker Cheetsheet

bappasaha — Fri, 18 Oct 2024 08:03:28 +0000

Docker Cheat Sheet

Getting Started with Docker

Check Docker Installation:
```
docker --version
```

Basic Commands

Pull an Image from Docker Hub:

docker pull <image-name>

Example:

docker pull ubuntu

List Available Images:
```
docker images
```

Run a Container:

docker run -it <image-name>

Example:

docker run -it ubuntu

Run a Container in Detached Mode:
```
docker run -d <image-name>
```
Stop a Running Container:
```
docker stop <container-id>
```
Start a Stopped Container:
```
docker start <container-id>
```
Remove a Stopped Container:
```
docker rm <container-id>
```
Remove an Image:
```
docker rmi <image-name>
```

Managing Containers

List Running Containers:
```
docker ps
```
List All Containers (including stopped):
```
docker ps -a
```
View Container Logs:
```
docker logs <container-id>
```

Execute a Command in a Running Container:

docker exec -it <container-id> <command>

Example:

docker exec -it <container-id> bash

Inspect a Container:
```
docker inspect <container-id>
```

Networking

List Docker Networks:
```
docker network ls
```
Create a New Network:
```
docker network create <network-name>
```

Connect a Container to a Network:

docker network connect <network-name> <container-id>

Disconnect a Container from a Network:

docker network disconnect <network-name> <container-id>

Volumes and Data Management

Create a Volume:
```
docker volume create <volume-name>
```
List Volumes:
```
docker volume ls
```
Remove a Volume:
```
docker volume rm <volume-name>
```

Mount a Volume to a Container:

docker run -v <volume-name>:<container-path> <image-name>

Dockerfile and Building Images

Create a Dockerfile:
Basic structure:

FROM <base-image>
MAINTAINER <your-name>
COPY <source> <destination>
RUN <command>
CMD ["<executable>"]

Build an Image from a Dockerfile:

docker build -t <image-name>:<tag> .

Example:

docker build -t myapp:latest .

List Built Images:
```
docker images
```

Advanced Commands

Tag an Image:

docker tag <image-id> <new-image-name>:<tag>

Push an Image to Docker Hub:
```
docker push <image-name>:<tag>
```

Save an Image to a Tar File:

docker save -o <path-to-output-file> <image-name>

Load an Image from a Tar File:
```
docker load -i <path-to-input-file>
```
Docker Compose:
- Start Services:
```
docker-compose up
```

- **Stop Services**:

    ```bash
    docker-compose down

    ```

Scale Services:

docker-compose up --scale <service-name>=<number>

View Running Docker Compose Services:
```
docker-compose ps
```

Useful Docker Commands

Remove All Stopped Containers:
```
docker container prune
```
Remove Unused Images:
```
docker image prune
```
Remove All Unused Data (containers, networks, images):
```
docker system prune
```
Get Docker System Information:
```
docker info
```

LinkedList in JavaScript

bappasaha — Sat, 05 Oct 2024 04:02:43 +0000

🔥00- Linked List in JavaScript

How to Create Node
Create Linked List
Performed Push( ), | O(1) | add node at the end
Performed Pop( ), | O(n) | remove Node at the end
Performed Unshift( ), | O(1) | add Node at the start
Performed shift( ), | O(1) | remove Node at the start
Performed get| set
Performed Insert **| **Remove at any Node and Reverse Linked List

🔥01- Linked List এবং Array
<br>

🔥01- Linked List এবং Array

এটি আমাদের প্রথম ডেটা স্ট্রাকচার যা আমরা তৈরি করতে যাচ্ছি, যা কিছুটা important. লিঙ্কড লিস্টগুলি পরিচয় করানোর জন্য, আমি এটি সেই ডেটা স্ট্রাকচারের সাথে তুলনা করব যা এটি সবচেয়ে বেশি তুলনা করা হয়, এবং তা হল অ্যারে।

অ্যারের বৈশিষ্ট্য

index: অ্যারেগুলির একটি index থাকে, যা প্রতিটি উপাদানকে চিহ্নিত করে।
মেমরিতে অবস্থান: অ্যারে উপাদানগুলি ধারাবাহিকভাবে মেমরিতে সংরক্ষিত হয়।

লিঙ্কড লিস্টের বৈশিষ্ট্য

index: লিঙ্কড লিস্টগুলির কোনও সূচক নেই।
মেমরিতে অবস্থান: লিঙ্কড লিস্টের উপাদানগুলি মেমরিতে যেকোনো জায়গায় থাকতে পারে এবং এটি ধারাবাহিক নয়।

গ্রাফিকাল উপস্থাপন

লিঙ্কড লিস্টের উপাদানগুলিকে গ্রাফিক্যালভাবে উপস্থাপন করার জন্য, আমরা সবুজ বর্গক্ষেত্রের পরিবর্তে বেগুনি বৃত্ত ব্যবহার করব।
🔂 🔂 🔂

Head and Tail: লিঙ্কড লিস্টে একটি ভেরিয়েবল থাকে যাকে "হেড" বলা হয়, যা প্রথম আইটেমকে নির্দেশ করে, এবং একটি "টেইল" থাকে, যা শেষ আইটেমকে নির্দেশ করে।
লিঙ্ক: প্রতিটি আইটেম পরবর্তী আইটেমের দিকে নির্দেশ করে, এবং শেষ আইটেমটি null এর দিকে নির্দেশ করে। তাই আপনি "null terminated list" শব্দটি শুনতে পাবেন।

সারসংক্ষেপ

অ্যারেগুলি ধারাবাহিকভাবে মেমরিতে সংরক্ষিত হয়, যেখানে লিঙ্কড লিস্টগুলি যেকোনো স্থানে থাকতে পারে। এই তুলনার মাধ্যমে আমরা লিঙ্কড লিস্ট এবং অ্যারের মধ্যে মৌলিক পার্থক্যগুলি বুঝতে পারি।

🔥02- লিঙ্কড লিস্ট এবং বিগ ও (Big O)
<br>

🔥02- লিঙ্কড লিস্ট এবং বিগ ও (Big O)

এটি আমাদের প্রথম ডেটা স্ট্রাকচার যা আমরা তৈরি করতে যাচ্ছি, এই সেকশনে, আমরা লিঙ্কড লিস্টের বিভিন্ন অপারেশনের জন্য বিগ ও বিশ্লেষণ করব।

✅ লিঙ্কড লিস্টে নোড যোগ করা

ধরি, আমাদের একটি লিঙ্কড লিস্ট আছে এবং আমরা একটি নতুন নোড (৪) যোগ করতে যাচ্ছি।

নতুন নোড যোগ করা:
- নতুন নোডটি শেষের দিকে যুক্ত করতে হলে, আমাদের শেষ নোডটি (tail) নতুন নোডের দিকে নির্দেশ করতে হবে।
- এটি করার জন্য, আমরা tail কে নতুন নোডের দিকে নির্দেশিত করি।
- এটি একটি ধ্রুবক সময় (O(1))।

✅ লিঙ্কড লিস্ট থেকে নোড মুছে ফেলা

শেষ থেকে মুছে ফেলা:
- শেষ নোডটি মুছে ফেলতে হলে, আমাদের শেষের দিকে (tail) যাওয়ার জন্য পুরো লিস্টটি পার হতে হবে।
- তাই, এটি O(n)।

শুরু থেকে নোড যোগ করা

শুরুর দিকে যোগ করা:
- নতুন নোডটি যুক্ত করতে হলে, হেডকে নতুন নোডের দিকে নির্দেশ করতে হবে।
- এটি O(1)।

শুরু থেকে নোড মুছে ফেলা

শুরু থেকে মুছে ফেলা:
- হেডকে পরবর্তী নোডের দিকে নির্দেশ করতে হবে।
- এটি O(1)।

মধ্যবর্তী অবস্থানে ইনসার্ট করা

মধ্যবর্তী অবস্থানে ইনসার্ট করা:
- একটি নির্দিষ্ট ইনডেক্সে ইনসার্ট করার জন্য, আমাদের হেড থেকে শুরু করে পুরো লিস্টটি পার হতে হবে।
- তাই, এটি O(n)।

মধ্যবর্তী অবস্থানে আইটেম মুছে ফেলা

মধ্যবর্তী অবস্থানে মুছে ফেলা:
- একইভাবে, একটি নির্দিষ্ট ইনডেক্সে আইটেম মুছে ফেলতে হলে, পুরো লিস্টটি পার হতে হবে।
- তাই, এটি O(n)।

আইটেম খোঁজা

মান দ্বারা খোঁজা:
- যদি আমরা মান দ্বারা খুঁজতে চাই, তাহলে হেড থেকে শুরু করে পুরো লিস্টটি পার হতে হবে।
- এটি O(n)।
ইনডেক্স দ্বারা খোঁজা:
- ইনডেক্স দ্বারা খুঁজতে হলে, আবারও হেড থেকে শুরু করে পুরো লিস্টটি পার হতে হবে।
- তাই, এটি O(n)।
Push Pop works in Tail part add or remove
unshift works in the Head part add or remove

অ্যারে এবং লিঙ্কড লিস্টের তুলনা

অপারেশন	অ্যারে (Array)	লিঙ্কড লিস্ট (Linked List)
শেষ থেকে POP করা	O(1)	O(n)
ইনডেক্স দ্বারা খোঁজা	O(1)	O(n)
শুরুতে যোগ করা	O(n)	O(1)
শুরুতে মুছে ফেলা	O(n)	O(1)
মধ্যবর্তী অবস্থানে যোগ করা	O(n)	O(n)
মধ্যবর্তী অবস্থানে মুছে ফেলা	O(n)	O(n)

এটি একটি দ্রুত পর্যালোচনা ছিল যে কিভাবে লিঙ্কড লিস্ট এবং অ্যারে বিভিন্ন অপারেশনের জন্য বিগ ও বিশ্লেষণে ভিন্ন।

let myLinkedList = new LinkedList(23); // প্রথম নোডের মান 23 দিয়ে লিঙ্কড লিস্ট তৈরি করে
myLinkedList.push(7); // শেষে 7 যোগ করে  | O(1)
myLinkedList.unshift(3); // শুরুতে 3 যোগ করে
myLinkedList.insertAt(1, 11); // সূচক 1 এ 11 সন্নিবেশ করে
myLinkedList.remove(1); // সূচক 1 থেকে আইটেম অপসারণ করে (11)

class LinkedList {
  constructor(value) {
    this.head = { value: value, next: null }; // হেড নোড শুরু করা
    this.length = 1; // দৈর্ঘ্য ট্র্যাক করা
  }

  push(value) {
    // শেষের দিকে নতুন নোড যোগ করার মেথড
  }

  unshift(value) {
    // শুরুতে নতুন নোড যোগ করার মেথড
  }

  insertAt(index, value) {
    // নির্দিষ্ট সূচকে একটি নোড সন্নিবেশ করার মেথড
  }

  remove(index) {
    // নির্দিষ্ট সূচক থেকে একটি নোড অপসারণ করার মেথড
  }

  pop() {
    // শেষ নোড অপসারণ করার মেথড
  }

  shift() {
    // প্রথম নোড অপসারণ করার মেথড
  }
}

🔥03- লিঙ্কড লিস্টের অন্তর্নিহিত গঠন
<br>

🔥03- লিঙ্কড লিস্টের Internal Structure

এখন আমরা লিঙ্কড লিস্টের অন্তর্নিহিত গঠন নিয়ে আলোচনা করব। আসুন দেখি এটি আসলে কীভাবে তৈরি হয়।

নোডের গঠন

লিঙ্কড লিস্টের প্রতিটি উপাদানকে নোড বলা হয়। একটি নোডে দুটি প্রধান উপাদান থাকে:

মান (Value): এটি নোডের মূল তথ্য।
পয়েন্টার (Pointer): এটি পরবর্তী নোডের ঠিকানাকে নির্দেশ করে।

একটি নোডের গঠন নিচের মতো হতে পারে:

{
    value: 7,
    next: 
}

লিঙ্কড লিস্টে নোড যোগ করা

যখন আমরা একটি নতুন নোড (যেমন ৪) যোগ করি, তখন আমাদের প্রথমে নিশ্চিত করতে হবে যে পূর্ববর্তী নোড (যেমন ৭) নতুন নোডের দিকে নির্দেশ করে। এটি করার জন্য, আমরা ৭ এর next পয়েন্টারকে নতুন নোডের ঠিকানায় সেট করি।

node7.next = node4; // ৭ নোডটি ৪ নোডের দিকে নির্দেশ করে

এখন, tail পয়েন্টারটিও নতুন নোড (৪) এর দিকে নির্দেশ করবে।

হেড এবং টেইল

হেড (Head): এটি প্রথম নোডকে নির্দেশ করে।
টেইল (Tail): এটি শেষ নোডকে নির্দেশ করে এবং এটি সর্বদা শেষের দিকে নির্দেশিত থাকে।

গ্রাফিক্যাল উপস্থাপন

লিঙ্কড লিস্টকে গ্রাফিক্যালভাবে উপস্থাপন করতে, আমরা সাধারণত একটি ডায়াগ্রাম ব্যবহার করি যেখানে প্রতিটি নোড একটি বৃত্তে চিত্রিত হয় এবং পয়েন্টারগুলি তীর দ্বারা চিহ্নিত করা হয়।

উদাহরণ

নিচে একটি উদাহরণ দেওয়া হল যেখানে আমরা একটি লিঙ্কড লিস্ট তৈরি করছি:

class Node {
  constructor(value) {
    this.value = value;
    this.next = null; // পরবর্তী নোডের জন্য পয়েন্টার
  }
}

class LinkedList {
  constructor() {
    this.head = null; // প্রথম নোড
    this.tail = null; // শেষ নোড
  }

  add(value) {
    const newNode = new Node(value);
    if (!this.head) {
      this.head = newNode;
      this.tail = newNode;
    } else {
      this.tail.next = newNode; // শেষ নোডের পরবর্তী পয়েন্টার সেট করা
      this.tail = newNode; // টেইল আপডেট করা
    }
  }
}

উপসংহার

লিঙ্কড লিস্ট হল একটি ডাইনামিক ডেটা স্ট্রাকচার যা বিভিন্ন ধরনের অপারেশন সম্পাদনের জন্য খুবই কার্যকর। প্রতিটি নোডে তথ্য এবং পরবর্তী নোডের ঠিকানা থাকে, যা আমাদেরকে সহজেই নতুন উপাদান যুক্ত করতে এবং মুছে ফেলতে দেয়। এই গঠনটি আমাদেরকে মেমরি ব্যবস্থাপনায় নমনীয়তা প্রদান করে।

এবং এটিই ছিল আমাদের লিঙ্কেড লিস্টের অন্তর্নিহিত গঠন নিয়ে আলোচনা।

🔥04- লিঙ্কড লিস্টের Constructor
<br>

🔥04- লিঙ্কড লিস্টের Constructor

এখন আমরা আমাদের লিঙ্কড লিস্টের জন্য কনস্ট্রাক্টর তৈরি করতে যাচ্ছি। আসুন শুরু করি।

লিঙ্কড লিস্ট ক্লাস তৈরি করা

প্রথমে, আমরা আমাদের লিঙ্কড লিস্ট ক্লাসটি তৈরি করব। কনস্ট্রাক্টরের কোড লেখার আগে, আমি কিছু বিষয় উল্লেখ করতে চাই।

কনস্ট্রাক্টরের সাধারণ বৈশিষ্ট্য

কনস্ট্রাক্টরের কিছু সাধারণ বৈশিষ্ট্য রয়েছে যা অন্যান্য পদ্ধতিগুলির সাথে মিল রয়েছে, যেমন:

Push: নতুন নোড তৈরি করে এবং সেটিকে শেষের দিকে যুক্ত করে।
Unshift: নতুন নোড তৈরি করে এবং সেটিকে শুরুতে যুক্ত করে।
Insert: নতুন নোড তৈরি করে এবং সেটিকে নির্দিষ্ট স্থানে সন্নিবেশ করে।

class LinkdList {
    constructor(value){
        // create new Node;

    }
    push(value){
        // create new Node
        add Node to end

    }
    unshift(value){
        // create new Node
        add Node to begining
    }
    insert (index, value){
        // create new Node
        add Node to begining
    }

সবগুলো পদ্ধতি নতুন নোড তৈরি করে, তাই আমরা একটি আলাদা ক্লাস তৈরি করব যাকে আমরা Node বলব। প্রতিটি পদ্ধতি যখন একটি নোড তৈরি করতে হবে, তখন এটি এই ক্লাসটি কল করবে।

✅নোড ক্লাস Constructor

নোড ক্লাসের গঠন নিচের মতো হবে:

class Node {
  constructor(value) {
    this.value = value; // নোডের মান
    this.next = null; // পরবর্তী নোডের জন্য পয়েন্টার
  }
}

// node class
class MyNode {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

const newNode_4 = new MyNode(4); //{value:4, next:null}

✅ লিঙ্কড লিস্ট Constructor

এখন আসুন আমাদের লিঙ্কড লিস্টের কনস্ট্রাক্টর তৈরি করি:

class LinkedList {
  constructor(value) {
    const newNode = new Node(value); // নতুন নোড তৈরি করা
    this.head = newNode; // হেডকে নতুন নোডের দিকে নির্দেশ করা
    this.tail = newNode; // টেইলকে একই নোডের দিকে নির্দেশ করা
    this.length = 1; // দৈর্ঘ্য ১ সেট করা
  }
}

নতুন লিঙ্কড লিস্ট তৈরি করা

নতুন লিঙ্কড লিস্ট তৈরি করতে, আপনি নিচের কোডটি ব্যবহার করবেন:

const myLinkedList = new LinkedList(4); // ৪ মান সহ একটি নতুন লিঙ্কড লিস্ট তৈরি করা

ডেভটুলসে পরীক্ষা করা

এখন আসুন ডেভটুলসে কোডটি পরীক্ষা করি।

প্রথমে, আমরা new LinkedList(4) কল করি।
এটি একটি নতুন নোড তৈরি করবে যার মান ৪ এবং এটি হেড ও টেইল উভয়কেই নির্দেশ করবে।
যদি আমরা myLinkedList লিখি এবং এন্টার চাপি, তাহলে দেখতে পাব যে আমাদের একটি কাজ করছে এমন লিঙ্কেড লিস্ট আছে।

ফলাফল

LinkedList {
    head: Node { value: 4, next: null },
    tail: Node { value: 4, next: null },
    length: 1
}

এটি দেখায় যে হেড এবং টেইল উভয়ই একই অবজেক্টকে নির্দেশ করছে এবং দৈর্ঘ্য ১।

এবং এইভাবে আমাদের একটি কার্যকরী লিঙ্কেড লিস্ট তৈরি হয়েছে!

Full Code 02-LL-Structure.js

class CreateNode {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

class LinkdList {
  constructor(value) {
    const newNode = new CreateNode(value);
    this.head = newNode;
    this.tail = this.head;
    this.length = 1;
  }
}

let LL1 = new LinkdList(4);

/*  outPut:
LinkdList {
  head: CreateNode { value: 4, next: null },
  tail: CreateNode { value: 4, next: null },
  length: 1
}

*/

🔥05- লিঙ্কড লিস্টের পুশ (Push) মেথড
<br>

🔥05- লিঙ্কড লিস্টের পুশ (Push) মেথড

এখন আমরা আমাদের লিঙ্কড লিস্টের জন্য পুশ (Push) মেথড তৈরি করব। আসুন প্রথমে পদক্ষেপগুলো দেখে নেওয়া যাক।

পুশ মেথডের পদক্ষেপ

নতুন নোড তৈরি করা: প্রথমে আমাদের একটি নতুন নোড তৈরি করতে হবে।
লাস্ট নোডের পয়েন্টার সেট করা: তারপর, শেষ নোডটি নতুন নোডের দিকে নির্দেশ করবে।
টেইল পয়েন্টার আপডেট করা: টেইল পয়েন্টারটিও নতুন নোডের দিকে নির্দেশ করবে।

corner case

আমাদের একটি এজ কেসও বিবেচনা করতে হবে, যা হল যদি আমরা একটি লিঙ্কড লিস্টে নোড যুক্ত করি যা এখনও খালি। এই ক্ষেত্রে, আমাদের হেড এবং টেইল উভয়ই নতুন নোডের দিকে নির্দেশ করবে।

কোড লেখা

এখন আসুন কোডে প্রবেশ করি এবং পুশ মেথডটি তৈরি করি:

push(value) {
    const newNode = new Node(value); // নতুন নোড তৈরি করা

    // যদি হেড খালি হয়
    if (!this.head) {
        this.head = newNode; // হেডকে নতুন নোডের দিকে নির্দেশ করা
        this.tail = newNode; // টেইলকেও নতুন নোডের দিকে নির্দেশ করা
    } else {
        this.tail.next = newNode; // শেষ নোডের পরবর্তী পয়েন্টারকে নতুন নোডের দিকে নির্দেশ করা
        this.tail = newNode; // টেইলকে নতুন নোডের দিকে নির্দেশ করা
    }

    this.length++; // দৈর্ঘ্য ১ বাড়ানো
    return this; // পুরো লিঙ্কড লিস্ট ফেরত দেওয়া
}

কোড বিশ্লেষণ

নতুন নোড তৈরি: const newNode = new Node(value); এই লাইনে আমরা একটি নতুন নোড তৈরি করছি।
হেড চেক: if (!this.head) এই শর্তটি পরীক্ষা করে যে হেড খালি কি না। যদি খালি হয়, তাহলে হেড এবং টেইল উভয়ই নতুন নোডের দিকে নির্দেশ করে।
নতুন নোড যুক্ত করা: যদি হেড খালি না হয়, তাহলে শেষ নোডের পরবর্তী পয়েন্টারকে নতুন নোডের দিকে নির্দেশ করি এবং টেইল আপডেট করি।
দৈর্ঘ্য বাড়ানো: this.length++ মাধ্যমে আমরা লিঙ্কেড লিস্টের দৈর্ঘ্য বাড়াচ্ছি।
ফিরিয়ে দেওয়া: return this; পুরো লিঙ্কেড লিস্ট ফেরত দেয়।

ডেভটুলসে পরীক্ষা করা

এখন আসুন ডেভটুলসে কোডটি পরীক্ষা করি:

let myLinkedList = new LinkedList(7); // ৭ মান সহ একটি নতুন লিঙ্কেড লিস্ট তৈরি করা
myLinkedList.push(4); // ৪ মান যুক্ত করা

যখন আমরা myLinkedList.push(4) কল করি, এটি পুরো লিঙ্কেড লিস্ট ফেরত দেবে।
আমরা দেখতে পাব যে হেড ৭ নোডকে নির্দেশ করছে এবং টেইল ৪ নোডকে নির্দেশ করছে। দৈর্ঘ্য ২।

ফলাফল

LinkedList {
    head: Node { value: 7, next: Node { value: 4, next: null } },
    tail: Node { value: 4, next: null },
    length: 2
}

🔲 Full Code

/* 
    🌟 Create a new node 
    🌟if it is first clild or head === null
        assign head pointer to the new Node
        assign tail pointer to the newNode
    🌟 else
        tail.next = newNode e point koray dibo
        tail=newNode kore dibo
    lenght =lenght+1;
    return this --&gt; this represents the global object

*/

class CreateNode {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

class LL {
  constructor(value) {
    const newNode = new CreateNode(value);
    this.head = newNode;
    this.tail = newNode;
    this.length = 1;
  }

  // push or add node at the end
  push(value) {
    const newNode = new CreateNode(value);
    if (this.head === null) {
      this.head = newNode;
      this.tail = newNode;
    } else {
      this.tail.next = newNode;
      this.tail = newNode;
    }
    this.length++;
    return this;
  }
}

let myLL = new LL(null);
myLL.push(4);
myLL.push(4);
console.log(myLL);

এবং এইভাবে আমাদের পুশ মেথড কার্যকরী হয়েছে!

🔥06- লিঙ্কড লিস্টের পপ (Pop) মেথড
<br>

🔥06- লিঙ্কড লিস্টের পপ (Pop) মেথড

এখন আমরা আমাদের লিঙ্কড লিস্টের জন্য পপ (Pop) মেথড তৈরি করব।

🌟 পপ মেথডের পদক্ষেপ

শেষ আইটেম অপসারণ: পপ মেথডটি শেষ আইটেমটি সরিয়ে দেবে এবং টেইলকে পূর্ববর্তী আইটেমের দিকে নির্দেশ করবে।
অপসারিত আইটেম ফেরত দেওয়া: অপসারিত আইটেমটি ফেরত দেওয়া হবে।

🌟 এজ কেস

আমাদের কিছু এজ কেস বিবেচনা করতে হবে:

শূন্য আইটেম: যদি লিঙ্কড লিস্টে কোনও আইটেম না থাকে, তাহলে আমরা কিছু অপসারণ করতে পারি না।
একটি আইটেম: যদি লিঙ্কড লিস্টে মাত্র একটি আইটেম থাকে, তাহলে আমাদের বিশেষভাবে কোড করতে হবে।

🌟পপ মেথডের Logic

টেইলকে পূর্ববর্তী আইটেমের দিকে নির্দেশ করা: এটি কিছুটা জটিল, কারণ আমাদের টেইলকে বাম দিকে সরাতে হবে।
নেস্টেড অবজেক্ট হিসেবে দেখতে হবে: টেইলকে পূর্ববর্তী আইটেমে নির্দেশ করার জন্য, আমাদের হেড থেকে শুরু করে পুরো তালিকাটি পার হতে হবে।

🌟 কোডিং পরিকল্পনা

নতুন ভেরিয়েবল তৈরি করা:

temp: এটি শেষ নোডকে নির্দেশ করবে।
pre: এটি শেষের পূর্ববর্তী নোডকে নির্দেশ করবে।

তালিকার মধ্য দিয়ে পুনরাবৃত্তি করা:

temp এর next যদি অন্য নোডকে নির্দেশ করে, তাহলে pre কে আপডেট করুন এবং temp কে পরবর্তী নোডে সরান।
পুনরাবৃত্তি চলতে থাকবে যতক্ষণ না temp.next null হয়।

টেইল আপডেট করা:

টেইলকে pre এর দিকে নির্দেশ করুন।
tail.next কে null সেট করুন, যা শেষ নোডটি সরিয়ে দেবে।

অপসারিত নোড ফেরত দেওয়া:
- অবশেষে, temp ফেরত দিন, যা অপসারিত নোডকে নির্দেশ করবে।

কোড উদাহরণ

pop() {
    // case 0 items
    if (!this.head) {
        return undefined; // যদি তালিকা খালি হয়
    }
// case two or more items
    let temp = this.head;
    let pre = this.head;

    // তালিকার মধ্য দিয়ে পুনরাবৃত্তি করা means as long as temp !== null
    while (temp.next) {
        pre = temp; // পূর্ববর্তী নোড আপডেট করা
        temp = temp.next; // পরবর্তী নোডে যাওয়া
    }

    this.tail = pre; // টেইলকে পূর্ববর্তী নোডে নির্দেশ করা
    this.tail.next = null; // শেষ নোড অপসারণ করা
    this.length --;

    return temp; // অপসারিত নোড ফেরত দেওয়া

//case for one items
   this.tail = pre; // টেইলকে পূর্ববর্তী নোডে নির্দেশ করা
    this.tail.next = null; // শেষ নোড অপসারণ করা
    this.length --;
    if(this.length ===0){
        this.head =null;
        this.tail =null;
    }
    return temp


}

এটি ছিল আমাদের পপ মেথডের একটি সংক্ষিপ্ত বিবরণ।

🌟 লিঙ্কড লিস্টের পপ (Pop) মেথড

এখন আমরা আমাদের লিঙ্কড লিস্টের পপ (Pop) মেথডটি কোড করব। এই মেথডটি শেষ আইটেমটি সরিয়ে দেবে এবং টেইলকে পূর্ববর্তী আইটেমের দিকে নির্দেশ করবে।

পপ মেথডের পদক্ষেপ

শূন্য আইটেম চেক করা: প্রথমে চেক করতে হবে যে লিঙ্কড লিস্টে কোনো আইটেম আছে কিনা।
একটি আইটেম চেক করা: যদি একটি মাত্র আইটেম থাকে, তাহলে হেড এবং টেইল উভয়ই সেই আইটেমের দিকে নির্দেশ করবে।
দুই বা ততোধিক আইটেম থাকা: যদি দুটি বা তার বেশি আইটেম থাকে, তাহলে আমাদের পূর্ববর্তী নোডে যাওয়ার জন্য তালিকার মধ্য দিয়ে পুনরাবৃত্তি করতে হবে।

কোডিং পরিকল্পনা

pop() {
    // ১. শূন্য আইটেম চেক করা
    if (!this.head || this.length === 0) {
        return undefined; // তালিকা খালি হলে undefined ফেরত দিন
    }

    let temp = this.head; // টেম্প ভেরিয়েবল হেডকে নির্দেশ করে
    let pre = null; // পূর্ববর্তী নোডের জন্য ভেরিয়েবল

    // ২. তালিকার মধ্য দিয়ে পুনরাবৃত্তি করা
    while (temp.next) {
        pre = temp; // পূর্ববর্তী নোড আপডেট করা
        temp = temp.next; // টেম্পকে পরবর্তী নোডে সরানো
    }

    // ৩. টেইল আপডেট করা
    this.tail = pre; // টেইলকে পূর্ববর্তী নোডে নির্দেশ করা
    this.tail.next = null; // শেষ নোড অপসারণ করা

    this.length--; // দৈর্ঘ্য কমানো

    // ৪. একমাত্র আইটেম থাকলে হেড এবং টেইল আপডেট করা
    if (this.length === 0) {
        this.head = null;
        this.tail = null;
    }

    return temp; // অপসারিত নোড ফেরত দেওয়া
}

কোড বিশ্লেষণ

শূন্য আইটেম চেক: if (!this.head || this.length === 0) এই শর্তটি পরীক্ষা করে যে তালিকা খালি কি না। যদি খালি হয়, তাহলে undefined ফেরত দেওয়া হয়।
পুনরাবৃত্তি: while (temp.next) এই শর্তটি ব্যবহার করে আমরা তালিকার শেষ পর্যন্ত পৌঁছানোর জন্য পুনরাবৃত্তি করি।
টেইল আপডেট: this.tail = pre দ্বারা টেইলকে পূর্ববর্তী নোডে নির্দেশ করি এবং this.tail.next = null দ্বারা শেষ নোড অপসারণ করি।
দৈর্ঘ্য আপডেট: this.length-- দ্বারা দৈর্ঘ্য কমানো হয়। যদি দৈর্ঘ্য শূন্য হয়, তাহলে হেড এবং টেইল উভয়কেই null এ সেট করা হয়।

ডেভটুলসে পরীক্ষা করা

এখন আসুন ডেভটুলসে কোডটি পরীক্ষা করি:

let myLinkedList = new LinkedList(1); // ১ মান সহ একটি নতুন লিঙ্কেড লিস্ট তৈরি করা
myLinkedList.push(2); // ২ মান যুক্ত করা

console.log(myLinkedList.pop()); // এটি ২ নোড ফেরত দেবে
console.log(myLinkedList); // এখন হেড ১ নোডকে নির্দেশ করবে, টেইলও ১ হবে

console.log(myLinkedList.pop()); // এটি ১ নোড ফেরত দেবে
console.log(myLinkedList); // এখন তালিকা খালি হবে, হেড এবং টেইল উভয়ই null হবে

console.log(myLinkedList.pop()); // এটি undefined ফেরত দেবে কারণ তালিকা খালি

ফলাফল

প্রথম পপ কল করার সময়, এটি ২ নোড ফেরত দেয় এবং তালিকায় ১ নোড থাকে।
দ্বিতীয় পপ কল করার সময়, এটি ১ নোড ফেরত দেয় এবং তালিকা খালি হয়ে যায়।
তৃতীয় পপ কল করার সময়, এটি undefined ফেরত দেয়।

এবং এইভাবে আমাদের পপ মেথড কার্যকরী হয়েছে!

🔲 Full Code

/*  
Pop is O(n) operation.
    case 1: no element
    case 2: two or more elements
    case 3: 1 element


*/



class CreateNode {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

class LinkdList {
  constructor(value) {
    const newNode = new CreateNode(value);
    this.head = newNode;
    this.tail = newNode;
    this.length = 1;
  }

  // push or add node at the end
  push(value) {
    const newNode = new CreateNode(value);
    if (this.head === null) {
      this.head = newNode;
      this.tail = newNode;
    } else {
      this.tail.next = newNode;
      this.tail = newNode;
    }
    this.length++;
    return this;
  };


  // pop or remove node at the last O(n)
  pop(){

    // case 1: no element
    if(!this.head || this.length ===0){
        return undefined;
    }
    // case 2: two or more elements
    let temp =this.head;
    let pre =this.head;
    while(temp.next !==null){
        pre =temp;
        temp = temp.next;
    }
    //both case 2 and 3
    this.tail =pre;
    this.tail.next =null;
    this.length --;

    // case 3: 1 element
    if(this.length ===0){
        this.head =null;
        this.tail =null;
    }
    return temp;

  }
};

let myLinkedList =new LinkdList(1);
myLinkedList.push(23);
myLinkedList.push(26);
console.log(myLinkedList)

myLinkedList.pop()
console.log(myLinkedList);

myLinkedList.pop()
console.log(myLinkedList);

myLinkedList.pop()
console.log(myLinkedList)

myLinkedList.pop()
console.log(myLinkedList);

🔥07- লিঙ্কড লিস্টের আনশিফট (Unshift) মেথড
<br>

🔥07- লিঙ্কড লিস্টের আনশিফট (Unshift) মেথড

এখন আমরা আমাদের লিঙ্কড লিস্টের জন্য আনশিফট (Unshift) মেথডটি লিখব। আনশিফট মেথডটি একটি নতুন নোডকে তালিকার শুরুতে যুক্ত করে।

আনশিফট মেথডের পদক্ষেপ

নতুন নোড তৈরি করা: প্রথমে একটি নতুন নোড তৈরি করতে হবে।
হেড পয়েন্টার আপডেট করা: নতুন নোডটি বর্তমান হেডের দিকে নির্দেশ করবে।
হেড এবং টেইল আপডেট করা: যদি তালিকা খালি হয়, তাহলে হেড এবং টেইল উভয়ই নতুন নোডের দিকে নির্দেশ করবে।

কোডিং পরিকল্পনা

unshift(value) {
    const newNode = new Node(value); // নতুন নোড তৈরি করা

    // যদি তালিকা খালি হয়
    if (!this.head) {
        this.head = newNode; // হেডকে নতুন নোডের দিকে নির্দেশ করা
        this.tail = newNode; // টেইলকেও নতুন নোডের দিকে নির্দেশ করা
    } else {
        newNode.next = this.head; // নতুন নোডের পরবর্তী পয়েন্টারকে বর্তমান হেডের দিকে নির্দেশ করা
        this.head = newNode; // হেডকে নতুন নোডের দিকে নির্দেশ করা
    }

    this.length++; // দৈর্ঘ্য ১ বাড়ানো
    return this; // পুরো লিঙ্কড লিস্ট ফেরত দেওয়া
}

কোড বিশ্লেষণ

নতুন নোড তৈরি: const newNode = new Node(value); এই লাইনে আমরা একটি নতুন নোড তৈরি করছি।
হেড চেক: if (!this.head) এই শর্তটি পরীক্ষা করে যে তালিকা খালি কি না। যদি খালি হয়, তাহলে হেড এবং টেইল উভয়ই নতুন নোডের দিকে নির্দেশ করে।
নতুন নোড যুক্ত করা: যদি তালিকা খালি না হয়, তাহলে newNode.next = this.head; দ্বারা নতুন নোডের পরবর্তী পয়েন্টারকে বর্তমান হেডে নির্দেশ করি এবং পরে হেড আপডেট করি।
দৈর্ঘ্য বাড়ানো: this.length++ মাধ্যমে আমরা লিঙ্কেড লিস্টের দৈর্ঘ্য বাড়াচ্ছি।
ফিরিয়ে দেওয়া: return this; পুরো লিঙ্কেড লিস্ট ফেরত দেয়।

ডেভটুলসে পরীক্ষা করা

এখন আসুন ডেভটুলসে কোডটি পরীক্ষা করি:

let myLinkedList = new LinkedList(11); // ১১ মান সহ একটি নতুন লিঙ্কেড লিস্ট তৈরি করা
myLinkedList.unshift(4); // ৪ মান যুক্ত করা

যখন আমরা myLinkedList.unshift(4) কল করি, এটি পুরো লিঙ্কেড লিস্ট ফেরত দেবে।

ফলাফল

LinkedList {
    head: Node { value: 4, next: Node { value: 11, next: null } },
    tail: Node { value: 11, next: null },
    length: 2
}

এবং এইভাবে আমাদের আনশিফট (Unshift) মেথড কার্যকরী হয়েছে!

🔲 Full Code

class CreateNode {
    constructor(value) {
        this.value = value;
        this.next = null;
    }
}

class LinkdList {
    constructor(value) {
        const newNode = new CreateNode(value);
        this.head = newNode;
        this.tail = newNode;
        this.length = 1;
    }

    // push or add node at the end
    push(value) {
        const newNode = new CreateNode(value);
        if (this.head === null) {
            this.head = newNode;
            this.tail = newNode;
        } else {
            this.tail.next = newNode;
            this.tail = newNode;
        }
        this.length++;
        return this;
    }
    pop() {

        if (!this.head)
            return undefined;
        let temp = this.head;
        let pre = this.head;
        while (temp.next) {
            pre = temp;
            temp = temp.next;
        }
        this.tail = pre;
        this.tail.next = null;
        this.length--;

        if (this.length === 0) {
            this.head = null;
            this.tail = null;
        }
        return temp;
    };


    unshift(value){
        const newNode =new CreateNode(value);

        if(!this.head){
            this.head = newNode;
            this.tail = newNode;
        }else{
            newNode.next =this.head; // pointer update
            this.head =newNode;   // new node k head banalam 
            // newNode =this.head;   // not working anymore
        }
        this.length++;
        return this; //whole linked list

    }
}

let myLinkedList = new LinkdList(1);
myLinkedList.push(20);
myLinkedList.push(70);
myLinkedList.push(40);
// console.log(myLinkedList);

myLinkedList.unshift(33);
console.log(myLinkedList);

🔥08- লিঙ্কড লিস্টের শিফট (Shift) মেথড
<br>

🔥08 লিঙ্কড লিস্টের শিফট (Shift) মেথড

এখন আমরা আমাদের লিঙ্কড লিস্টের জন্য শিফট (Shift) মেথডটি লিখব। শিফট মেথডটি তালিকার প্রথম আইটেমটি সরিয়ে দেবে এবং সেই আইটেমটি ফেরত দেবে।

শিফট মেথডের পদক্ষেপ

শূন্য আইটেম চেক করা: প্রথমে চেক করতে হবে যে লিঙ্কড লিস্টে কোনো আইটেম আছে কিনা।
একটি আইটেম থাকা: যদি একটি মাত্র আইটেম থাকে, তাহলে হেড এবং টেইল উভয়ই সেই আইটেমের দিকে নির্দেশ করবে।
দুই বা ততোধিক আইটেম থাকা: যদি দুটি বা তার বেশি আইটেম থাকে, তাহলে হেডকে পরবর্তী নোডের দিকে নির্দেশ করতে হবে।

কোডিং পরিকল্পনা

shift() {
    // ১. শূন্য আইটেম চেক করা
    if (!this.head) {
        return undefined; // তালিকা খালি হলে undefined ফেরত দিন
    }

    let temp = this.head; // টেম্প ভেরিয়েবল হেডকে নির্দেশ করে

    // ২. হেড আপডেট করা
    this.head = this.head.next; // হেডকে পরবর্তী নোডে নির্দেশ করা

    // ৩. অপসারিত নোডের পরবর্তী পয়েন্টারকে null সেট করা
    temp.next = null;

    // ৪. দৈর্ঘ্য কমানো
    this.length--;

    // ৫. যদি তালিকা খালি হয়, তাহলে টেইল আপডেট করা
    if (this.length === 0) {
        this.tail = null;
    }

    return temp; // অপসারিত নোড ফেরত দেওয়া
}

কোড বিশ্লেষণ

শূন্য আইটেম চেক: if (!this.head) এই শর্তটি পরীক্ষা করে যে তালিকা খালি কি না। যদি খালি হয়, তাহলে undefined ফেরত দেওয়া হয়।
হেড আপডেট: this.head = this.head.next; দ্বারা হেডকে পরবর্তী নোডে নির্দেশ করি।
অপসারিত নোডের পয়েন্টার আপডেট: temp.next = null; দ্বারা অপসারিত নোডের পরবর্তী পয়েন্টারকে null সেট করি।
দৈর্ঘ্য আপডেট: this.length-- দ্বারা দৈর্ঘ্য কমানো হয়। যদি দৈর্ঘ্য শূন্য হয়, তাহলে টেইলকেও null এ সেট করা হয়।

ডেভটুলসে পরীক্ষা করা

এখন আসুন ডেভটুলসে কোডটি পরীক্ষা করি:

let myLinkedList = new LinkedList(2); // ২ মান সহ একটি নতুন লিঙ্কেড লিস্ট তৈরি করা
myLinkedList.unshift(1); // ১ মান যুক্ত করা

console.log(myLinkedList.shift()); // এটি ১ নোড ফেরত দেবে
console.log(myLinkedList); // এখন তালিকায় ২ নোড থাকবে

myLinkedList.shift(); // এটি ২ নোড ফেরত দেবে
console.log(myLinkedList); // এখন তালিকা খালি হবে, হেড এবং টেইল উভয়ই null হবে

console.log(myLinkedList.shift()); // এটি undefined ফেরত দেবে কারণ তালিকা খালি

ফলাফল

প্রথম শিফট কল করার সময়, এটি ১ নোড ফেরত দেয় এবং তালিকায় ২ নোড থাকে।
দ্বিতীয় শিফট কল করার সময়, এটি ২ নোড ফেরত দেয় এবং তালিকা খালি হয়ে যায়।
তৃতীয় শিফট কল করার সময়, এটি undefined ফেরত দেয়।

এবং এইভাবে আমাদের শিফট (Shift) মেথড কার্যকরী হয়েছে!

Full Code

class CreateNode {
    constructor(value) {
        this.value = value;
        this.next = null;
    }
}

class LinkdList {
    constructor(value) {
        const newNode = new CreateNode(value);
        this.head = newNode;
        this.tail = newNode;
        this.length = 1;
    }


    //todo: Add Node
    // push or add node at the end
    push(value) {
        const newNode = new CreateNode(value);
        if (this.head === null) {
            this.head = newNode;
            this.tail = newNode;
        } else {
            this.tail.next = newNode;
            this.tail = newNode;
        }
        this.length++;
        return this;
    }

    // add node at the start
    unshift(value){
        const newNode =new CreateNode(value);

        if(!this.head){
            this.head = newNode;
            this.tail = newNode;
        }else{
            newNode.next =this.head; // pointer update
            this.head =newNode;   // new node k head banalam 
        }
        this.length++;
        return this; //whole linked list
    }

    //todo: Delete Node 

    // remove from end
    pop() {

        if (!this.head)
            return undefined;
        let temp = this.head;
        let pre = this.head;
        while (temp.next) {
            pre = temp;
            temp = temp.next;
        }
        this.tail = pre;
        this.tail.next = null;
        this.length--;

        if (this.length === 0) {
            this.head = null;
            this.tail = null;
        }
        return temp;
    };

    //remove from first
    shift(){
        if(!this.head) 
            return this.undefined;
        let tempNode =this.head;   // tempNode pointing to the head
        this.head =this.head.next;  // move head pointer
        tempNode.next= null;   // finally ser tempNode to null for detaching from head
        this.length--;

        if(this.length ===0){
            this.tail =null;
        }
        return this;
    }
}

let myLinkedList = new LinkdList(1);
myLinkedList.push(20);

myLinkedList.unshift(33);
console.log(myLinkedList);

myLinkedList.shift();
console.log(myLinkedList);

🔥09 -লিঙ্কড লিস্টের গেট (Get) মেথড
<br>

🔥09 -লিঙ্কড লিস্টের গেট (Get) মেথড

এখন আমরা আমাদের লিঙ্কড লিস্টের জন্য গেট (Get) মেথডটি তৈরি করব। গেট মেথডটি একটি নির্দিষ্ট ইনডেক্সে থাকা নোডটি ফেরত দেয়।

গেট মেথডের পদক্ষেপ

ইনডেক্স চেক করা: প্রথমে নিশ্চিত করতে হবে যে ইনডেক্সটি বৈধ কিনা।
নোড খোঁজা: যদি ইনডেক্স বৈধ হয়, তাহলে তালিকার শুরু থেকে শুরু করে নির্দিষ্ট ইনডেক্সে পৌঁছাতে হবে।
নোড ফেরত দেওয়া: নির্দিষ্ট ইনডেক্সের নোডটি ফেরত দিতে হবে।

কোডিং পরিকল্পনা

get(index) {
    // ১. ইনডেক্স চেক করা
    if (index &lt; 0 || index &gt;= this.length) {
        return undefined; // অবৈধ ইনডেক্স হলে undefined ফেরত দিন
    }

    let temp = this.head; // টেম্প ভেরিয়েবল হেডকে নির্দেশ করে

    // ২. তালিকার মধ্য দিয়ে পুনরাবৃত্তি করা
    for (let i = 0; i &lt; index; i++) {
        temp = temp.next; // টেম্পকে পরবর্তী নোডে সরানো
    }

    return temp; // নির্দিষ্ট ইনডেক্সের নোড ফেরত দেওয়া
}

কোড বিশ্লেষণ

ইনডেক্স চেক: if (index < 0 || index >= this.length) এই শর্তটি পরীক্ষা করে যে ইনডেক্স বৈধ কিনা। যদি অবৈধ হয়, তাহলে undefined ফেরত দেওয়া হয়।
নোড খোঁজা: for (let i = 0; i < index; i++) দ্বারা আমরা তালিকার মধ্য দিয়ে পুনরাবৃত্তি করি এবং temp ভেরিয়েবলকে পরবর্তী নোডে সরাই।
নোড ফেরত দেওয়া: শেষ পর্যন্ত, return temp; দ্বারা নির্দিষ্ট ইনডেক্সের নোডটি ফেরত দিই।

let myLinkedList = new LinkedList(0); // ০ মান সহ একটি নতুন লিঙ্কেড লিস্ট তৈরি করা
myLinkedList.unshift(1); // ১ মান যুক্ত করা
myLinkedList.unshift(2); // ২ মান যুক্ত করা
myLinkedList.unshift(3); // ৩ মান যুক্ত করা

console.log(myLinkedList.get(-1)); // এটি undefined ফেরত দেবে (অবৈধ ইনডেক্স)
console.log(myLinkedList.get(10)); // এটি undefined ফেরত দেবে (অবৈধ ইনডেক্স)
console.log(myLinkedList.get(2)); // এটি ২ নোড ফেরত দেবে (বৈধ ইনডেক্স)

ফলাফল

প্রথম গেট কল করার সময়, এটি অবৈধ ইনডেক্স (-1) এর জন্য undefined ফেরত দেয়।
দ্বিতীয় গেট কল করার সময়, এটি অবৈধ ইনডেক্স (10) এর জন্যও undefined ফেরত দেয়।
তৃতীয় গেট কল করার সময়, এটি বৈধ ইনডেক্স (2) এর জন্য ২ নোডের মান ফেরত দেয়।

এবং এইভাবে আমাদের গেট (Get) মেথড কার্যকরী হয়েছে!

🔥10- লিঙ্কড লিস্টের সেট (Set) মেথড
<br>

🔥10- লিঙ্কড লিস্টের সেট (Set) মেথড

এখন আমরা আমাদের লিঙ্কড লিস্টের জন্য সেট (Set) মেথডটি তৈরি করব। সেট মেথডটি একটি নির্দিষ্ট ইনডেক্সে থাকা নোডের মান পরিবর্তন করে।

সেট মেথডের পদক্ষেপ

ইনডেক্স চেক করা: প্রথমে নিশ্চিত করতে হবে যে ইনডেক্সটি বৈধ কিনা।
নোড খোঁজা: যদি ইনডেক্স বৈধ হয়, তাহলে তালিকার শুরু থেকে শুরু করে নির্দিষ্ট ইনডেক্সে পৌঁছাতে হবে।
মান পরিবর্তন করা: নির্দিষ্ট ইনডেক্সের নোডটির মান পরিবর্তন করতে হবে।
ফলাফল ফেরত দেওয়া: সফলভাবে পরিবর্তন হলে true ফেরত দিতে হবে, অন্যথায় false।

কোডিং পরিকল্পনা

set(index, value) {
    // ১. ইনডেক্স চেক করা
    if (index &lt; 0 || index &gt;= this.length) {
        return false; // অবৈধ ইনডেক্স হলে false ফেরত দিন
    }

    let temp = this.get(index); // নির্দিষ্ট ইনডেক্সের নোড খোঁজা

    // ২. নোড পাওয়া গেলে মান পরিবর্তন করা
    if (temp) {
        temp.value = value; // নোডের মান পরিবর্তন করা
        return true; // সফলভাবে পরিবর্তন হলে true ফেরত দিন
    }

    return false; // নোড না পাওয়া গেলে false ফেরত দিন
}

কোড বিশ্লেষণ

ইনডেক্স চেক: if (index < 0 || index >= this.length) এই শর্তটি পরীক্ষা করে যে ইনডেক্স বৈধ কিনা। যদি অবৈধ হয়, তাহলে false ফেরত দেওয়া হয়।
নোড খোঁজা: let temp = this.get(index); দ্বারা আমরা গেট মেথড ব্যবহার করে নির্দিষ্ট ইনডেক্সের নোডটি খুঁজে বের করি।
মান পরিবর্তন: if (temp) দ্বারা নিশ্চিত হই যে নোডটি পাওয়া গেছে এবং তারপর temp.value = value; দ্বারা মান পরিবর্তন করি।
ফলাফল ফেরত দেওয়া: সফলভাবে পরিবর্তন হলে true এবং অন্যথায় false ফেরত দিই।

ডেভটুলসে পরীক্ষা করা

এখন আসুন ডেভটুলসে কোডটি পরীক্ষা করি:

let myLinkedList = new LinkedList(3); // ৩ মান সহ একটি নতুন লিঙ্কেড লিস্ট তৈরি করা
myLinkedList.unshift(2); // ২ মান যুক্ত করা
myLinkedList.unshift(1); // ১ মান যুক্ত করা

console.log(myLinkedList.set(1, 4)); // এটি true ফেরত দেবে এবং ২ নোডের মানকে ৪ এ পরিবর্তন করবে
console.log(myLinkedList.get(1)); // এটি এখন ৪ ফেরত দেবে

ফলাফল

প্রথম সেট কল করার সময়, এটি সফলভাবে ২ নোডের মানকে ৪ এ পরিবর্তন করে এবং true ফেরত দেয়।
দ্বিতীয় গেট কল করার সময়, এটি নতুন মান (৪) ফেরত দেয়।

এবং এইভাবে আমাদের সেট (Set) মেথড কার্যকরী হয়েছে!

🔥11 -লিঙ্কড লিস্টের ইনসার্ট (Insert) মেথড
<br>

🔥11 লিঙ্কড লিস্টের ইনসার্ট (Insert) মেথড

Insert Node at any position

এখন আমরা আমাদের লিঙ্কড লিস্টের জন্য ইনসার্ট (Insert) মেথডটি তৈরি করব। ইনসার্ট মেথডটি একটি নতুন নোডকে নির্দিষ্ট ইনডেক্সে যুক্ত করে।

ইনসার্ট মেথডের পদক্ষেপ

ইনডেক্স চেক করা: প্রথমে নিশ্চিত করতে হবে যে ইনডেক্সটি বৈধ কিনা।
নতুন নোড তৈরি করা: একটি নতুন নোড তৈরি করতে হবে।
নোড যুক্ত করা:
- যদি ইনডেক্স ০ হয়, তাহলে unshift মেথড ব্যবহার করে নতুন নোড যুক্ত করুন।
- যদি ইনডেক্স তালিকার দৈর্ঘ্যের সমান হয়, তাহলে push মেথড ব্যবহার করে নতুন নোড যুক্ত করুন।
- যদি ইনডেক্স বৈধ হয় এবং তালিকার মাঝখানে যুক্ত করতে হয়, তাহলে পূর্ববর্তী নোডের পয়েন্টার আপডেট করুন।

কোডিং পরিকল্পনা

insert(index, value) {
    // ১. ইনডেক্স চেক করা
    if (index &lt; 0 || index &gt; this.length) {
        return false; // অবৈধ ইনডেক্স হলে false ফেরত দিন
    }

    const newNode = new Node(value); // নতুন নোড তৈরি করা

    // ২. যদি ইনডেক্স ০ হয়
    if (index === 0) {
        return this.unshift(value); // unshift মেথড কল করা
    }

    // ৩. যদি ইনডেক্স তালিকার দৈর্ঘ্যের সমান হয়
    if (index === this.length) {
        return this.push(value); // push মেথড কল করা
    }

    // ৪. তালিকার মাঝখানে ইনসার্ট করা
    let temp = this.get(index - 1); // পূর্ববর্তী নোড খোঁজা
    newNode.next = temp.next; // নতুন নোডের পরবর্তী পয়েন্টার আপডেট করা
    temp.next = newNode; // পূর্ববর্তী নোডের পরবর্তী পয়েন্টারকে নতুন নোডে নির্দেশ করা

    this.length++; // দৈর্ঘ্য বাড়ানো
    return true; // সফলভাবে পরিবর্তন হলে true ফেরত দিন
}

কোড বিশ্লেষণ

ইনডেক্স চেক: if (index < 0 || index > this.length) এই শর্তটি পরীক্ষা করে যে ইনڈেক্স বৈধ কিনা। যদি অবৈধ হয়, তাহলে false ফেরত দেওয়া হয়।
নতুন নোড তৈরি: const newNode = new Node(value); দ্বারা একটি নতুন নোড তৈরি করি।
ইনসার্ট অপারেশন:
- যদি ইনডেক্স ০ হয়, তাহলে unshift মেথড কল করি।
- যদি ইনڈেক্স তালিকার দৈর্ঘ্যের সমান হয়, তাহলে push মেথড কল করি।
- অন্যথায়, পূর্ববর্তী নোড খুঁজে বের করে এবং নতুন নোড যুক্ত করি।
দৈর্ঘ্য বাড়ানো: this.length++ দ্বারা তালিকার দৈর্ঘ্য বাড়াই।

let myLinkedList = new LinkedList(0); // ০ মান সহ একটি নতুন লিঙ্কেড লিস্ট তৈরি করা
myLinkedList.push(2); // ২ মান যুক্ত করা

console.log(myLinkedList.insert(1, 1)); // এটি true ফেরত দেবে এবং ১ নোডকে ইনসার্ট করবে
console.log(myLinkedList); // এখন তালিকায় ০ -&gt; ১ -&gt; ২ থাকবে

ফলাফল

প্রথম ইনসার্ট কল করার সময়, এটি সফলভাবে ১ নোডকে ইনসার্ট করে এবং true ফেরত দেয়।
তালিকা এখন ০ -> ১ -> ২ রূপে থাকবে।

এবং এইভাবে আমাদের ইনসার্ট (Insert) মেথড কার্যকরী হয়েছে!

🔥12-লিঙ্কড লিস্টের রিমুভ (Remove) মেথড 
<br>

🔥12-লিঙ্কড লিস্টের রিমুভ (Remove) মেথড

এখন আমরা আমাদের লিঙ্কড লিস্টের জন্য রিমুভ (Remove) মেথডটি তৈরি করব। রিমুভ মেথডটি একটি নির্দিষ্ট ইনডেক্স থেকে একটি আইটেম সরিয়ে দেয়।

রিমুভ মেথডের পদক্ষেপ

ইনডেক্স চেক করা: প্রথমে নিশ্চিত করতে হবে যে ইনডেক্সটি বৈধ কিনা।
প্রথম আইটেম সরানো: যদি ইনডেক্স ০ হয়, তাহলে shift মেথড ব্যবহার করে আইটেম সরান।
শেষ আইটেম সরানো: যদি ইনডেক্স তালিকার দৈর্ঘ্যের সমান হয়, তাহলে pop মেথড ব্যবহার করে আইটেম সরান।
মাঝে আইটেম সরানো: যদি ইনডেক্স বৈধ হয় এবং তালিকার মাঝখানে আইটেম সরাতে হয়, তাহলে পূর্ববর্তী নোডের পয়েন্টার আপডেট করুন।

কোডিং পরিকল্পনা

remove(index) {
    // ১. ইনডেক্স চেক করা
    if (index &lt; 0 || index &gt;= this.length) {
        return undefined; // অবৈধ ইনডেক্স হলে undefined ফেরত দিন
    }

    // ২. প্রথম আইটেম সরানো
    if (index === 0) {
        return this.shift(); // shift মেথড কল করা
    }

    // ৩. শেষ আইটেম সরানো
    if (index === this.length - 1) {
        return this.pop(); // pop মেথড কল করা
    }

    // ৪. মাঝখানে আইটেম সরানো
    let before = this.get(index - 1); // পূর্ববর্তী নোড খোঁজা
    let temp = before.next; // অপসারিত নোডটি খোঁজা

    before.next = temp.next; // পূর্ববর্তী নোডের পরবর্তী পয়েন্টার আপডেট করা
    temp.next = null; // অপসারিত নোডের পরবর্তী পয়েন্টারকে null সেট করা

    this.length--; // দৈর্ঘ্য কমানো

    return temp; // অপসারিত নোড ফেরত দেওয়া
}

কোড বিশ্লেষণ

ইনডেক্স চেক: if (index < 0 || index >= this.length) এই শর্তটি পরীক্ষা করে যে ইনডেক্স বৈধ কিনা। যদি অবৈধ হয়, তাহলে undefined ফেরত দেওয়া হয়।
প্রথম আইটেম সরানো: if (index === 0) দ্বারা নিশ্চিত হই যে এটি প্রথম আইটেম এবং shift মেথড কল করি।
শেষ আইটেম সরানো: if (index === this.length - 1) দ্বারা নিশ্চিত হই যে এটি শেষ আইটেম এবং pop মেথড কল করি।
মাঝখানে আইটেম সরানো: পূর্ববর্তী নোড খুঁজে বের করে এবং নতুন পয়েন্টার সেট করি।
দৈর্ঘ্য কমানো: this.length-- দ্বারা তালিকার দৈর্ঘ্য কমাই।

এখন আসুন ডেভটুলসে কোডটি পরীক্ষা করি:

let myLinkedList = new LinkedList(11); // ১১ মান সহ একটি নতুন লিঙ্কেড লিস্ট তৈরি করা
myLinkedList.push(23); // ২৩ মান যুক্ত করা
myLinkedList.push(7); // ৭ মান যুক্ত করা

console.log(myLinkedList.remove(1)); // এটি ২৩ নোড ফেরত দেবে এবং তালিকা থেকে সরিয়ে দেবে
console.log(myLinkedList); // এখন তালিকায় ১১ -&gt; ৭ থাকবে, দৈর্ঘ্য হবে 2

ফলাফল

প্রথম রিমুভ কল করার সময়, এটি সফলভাবে ২৩ নোডকে সরিয়ে দেয় এবং ফেরত দেয়।
তালিকা এখন ১১ -> ৭ রূপে থাকবে এবং দৈর্ঘ্য হবে ২।

এবং এইভাবে আমাদের রিমুভ (Remove) মেথড কার্যকরী হয়েছে!

🔥13-Reverse Linked List
<br>

🔥13-লিঙ্কড লিস্টের রিভার্স (Reverse) মেথড

এখন আমরা আমাদের লিঙ্কড লিস্টের জন্য রিভার্স (Reverse) মেথডটি তৈরি করব। রিভার্স মেথডটি একটি লিঙ্কড লিস্টের নোডগুলিকে উল্টে দেয়।

রিভার্স মেথডের পদক্ষেপ

হেড এবং টেইল পরিবর্তন: প্রথমে হেড এবং টেইলকে একে অপরের দিকে নির্দেশ করতে হবে।
নোডগুলির পয়েন্টার পরিবর্তন: প্রতিটি নোডের পরবর্তী পয়েন্টারকে পূর্ববর্তী নোডে নির্দেশ করতে হবে।
ফলাফল ফেরত দেওয়া: পুরো উল্টানো তালিকা ফেরত দিতে হবে।

কোডিং পরিকল্পনা

reverse() {
    // ১. হেড এবং টেইল পরিবর্তন করা
    let temp = this.head; // টেম্প ভেরিয়েবল হেডকে নির্দেশ করে
    this.head = this.tail; // হেডকে টেইলে নির্দেশ করা
    this.tail = temp; // টেইলকে পূর্ববর্তী হেডে নির্দেশ করা

    let next = null; // পরবর্তী নোডের জন্য ভেরিয়েবল
    let previous = null; // পূর্ববর্তী নোডের জন্য ভেরিয়েবল

    // ২. তালিকার মধ্য দিয়ে পুনরাবৃত্তি করা
    while (temp) {
        next = temp.next; // পরবর্তী নোড সংরক্ষণ করা
        temp.next = previous; // বর্তমান নোডের পরবর্তী পয়েন্টার আপডেট করা
        previous = temp; // পূর্ববর্তী নোড আপডেট করা
        temp = next; // টেম্পকে পরবর্তী নোডে সরানো
    }

    // ৩. ফলাফল ফেরত দেওয়া
    return this; // পুরো উল্টানো তালিকা ফেরত দেওয়া
}

কোড বিশ্লেষণ

হেড এবং টেইল পরিবর্তন: প্রথমে let temp = this.head; দ্বারা টেম্প ভেরিয়েবল তৈরি করি। তারপর this.head = this.tail; এবং this.tail = temp; দ্বারা হেড এবং টেইলকে পরিবর্তন করি।
পুনরাবৃত্তি: while (temp) দ্বারা আমরা তালিকার প্রতিটি নোডের পয়েন্টার পরিবর্তন করি।
- next = temp.next; দ্বারা পরবর্তী নোড সংরক্ষণ করি।
- temp.next = previous; দ্বারা বর্তমান নোডের পরবর্তী পয়েন্টার আপডেট করি।
- previous = temp; দ্বারা পূর্ববর্তী নোড আপডেট করি।
- temp = next; দ্বারা টেম্পকে পরবর্তী নোডে সরাই।
ফলাফল ফেরত দেওয়া: শেষে, return this; দ্বারা পুরো উল্টানো তালিকা ফেরত দিই।

let myLinkedList = new LinkedList(1); // ১ মান সহ একটি নতুন লিঙ্কেড লিস্ট তৈরি করা
myLinkedList.push(2); // ২ মান যুক্ত করা
myLinkedList.push(3); // ৩ মান যুক্ত করা

console.log(myLinkedList.reverse()); // এটি উল্টানো তালিকা ফেরত দেবে

ফলাফল

রিভার্স কল করার সময়, তালিকা এখন ৩ -> ২ -> ১ রূপে থাকবে, যেখানে হেড এখন ৩ এবং টেইল ১।

এবং এইভাবে আমাদের রিভার্স (Reverse) মেথড কার্যকরী হয়েছে!

Full Code

class Node {
    constructor(value){
        this.value = value;
        this.next = null;
    }
}

class LinkedList {
    constructor(value) {
        const newNode = new Node(value);
        this.head = newNode;
        this.tail = this.head;
        this.length = 1;
    }

    printList() {
        let temp = this.head;
        while (temp !== null) {
            console.log(temp.value);
            temp = temp.next;
        }
    }

    getHead() {
        if (this.head === null) {
            console.log("Head: null");
        } else {
            console.log("Head: " + this.head.value);
        }
    }

    getTail() {
        if (this.tail === null) {
            console.log("Tail: null");
        } else {
            console.log("Tail: " + this.tail.value);
        }
    }

    getLength() {
        console.log("Length: " + this.length);
    }

    makeEmpty() {
        this.head = null;
        this.tail = null;
        this.length = 0;
    }

    push(value) {
        const newNode = new Node(value);
        if (!this.head) {
            this.head = newNode;
            this.tail = newNode;
        } else {
            this.tail.next = newNode;
            this.tail = newNode;
        }
        this.length++;
        return this;
    }

    pop() {
        if (this.length === 0) return undefined;
        let temp = this.head;
        let pre = this.head;
        while (temp.next) {
            pre = temp;
            temp = temp.next;
        }
        this.tail = pre;
        this.tail.next = null;
        this.length--;
        if (this.length === 0) {
            this.head = null;
            this.tail = null;
        }
        return temp;
    }

    unshift(value) {
        const newNode = new Node(value);
        if (!this.head) {
            this.head = newNode;
            this.tail = newNode;
        } else {
            newNode.next = this.head;
            this.head = newNode;
        }
        this.length++;
        return this;
    }

    shift() {
        if (this.length === 0) return undefined;
        let temp = this.head;
        this.head = this.head.next;
        this.length--;
        if (this.length === 0) {
            this.tail = null;
        }
        temp.next = null;
        return temp;
    }

    get(index) {
        if (index < 0 || index >= this.length) return undefined;
        let temp = this.head;
        for (let i = 0; i < index; i++) {
            temp = temp.next;
        }
        return temp;
    }

    set(index, value) {
        let temp = this.get(index);
        if (temp) {
            temp.value = value;
            return true;
        }
        return false;
    }

    insert(index, value) {
        if (index < 0 || index > this.length) return false;
        if (index === this.length) return this.push(value);
        if (index === 0) return this.unshift(value);

        const newNode = new Node(value);
        const temp = this.get(index - 1);
        newNode.next = temp.next;
        temp.next = newNode;
        this.length++;
        return true;
    }

    remove(index) {
        if (index < 0 || index >= this.length) return undefined;
        if (index === 0) return this.shift();
        if (index === this.length - 1) return this.pop();

        const before = this.get(index - 1);
        const temp = before.next;

        before.next = temp.next;
        temp.next = null;
        this.length--;
        return temp;
    }

    reverse() {
        let temp = this.head;
        this.head = this.tail;
        this.tail = temp;
        let next = temp.next;
        let prev = null;
        for (let i = 0; i < this.length; i++) {
            next = temp.next;
            temp.next = prev;
            prev = temp;
            temp = next;
        }
    }  

}


function test() {
    let myLinkedList = new LinkedList(1);
    myLinkedList.push(2);
    myLinkedList.push(3);
    myLinkedList.push(4);

    console.log("LL before reverse():");
    myLinkedList.printList();

    myLinkedList.reverse();

    console.log("\nLL after reverse():");
    myLinkedList.printList();
}


test();

Class in JavaScript

bappasaha — Wed, 02 Oct 2024 07:14:25 +0000

🔥🔥🔥 Class

class Box{

    constructor(color) {
        this.color =color;
    }

    getColor(){
        return this.color;
    }
    setColor(color){
        this.color =color
    }
}

let b1 =new Box('green');
let b2 =new Box('red');

console.log(b1.color)
console.log(b2.color)

ক্লাস সম্পর্কে

ক্লাস হল অবজেক্ট-অরিয়েন্টেড প্রোগ্রামিংয়ের (OOP) একটি মৌলিক ধারণা। এটি অবজেক্ট তৈরি করার জন্য একটি ব্লুপ্রিন্ট হিসাবে কাজ করে, যা ডেটা এবং সেই ডেটা পরিচালনার জন্য পদ্ধতিগুলি একত্রিত করে।

ক্লাসের উদাহরণ: কুকি ক্লাস

class Cookie {
    constructor(color) {
        this.color = color; // 'this' কীওয়ার্ড কুকির নির্দিষ্ট ইনস্ট্যান্সকে নির্দেশ করে।
    }
}

কনস্ট্রাক্টর: কনস্ট্রাক্টর মেথডটি একটি নতুন ইনস্ট্যান্স তৈরি করার সময় কল হয়। এখানে এটি একটি color প্যারামিটার গ্রহণ করে এবং এটিকে ইনস্ট্যান্স ভেরিয়েবল this.color এ অ্যাসাইন করে।

ইনস্ট্যান্স তৈরি করা

new কীওয়ার্ড ব্যবহার করে ক্লাসের ইনস্ট্যান্স তৈরি করা যায়:

let cookieOne = new Cookie("green"); // একটি সবুজ কুকি তৈরি করে
let cookieTwo = new Cookie("blue");   // একটি নীল কুকি তৈরি করে

ইনস্ট্যান্স: cookieOne এবং cookieTwo হল Cookie ক্লাসের নির্দিষ্ট ইনস্ট্যান্স, প্রতিটির নিজস্ব রঙের বৈশিষ্ট্য রয়েছে।

বৈশিষ্ট্য এবং পদ্ধতিগুলি অ্যাক্সেস করা

ক্লাসের মধ্যে পদ্ধতি সংজ্ঞায়িত করা যায় যাতে তার বৈশিষ্ট্যগুলির সাথে যোগাযোগ করা যায়। সাধারণ পদ্ধতিগুলির মধ্যে গেটার এবং সেটার অন্তর্ভুক্ত।

গেটার এবং সেটার

class Cookie {
    constructor(color) {
        this.color = color;
    }

    getColor() {
        return this.color; // কুকির রঙ ফেরত দেয়
    }

    setColor(newColor) {
        this.color = newColor; // কুকির রঙ আপডেট করে
    }
}

গেট রঙ: আপনি একটি নির্দিষ্ট কুকির রঙ উদ্ধার করতে পারেন।
সেট রঙ: আপনি একটি নির্দিষ্ট কুকির রঙ পরিবর্তন করতে পারেন।

উদাহরণ ব্যবহার

console.log(cookieOne.getColor()); // আউটপুট: green
cookieOne.setColor("yellow");
console.log(cookieOne.getColor()); // আউটপুট: yellow

ডেটা স্ট্রাকচারগুলিতে সম্প্রসারণ: লিঙ্কড লিস্ট ক্লাস

ক্লাসগুলি শুধুমাত্র সাধারণ অবজেক্ট যেমন কুকির জন্য সীমাবদ্ধ নয়; এগুলি জটিল ডেটা স্ট্রাকচার যেমন লিঙ্কড লিস্ট তৈরি করতে ব্যবহৃত হতে পারে।

লিঙ্কড লিস্ট ক্লাসের সারসংক্ষেপ

class LinkedList {
    constructor(value) {
        this.head = { value: value, next: null }; // হেড নোড শুরু করা
        this.length = 1; // দৈর্ঘ্য ট্র্যাক করা
    }

    push(value) {
        // শেষের দিকে নতুন নোড যোগ করার মেথড
    }

    unshift(value) {
        // শুরুতে নতুন নোড যোগ করার মেথড
    }

    insertAt(index, value) {
        // নির্দিষ্ট সূচকে একটি নোড সন্নিবেশ করার মেথড
    }

    remove(index) {
        // নির্দিষ্ট সূচক থেকে একটি নোড অপসারণ করার মেথড
    }

    pop() {
        // শেষ নোড অপসারণ করার মেথড
    }

    shift() {
        // প্রথম নোড অপসারণ করার মেথড
    }
}

লিঙ্কড লিস্টের উদাহরণ ব্যবহার

let myLinkedList = new LinkedList(23); // প্রথম নোডের মান 23 দিয়ে লিঙ্কড লিস্ট তৈরি করে
myLinkedList.push(7);                    // শেষে 7 যোগ করে
myLinkedList.unshift(3);                 // শুরুতে 3 যোগ করে
myLinkedList.insertAt(1, 11);            // সূচক 1 এ 11 সন্নিবেশ করে
myLinkedList.remove(1);                  // সূচক 1 থেকে আইটেম অপসারণ করে (11)

উপসংহার

ক্লাসগুলি আপনার কোডকে কাঠামোবদ্ধ করার জন্য একটি শক্তিশালী উপায় প্রদান করে, যা এটি মডুলার এবং পুনঃব্যবহারযোগ্য করে তোলে। তারা আপনাকে ডেটা এবং আচরণ উভয়ই সংজ্ঞায়িত করতে দেয়, যা জটিল অ্যাপ্লিকেশন তৈরি করার জন্য অপরিহার্য। ক্লাসগুলি সম্পর্কে এই মৌলিক জ্ঞান আপনাকে প্রোগ্রামিংয়ের বিভিন্ন চ্যালেঞ্জ মোকাবেলায় প্রস্তুত করবে!

Pointer in JavaScript

bappasaha — Wed, 02 Oct 2024 07:12:33 +0000

Code :

//todo: 1. withot using pointer

let n1 = 5;
let n2 = n1;

console.log("n1=", n1, " and n2=", n2);
n1 = 100;
console.log("n1=", n1, " and n2=", n2); 

//output
//n1= 5  and n2= 5
//n1= 100  and n2= 5

------------------------------------

//todo: 2. using pointer{object}
 /* 
 obj1 ↘️ 
       {value:11}
 obj2 ↗️ 

 */
let obj1 = {
  value: 11,     // obj1 -> {value:11}
};

let obj2 =obj1;   
console.log(obj1.value, obj2.value);  // 11 11
obj1.value =22;
console.log(obj1.value, obj2.value);  // 22 22

Pointer:

In javascript we implement this using object

;

পয়েন্টার সম্পর্কে

পয়েন্টারগুলি বোঝা গুরুত্বপূর্ণ কারণ আমরা সমস্ত ডেটা স্ট্রাকচারে এগুলি ব্যবহার করব। যদি আপনি ইতিমধ্যে পয়েন্টারগুলি বুঝে থাকেন, তবে আপনি এই অংশটি বাদ দিতে পারেন।

পয়েন্টার ছাড়া ভেরিয়েবল

আসুন প্রথমে এমন একটি উদাহরণ দেখি যা পয়েন্টার ব্যবহার করে না:

let numOne = 5; // numOne ভেরিয়েবল তৈরি করুন এবং 5 মান দিন
let numTwo = numOne; // numTwo ভেরিয়েবল তৈরি করুন এবং numOne এর মান দিন

পয়েন্টার ছাড়া ভেরিয়েবলের আচরণ

যখন আমরা উপরের কোডটি চালাই, তখন দেখা যায়:

numOne এর মান 5।
numTwo এরও মান 5।

এখন, যদি আমরা numOne পরিবর্তন করি:

numOne = 10; // numOne এর মান 10 এ পরিবর্তন করুন

এখন, numOne এর মান 10, কিন্তু numTwo এখনও 5।

এটি ঘটে কারণ যখন আমরা numTwo কে numOne এর সমান করি, তখন এটি সেই মুহূর্তে মানটি কপি করে। numOne পরিবর্তিত হলে numTwo প্রভাবিত হয় না।

পয়েন্টার সহ ভেরিয়েবল

এখন, আসুন দেখি কীভাবে পয়েন্টারগুলি অবজেক্টগুলির সাথে কাজ করে:

let objectOne = { value: 11 }; // একটি অবজেক্ট তৈরি করুন এবং objectOne এ অ্যাসাইন করুন
let objectTwo = objectOne; // objectTwo কে objectOne এর সমান করুন

পয়েন্টার সহ ভেরিয়েবলের আচরণ

যখন আমরা এই কোডটি চালাই:

objectOne এবং objectTwo উভয়ই একই অবজেক্টের দিকে নির্দেশ করে।

যদি আমরা অবজেক্টটির মান পরিবর্তন করি:

objectOne.value = 22; // objectOne দ্বারা নির্দেশিত অবজেক্টের মান পরিবর্তন করুন

এখন objectOne.value এবং objectTwo.value উভয়ই 22।

পয়েন্টার স্থানান্তর

আমরা একটি অবজেক্টের দিকে নির্দেশক স্থানান্তর করতে পারি:

let objectThree = { value: 33 }; // আরেকটি অবজেক্ট তৈরি করুন
objectTwo = objectThree; // এখন, objectTwo objectThree এর দিকে নির্দেশ করবে

এখন:

objectTwo একটি ভিন্ন অবজেক্ট (objectThree) এর দিকে নির্দেশ করছে, যখন objectOne এখনও মূল অবজেক্টের দিকে নির্দেশ করছে যার মান 22।

মেমরি ব্যবস্থাপনা এবং গার্বেজ কালেকশন

যদি একটি অবজেক্টকে আর কোনও ভেরিয়েবল দ্বারা নির্দেশিত না হয়, তবে এটি অপ্রাপ্য হয়ে যায়। উদাহরণস্বরূপ:

let unusedObject = { value: 44 }; // একটি অপ্রয়োজনীয় অবজেক্ট তৈরি করুন
unusedObject = null; // এখন এটি আর কোনও ভেরিয়েবল দ্বারা নির্দেশিত নয়

এখন, যেহেতু কোনও ভেরিয়েবল এই অবজেক্টকে নির্দেশ করছে না, এটি মেমরিতে স্থান দখল করছে কিন্তু ব্যবহৃত হচ্ছে না।

JavaScript সময়ে সময়ে এই ধরনের জিনিস পরিষ্কার করবে একটি প্রক্রিয়া দ্বারা যা গার্বেজ কালেকশন নামে পরিচিত।

উপসংহার

পয়েন্টারগুলি আমাদের কোডে ডেটা পরিচালনার জন্য অত্যন্ত গুরুত্বপূর্ণ। তারা আমাদেরকে একই অবজেক্টে একাধিক ভেরিয়েবলকে নির্দেশ করতে দেয় এবং মেমরি ব্যবস্থাপনায় সহায়তা করে। এই বিষয়গুলি বোঝা আপনাকে ডেটা স্ট্রাকচার এবং আরও জটিল প্রোগ্রামিং ধারণাগুলি বুঝতে সাহায্য করবে!

Push Two remote GitHub in same time

bappasaha — Sun, 25 Aug 2024 09:43:17 +0000

নিচের কমান্ড গুলো ফলো করুন :

git init

git add .

git commit -m "First commit"

git branch -M main

git remote add bappasahabapi YOUR_PERSONAL_ACCOUNT_REPOSITORY_HTTPS_URL

ex: `git remote add https://github.com/bappasahabapi1/test1.git`

git remote add bappasahabapi1 YOUR_PERSONAL_ACCOUNT_REPOSITORY_HTTPS_URL
ex: `git remote add https://github.com/bappasahabapi1/test2.git`

First account

git push bappasahabapi1 main

Second account

git push bappasahabapi2 main

মনে রাখবেন পুশ করার সময় খেয়াল রাখবেন আপনি কোন ব্রাঞ্চে আছেন আর কোন ব্রাঞ্চে পুশ করতেছে। Git bash Terminal এ দেখতে পারবেন আপনি কোন ব্রাঞ্চে আছেন বর্তমানে। এরকম হলে ব্রাঞ্চ পরিবর্তন করে আবার পুশ করেন।

git branch -M main

এর পরেও না হলে:

.git হিডেন ফোল্ডার ডিলিট দিয়ে আবার চেষ্টা করুন।

বিঃ দ্রঃ মনে রাখতে হবে কোনো কিছু পুশ করলে আপনাকে ২টা রিপোজিটরিতে পুশ করতে হবে। Deploy করার পরে গিটে আবার পুশ করলে vercel এ অটো আপডেট হয়ে যাবে।

one command to push two branch

npm run push

{
  "name": "vite-react-bsb",
  "private": true,
  "version": "0.0.0",
  "type": "module",
  "scripts": {
    "dev": "vite",
    "build": "vite build",
    "lint": "eslint . --ext js,jsx --report-unused-disable-directives --max-warnings 0",
    "preview": "vite preview",
    "push":"git push -u bappasahabapi1 main && git push -u bappasahabapi2 main",
    **"push":"git push -u vercel main && git push -u code main"**
  },
  "dependencies": {
    "react": "^18.2.0",
    "react-dom": "^18.2.0",
    "react-icons": "^5.0.1",
    "react-toastify": "^10.0.4"
  },
  "devDependencies": {
    "@types/react": "^18.2.43",
    "@types/react-dom": "^18.2.17",
    "@vitejs/plugin-react": "^4.2.1",
    "autoprefixer": "^10.4.16",
    "eslint": "^8.55.0",
    "eslint-plugin-react": "^7.33.2",
    "eslint-plugin-react-hooks": "^4.6.0",
    "eslint-plugin-react-refresh": "^0.4.5",
    "postcss": "^8.4.33",
    "tailwindcss": "^3.4.1",
    "vite": "^5.0.8"
  }
}