diff --git a/Documentation/app/docs/eventemitter/page.tsx b/Documentation/app/docs/eventemitter/page.tsx
new file mode 100644
index 0000000..3333898
--- /dev/null
+++ b/Documentation/app/docs/eventemitter/page.tsx
@@ -0,0 +1,403 @@
+import CodeBlock from "@/components/CodeBlock";
+import DocNavigation from "@/components/DocNavigation";
+
+export default function EventEmitterPage() {
+ return (
+
+
HTTP Routing
+
+ Build modular, Express.js-style REST APIs with BanglaCode's powerful routing system using pure Banglish keywords.
+
+
+
Overview
+
+ BanglaCode provides an Express.js-inspired router system that allows you to organize your HTTP endpoints into modular, reusable components. This makes it easy to build complex web applications with clean, maintainable code structure.
+
+
+
Key Features
+
+ - ✅ Modular Routing - Organize routes in separate files
+ - ✅ All HTTP Methods - GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS support
+ - ✅ Router Mounting - Mount sub-routers on paths
+ - ✅ Method Chaining - Define multiple routes fluently
+ - ✅ Pure Banglish - Bengali keywords throughout
+
+
+
+
+
Basic Router
+
Create a basic HTTP router with multiple endpoints:
+
+
router_banao() - Create Router
+
{`// Create new router
+dhoro app = router_banao();
+
+// Define GET route (আনা - fetch)
+app.ana("/", kaj(req, res) {
+ uttor(res, "Welcome to BanglaCode!");
+});
+
+// Define POST route (পাঠানো - send)
+app.pathano("/submit", kaj(req, res) {
+ json_uttor(res, {"message": "Data received"}, 201);
+});
+
+// Start server with router
+server_chalu(3000, app);`}
+
+
+
+
HTTP Methods
+
All 7 standard HTTP methods are supported with pure Banglish keywords:
+
+
ana() - GET (আনা - fetch)
+
{`app.ana("/users", kaj(req, res) {
+ dhoro users = [
+ {"id": 1, "name": "Ankan"},
+ {"id": 2, "name": "Rahim"}
+ ];
+ json_uttor(res, {"users": users});
+});`}
+
+
pathano() - POST (পাঠানো - send)
+
{`app.pathano("/users", kaj(req, res) {
+ // In real app, would parse req["body"]
+ dhoro newUser = {"id": 3, "name": "New User"};
+ json_uttor(res, {"user": newUser}, 201);
+});`}
+
+
bodlano() - PUT (বদলানো - update/change)
+
{`app.bodlano("/users/update", kaj(req, res) {
+ json_uttor(res, {
+ "message": "User updated successfully"
+ });
+});`}
+
+
mujhe_felo() - DELETE (মুছে ফেলো - remove)
+
{`app.mujhe_felo("/users/delete", kaj(req, res) {
+ uttor(res, "User deleted", 204);
+});`}
+
+
songshodhon() - PATCH (সংশোধন - modify)
+
{`app.songshodhon("/users/modify", kaj(req, res) {
+ json_uttor(res, {"message": "User modified"});
+});`}
+
+
matha() - HEAD (মাথা - retrieve headers)
+
{`app.matha("/users", kaj(req, res) {
+ res["headers"] = {"Content-Type": "application/json"};
+ res["status"] = 200;
+});`}
+
+
nirdharon() - OPTIONS (নির্ধারণ - determine options)
+
{`app.nirdharon("/users", kaj(req, res) {
+ res["headers"] = {"Allow": "GET, POST, PUT, DELETE, PATCH"};
+ res["status"] = 200;
+});`}
+
+
+
+
Modular Routing
+
+ The real power of BanglaCode's routing system is the ability to organize routes into separate modules, just like Express.js.
+
+
+
Step 1: Create Route Modules
+
+
File: routes_auth.bang
+
{`// Authentication Routes Module
+dhoro authRouter = router_banao();
+
+authRouter.pathano("/login", kaj(req, res) {
+ json_uttor(res, {
+ "token": "jwt_token_here",
+ "user": {"name": "Ankan"}
+ });
+});
+
+authRouter.pathano("/register", kaj(req, res) {
+ json_uttor(res, {
+ "message": "User registered successfully"
+ }, 201);
+});
+
+authRouter.pathano("/logout", kaj(req, res) {
+ json_uttor(res, {"message": "Logged out"});
+});
+
+// Export router
+pathao authRouter;`}
+
+
File: routes_users.bang
+
{`// User Management Routes Module
+dhoro usersRouter = router_banao();
+
+dhoro users = [
+ {"id": 1, "name": "Ankan"},
+ {"id": 2, "name": "Rahim"}
+];
+
+usersRouter.ana("/", kaj(req, res) {
+ json_uttor(res, {"users": users});
+});
+
+usersRouter.pathano("/", kaj(req, res) {
+ json_uttor(res, {
+ "message": "User created"
+ }, 201);
+});
+
+usersRouter.mujhe_felo("/delete", kaj(req, res) {
+ json_uttor(res, {"message": "User deleted"});
+});
+
+// Export router
+pathao usersRouter;`}
+
+
Step 2: Mount Routers in Main App
+
+
File: main.bang
+
{`// Import route modules
+dhoro authRouter = ano("routes_auth.bang");
+dhoro usersRouter = ano("routes_users.bang");
+
+// Create main app
+dhoro app = router_banao();
+
+// Main routes
+app.ana("/", kaj(req, res) {
+ json_uttor(res, {
+ "message": "Welcome to API",
+ "endpoints": {
+ "auth": "/api/auth",
+ "users": "/api/users"
+ }
+ });
+});
+
+// Mount sub-routers using bebohar (ব্যবহার - use/mount)
+app.bebohar("/api/auth", authRouter);
+app.bebohar("/api/users", usersRouter);
+
+// Start server
+dekho("Server starting on port 3000...");
+server_chalu(3000, app);`}
+
+
Available Routes
+
After mounting, these routes are available:
+
+ GET / - Main welcome messagePOST /api/auth/login - User loginPOST /api/auth/register - User registrationPOST /api/auth/logout - User logoutGET /api/users - Get all usersPOST /api/users - Create new userDELETE /api/users/delete - Delete user
+
+
+
+
Method Chaining
+
Define multiple routes fluently with method chaining:
+
+
{`dhoro app = router_banao();
+
+app
+ .ana("/", kaj(req, res) {
+ uttor(res, "Home");
+ })
+ .ana("/about", kaj(req, res) {
+ uttor(res, "About");
+ })
+ .pathano("/submit", kaj(req, res) {
+ uttor(res, "Submitted");
+ })
+ .bodlano("/update", kaj(req, res) {
+ uttor(res, "Updated");
+ });`}
+
+
+
+
Request & Response Objects
+
+
Request Object (req)
+
The request object contains information about the incoming HTTP request:
+
+
{`app.ana("/inspect", kaj(req, res) {
+ dhoro method = req["method"]; // "GET"
+ dhoro path = req["path"]; // "/inspect"
+ dhoro query = req["query"]; // Query string
+ dhoro headers = req["headers"]; // Request headers
+ dhoro body = req["body"]; // Request body
+
+ json_uttor(res, {
+ "method": method,
+ "path": path,
+ "query": query
+ });
+});`}
+
+
Response Object (res)
+
Use helper functions to send responses:
+
+
uttor() - Simple Response
+
{`// Basic response
+uttor(res, "Hello, World!");
+
+// With status code
+uttor(res, "Not Found", 404);
+
+// With content type
+uttor(res, "Hello", 200, "text/plain");`}
+
+
json_uttor() - JSON Response
+
{`// JSON response (auto sets content-type)
+json_uttor(res, {"message": "Success"});
+
+// With status code
+json_uttor(res, {"error": "Not Found"}, 404);`}
+
+
+
+
Complete Example
+
A full modular REST API with authentication and users:
+
+
{`// File: main.bang - Complete Modular API
+
+// Import modules
+dhoro authRouter = ano("routes_auth.bang");
+dhoro usersRouter = ano("routes_users.bang");
+
+// Create app
+dhoro app = router_banao();
+
+// Health check
+app.ana("/health", kaj(req, res) {
+ json_uttor(res, {
+ "status": "healthy",
+ "uptime": somoy()
+ });
+});
+
+// API info
+app.ana("/api", kaj(req, res) {
+ json_uttor(res, {
+ "version": "1.0.0",
+ "endpoints": {
+ "auth": "/api/auth (login, register)",
+ "users": "/api/users (CRUD)"
+ }
+ });
+});
+
+// Mount routers
+app.bebohar("/api/auth", authRouter);
+app.bebohar("/api/users", usersRouter);
+
+// 404 handler
+app.ana("/*", kaj(req, res) {
+ json_uttor(res, {
+ "error": "Route not found"
+ }, 404);
+});
+
+// Start server
+dekho("🚀 Server starting...");
+dekho("📍 http://localhost:3000");
+server_chalu(3000, app);`}
+
+
+
+
Best Practices
+
+
1. Organize by Feature
+
Group related routes in separate modules:
+
+ routes_auth.bang - Authenticationroutes_users.bang - User managementroutes_products.bang - Product catalogroutes_orders.bang - Order processing
+
+
2. Use Consistent Naming
+
{`// Good - descriptive router names
+dhoro authRouter = router_banao();
+dhoro usersRouter = router_banao();
+
+// Bad - unclear names
+dhoro r1 = router_banao();
+dhoro temp = router_banao();`}
+
+
3. Mount on Logical Paths
+
{`// Good - grouped by API version and resource
+app.bebohar("/api/v1/auth", authRouter);
+app.bebohar("/api/v1/users", usersRouter);
+
+// Bad - inconsistent paths
+app.bebohar("/auth", authRouter);
+app.bebohar("/api/users", usersRouter);`}
+
+
4. Export from Modules
+
{`// At end of route module file
+pathao authRouter; // Always export your router`}
+
+
+
+
API Reference
+
+
router_banao()
+
Returns: Router object
+
Description: Creates a new Express-style router instance
+
+
router.ana(path, handler)
+
Method: GET (আনা - fetch)
+
+ path (String) - Route pathhandler (Function) - Request handler- Returns: Router (for chaining)
+
+
+
router.pathano(path, handler)
+
Method: POST (পাঠানো - send)
+
+ path (String) - Route pathhandler (Function) - Request handler- Returns: Router (for chaining)
+
+
+
router.bodlano(path, handler)
+
Method: PUT (বদলানো - update/change)
+
+ path (String) - Route pathhandler (Function) - Request handler- Returns: Router (for chaining)
+
+
+
router.mujhe_felo(path, handler)
+
Method: DELETE (মুছে ফেলো - remove)
+
+ path (String) - Route pathhandler (Function) - Request handler- Returns: Router (for chaining)
+
+
+
router.songshodhon(path, handler)
+
Method: PATCH (সংশোধন - modify)
+
+ path (String) - Route pathhandler (Function) - Request handler- Returns: Router (for chaining)
+
+
+
router.matha(path, handler)
+
Method: HEAD (মাথা - retrieve headers)
+
+ path (String) - Route pathhandler (Function) - Request handler- Returns: Router (for chaining)
+
+
+
router.nirdharon(path, handler)
+
Method: OPTIONS (নির্ধারণ - determine options)
+
+ path (String) - Route pathhandler (Function) - Request handler- Returns: Router (for chaining)
+
+
+
router.bebohar(mountPath, subRouter)
+
Method: Mount sub-router (ব্যবহার - use/mount)
+
+ mountPath (String) - Base path for sub-routersubRouter (Router) - Router to mount- Returns: Router (for chaining)
+
+
+
server_chalu(port, handler)
+
+ port (Number) - Port to listen onhandler (Function OR Router) - Request handler or router
+
+
+
+
Related Topics
+
+
- BanglaCode has 31 Bengali keywords written in Banglish (Bengali words using English/Latin script).
+ BanglaCode keywords are written in Banglish (Bengali words using English/Latin script).
This makes it easy to type on any keyboard while remaining familiar to Bengali speakers.
@@ -193,6 +201,25 @@ dhoro sum = add(5, 3);
greet("Rahim");`}
/>
+
Object Oriented Programming
- Classes and Objects in BanglaCode.
+ Classes, Objects, Getters, Setters, Static Properties, and Private Fields in BanglaCode.
Classes (`sreni`)
- Define a class using sreni and stricture with shuru (constructor).
+ Define a class using sreni and constructor with shuru (constructor).
sreni Manush {
@@ -30,6 +30,220 @@ export default function OOP() {
dhoro person = notun Manush("Ankan", 25);
person.porichoy();
+
+ Getters (`pao`)
+ Getters allow you to define computed properties that are accessed like regular properties.
+
+
sreni Person {
+ shuru(naam, boichhor) {
+ ei.naam = naam;
+ ei.boichhor = boichhor;
+ }
+
+ pao boshi() {
+ dhoro current = 2026;
+ ferao current - ei.boichhor;
+ }
+ }
+
+ dhoro p = notun Person("Ankan", 1995);
+ dekho(p.boshi); // 31 (computed automatically)
+
Setters (`set`)
+ Setters allow you to define how properties are assigned, with validation or transformation.
+
+
sreni Rectangle {
+ shuru() {
+ ei._width = 0;
+ ei._height = 0;
+ }
+
+ pao area() {
+ ferao ei._width * ei._height;
+ }
+
+ set width(w) {
+ ei._width = w;
+ }
+
+ set height(h) {
+ ei._height = h;
+ }
+ }
+
+ dhoro rect = notun Rectangle();
+ rect.width = 10; // Calls setter
+ rect.height = 5; // Calls setter
+ dekho(rect.area); // 50
+
Static Properties (`sthir`)
+ Static properties belong to the class itself, not instances. Access them via ClassName.property.
+
+
sreni Circle {
+ sthir PI = 3.14159;
+
+ shuru(radius) {
+ ei.radius = radius;
+ }
+
+ kaj area() {
+ ferao Circle.PI * ei.radius * ei.radius;
+ }
+ }
+
+ dekho(Circle.PI); // 3.14159
+ dhoro c = notun Circle(10);
+ dekho(c.area()); // 314.159
+
Private Fields (Convention: `_prefix`)
+ Use underscore prefix for private fields. While accessible, it signals internal use only.
+
+
sreni BankAccount {
+ shuru(balance) {
+ ei._balance = balance; // Private field
+ }
+
+ kaj deposit(amount) {
+ ei._balance = ei._balance + amount;
+ }
+
+ kaj withdraw(amount) {
+ jodi (amount <= ei._balance) {
+ ei._balance = ei._balance - amount;
+ ferao sotti;
+ }
+ ferao mittha;
+ }
+
+ pao balance() {
+ ferao ei._balance; // Controlled access
+ }
+ }
+
+ dhoro account = notun BankAccount(1000);
+ account.deposit(500);
+ dekho(account.balance); // 1500 (via getter)
+
Real-World Example: Temperature Converter
+ Combining getters and setters for bidirectional conversion:
+
+
sreni Temperature {
+ shuru() {
+ ei._celsius = 0;
+ }
+
+ pao celsius() {
+ ferao ei._celsius;
+ }
+
+ set celsius(c) {
+ ei._celsius = c;
+ }
+
+ pao fahrenheit() {
+ ferao (ei._celsius * 9 / 5) + 32;
+ }
+
+ set fahrenheit(f) {
+ ei._celsius = (f - 32) * 5 / 9;
+ }
+ }
+
+ dhoro temp = notun Temperature();
+ temp.celsius = 100;
+ dekho(temp.fahrenheit); // 212
+
+ temp.fahrenheit = 32;
+ dekho(temp.celsius); // 0
+
Real-World Example: Product with Tax
+ Using static properties for shared constants:
+
+
sreni Product {
+ sthir TAX_RATE = 0.15; // 15% tax
+
+ shuru(naam, dam, quantity) {
+ ei._naam = naam;
+ ei._dam = dam;
+ ei._quantity = quantity;
+ }
+
+ pao subtotal() {
+ ferao ei._dam * ei._quantity;
+ }
+
+ pao tax() {
+ ferao ei.subtotal * Product.TAX_RATE;
+ }
+
+ pao total() {
+ ferao ei.subtotal + ei.tax;
+ }
+ }
+
+ dhoro product = notun Product("Laptop", 1000, 2);
+ dekho(product.subtotal); // 2000
+ dekho(product.tax); // 300
+ dekho(product.total); // 2300
+
OOP Features Summary
+
+
+
Getters (`pao`)
+
+ • Computed properties accessed like regular properties
+ • No parameters, must return a value
+ • Perfect for derived data and calculations
+
+
+
+
+
Setters (`set`)
+
+ • Control how properties are assigned
+ • Exactly one parameter required
+ • Enable validation and transformation
+
+
+
+
+
Static Properties (`sthir`)
+
+ • Belong to the class, not instances
+ • Access via ClassName.property
+ • Shared across all instances
+ • Can be modified at runtime
+
+
+
+
+
Private Fields (`_prefix`)
+
+ • Use underscore prefix for internal fields
+ • Signals "internal use only" by convention
+ • Access via getters/setters for encapsulation
+ • Separate storage from public properties
+
+
+
+
💡 Best Practices
+
+ - Use getters for computed properties that don't require parameters
+ - Use setters for validation before assignment
+ - Use static properties for constants shared across instances
+ - Use `_prefix` for private fields and expose via getters/setters
+ - Combine getters and setters for bidirectional conversions
+ - Access static properties via
ClassName.property, not instance.property
+
+
+
+ Path Utilities (পাথ ইউটিলিটি)
+
+ BanglaCode provides comprehensive cross-platform path manipulation utilities. All operations are OS-aware and handle Windows, Linux, and macOS path conventions automatically.
+
+
+
+
+ Path Constants
+
+
+
+ PATH_SEP & PATH_DELIMITER
+
+
+ Platform-specific path separator and delimiter constants.
+
+
+
+ {`dhoro sep = PATH_SEP; // Unix: "/" | Windows: "\\\\"
+dhoro delim = PATH_DELIMITER; // Unix: ":" | Windows: ";"`}
+
+
+
+
+
+ Path Functions
+
+
+
+
+ path_resolve(...paths)
+
+
+ Resolves paths to absolute path.
+
+
+
+ {`dhoro abs = path_resolve(".", "src", "main.bang");
+dekho(abs); // /home/user/project/src/main.bang`}
+
+
+
+
+
+
+ path_normalize(path)
+
+
+ Normalizes path by removing redundant separators and resolving . and ..
+
+
+
+ {`dhoro clean = path_normalize("/foo//bar/../baz");
+dekho(clean); // /foo/baz`}
+
+
+
+
+
+
+ path_relative(base, target)
+
+
+ Computes relative path from base to target.
+
+
+
+ {`dhoro rel = path_relative("/home/user", "/home/user/docs/file.txt");
+dekho(rel); // docs/file.txt`}
+
+
+
+
+
+
+ path_joro(...segments)
+
+
+ Joins path segments using platform-specific separator.
+
+
+
+ {`dhoro fullPath = path_joro("home", "user", "file.txt");
+// Unix: home/user/file.txt | Windows: home\\user\\file.txt`}
+
+
+
+
+
+
+ directory_naam(path)
+
+
+ Returns directory name of a path.
+
+
+
+ {`dhoro dir = directory_naam("/home/user/file.txt");
+dekho(dir); // /home/user`}
+
+
+
+
+
+
+ path_naam(path)
+
+
+ Returns base name (filename or directory name).
+
+
+
+ {`dhoro name = path_naam("/home/user/document.txt");
+dekho(name); // document.txt`}
+
+
+
+
+
+
+ file_ext(path)
+
+
+ Returns file extension (including dot).
+
+
+
+ {`dhoro ext = file_ext("program.bang");
+dekho(ext); // .bang`}
+
+
+
+
+
+
+ Real-World Example
+
+
+
Path Analysis Utility
+
+ {`kaj analyzePath(filePath) {
+ ferao {
+ absolute: path_resolve(filePath),
+ normalized: path_normalize(filePath),
+ directory: directory_naam(filePath),
+ filename: path_naam(filePath),
+ extension: file_ext(filePath),
+ separator: PATH_SEP
+ };
+}
+
+dhoro result = analyzePath("./src/../lib/utils.bang");
+dekho(result);
+// {
+// absolute: "/home/user/project/lib/utils.bang",
+// normalized: "lib/utils.bang",
+// directory: ".",
+// filename: "utils.bang",
+// extension: ".bang",
+// separator: "/"
+// }`}
+
+
+
+
+ API Summary
+
+
+
+
+ | Function/Constant |
+ Description |
+
+
+
+
+ PATH_SEP |
+ Platform path separator |
+
+
+ PATH_DELIMITER |
+ Platform path list delimiter |
+
+
+ path_resolve(...paths) |
+ Resolve to absolute path |
+
+
+ path_normalize(path) |
+ Normalize path |
+
+
+ path_relative(base, target) |
+ Get relative path |
+
+
+ path_joro(...segments) |
+ Join path segments |
+
+
+ directory_naam(path) |
+ Get directory name |
+
+
+ path_naam(path) |
+ Get base name |
+
+
+ file_ext(path) |
+ Get file extension |
+
+
+
+
+
+
Streams API
+
+
+ The Streams API in BanglaCode enables efficient processing of large amounts of data by breaking it into smaller chunks. Instead of loading entire files or datasets into memory at once, streams allow you to process data piece by piece, making your applications more memory-efficient and responsive.
+
+
+ {/* Quick Start */}
+
+ Quick Start
+
+
+
+{`// Create a writable stream
+dhoro stream = stream_writable_srishti();
+
+// Write data to stream
+stream_lekho(stream, "Hello ");
+stream_lekho(stream, "World!");
+
+// Close stream
+stream_bondho(stream);
+
+dekho("Data:", buffer_text(buffer_theke(stream.Buffer)));`}
+
+
+
+
+ {/* Core Concepts */}
+
+ Core Concepts
+
+
+
+
Readable Streams (স্ট্রীম পড়ার)
+
+ Readable streams represent a source of data that you can read from chunk by chunk. They're ideal for processing large files or data sources without loading everything into memory.
+
+
+
+
+
Writable Streams (স্ট্রীম লেখার)
+
+ Writable streams represent a destination where you can write data chunk by chunk. They're perfect for creating files, sending data over networks, or any operation that produces data incrementally.
+
+
+
+
+
Event-Driven Processing
+
+ Streams emit events (data, end, error) that you can listen to, enabling reactive data processing patterns. This makes streams perfect for real-time data processing and transformations.
+
+
+
+
+
Backpressure Management
+
+ Streams automatically handle backpressure using the high water mark, preventing memory overflow when the producer is faster than the consumer. Default high water mark is 16KB.
+
+
+
+
+ {/* API Reference */}
+
+ API Reference
+
+
+ {/* stream_readable_srishti */}
+
+
+ stream_readable_srishti(highWaterMark?)
+
+
+ Creates a new readable stream.
+
+
+
Parameters:
+
+ highWaterMark (optional): Maximum buffer size in bytes (default: 16384)
+
+
+
Returns:
+
Stream object with type "readable"
+
+
+
+
+{`dhoro stream = stream_readable_srishti();
+dhoro largeStream = stream_readable_srishti(65536); // 64KB buffer`}
+
+
+
+
+
+ {/* stream_writable_srishti */}
+
+
+ stream_writable_srishti(highWaterMark?)
+
+
+ Creates a new writable stream.
+
+
+
Parameters:
+
+ highWaterMark (optional): Maximum buffer size in bytes (default: 16384)
+
+
+
Returns:
+
Stream object with type "writable"
+
+
+
+
+{`dhoro stream = stream_writable_srishti();
+dhoro customStream = stream_writable_srishti(32768); // 32KB buffer`}
+
+
+
+
+
+ {/* stream_lekho */}
+
+
+ stream_lekho(stream, data)
+
+
+ Writes data to a writable stream. Triggers "data" event handlers if registered.
+
+
+
Parameters:
+
+ stream: Writable stream objectdata: String or Buffer to write
+
+
+
Returns:
+
True if buffer is below high water mark, false otherwise
+
+
+
+
+{`dhoro stream = stream_writable_srishti();
+stream_lekho(stream, "Hello World");
+stream_lekho(stream, buffer_theke([72, 105])); // Write buffer`}
+
+
+
+
+
+ {/* stream_poro */}
+
+
+ stream_poro(stream, size?)
+
+
+ Reads data from a readable stream.
+
+
+
Parameters:
+
+ stream: Readable stream objectsize (optional): Number of bytes to read (default: all available)
+
+
+
Returns:
+
Buffer containing the read data, or null if stream is ended
+
+
+
+
+{`dhoro stream = stream_readable_srishti();
+dhoro data = stream_poro(stream); // Read all
+dhoro chunk = stream_poro(stream, 100); // Read 100 bytes`}
+
+
+
+
+
+ {/* stream_bondho */}
+
+
+ stream_bondho(stream)
+
+
+ Closes a stream, preventing further writes or reads. Triggers "end" event handlers.
+
+
+
Parameters:
+
+ stream: Stream object to close
+
+
+
+
+{`dhoro stream = stream_writable_srishti();
+stream_lekho(stream, "Final data");
+stream_bondho(stream); // Close stream`}
+
+
+
+
+
+ {/* stream_shesh */}
+
+
+ stream_shesh(stream)
+
+
+ Signals that a readable stream has ended (no more data will be written to it). Triggers "end" event handlers.
+
+
+
Parameters:
+
+ stream: Readable stream to end
+
+
+
+
+{`dhoro stream = stream_readable_srishti();
+// ... produce data ...
+stream_shesh(stream); // Signal end of data`}
+
+
+
+
+
+ {/* stream_pipe */}
+
+
+ stream_pipe(readable, writable)
+
+
+ Pipes data from a readable stream to a writable stream, automatically handling backpressure.
+
+
+
Parameters:
+
+ readable: Source readable streamwritable: Destination writable stream
+
+
+
+
+{`dhoro source = stream_readable_srishti();
+dhoro destination = stream_writable_srishti();
+stream_pipe(source, destination);`}
+
+
+
+
+
+ {/* stream_on */}
+
+
+ stream_on(stream, eventName, handler)
+
+
+ Registers an event handler for stream events (data, end, error).
+
+
+
Parameters:
+
+ stream: Stream objecteventName: Event name ("data", "end", or "error")handler: Function to call when event occurs
+
+
+
+
+{`dhoro stream = stream_writable_srishti();
+
+stream_on(stream, "data", kaj(chunk) {
+ dekho("Received:", chunk);
+});
+
+stream_on(stream, "end", kaj() {
+ dekho("Stream ended");
+});
+
+stream_on(stream, "error", kaj(err) {
+ dekho("Error:", err);
+});`}
+
+
+
+
+
+
+ {/* Real-World Examples */}
+
+ Real-World Examples
+
+
+ {/* Example 1: File Processing */}
+
+
Example 1: Large File Processing
+
+ Process a large file in chunks instead of loading it all into memory:
+
+
+
+
+{`// Process large log file line by line
+dhoro logStream = stream_writable_srishti();
+dhoro errorCount = 0;
+dhoro warningCount = 0;
+
+// Register data handler to process chunks
+stream_on(logStream, "data", kaj(chunk) {
+ dhoro lines = bibhajan(chunk, "\\n");
+
+ ghuriye (dhoro i = 0; i < dorghyo(lines); i = i + 1) {
+ dhoro line = lines[i];
+
+ jodi (khuje(line, "ERROR") != mittha) {
+ errorCount = errorCount + 1;
+ } nahole jodi (khuje(line, "WARNING") != mittha) {
+ warningCount = warningCount + 1;
+ }
+ }
+});
+
+// Handle end of stream
+stream_on(logStream, "end", kaj() {
+ dekho("Processing complete!");
+ dekho("Errors:", errorCount);
+ dekho("Warnings:", warningCount);
+});
+
+// Read file and write to stream in chunks
+dhoro content = poro("large_log.txt");
+dhoro chunkSize = 8192; // 8KB chunks
+
+ghuriye (dhoro i = 0; i < dorghyo(content); i = i + chunkSize) {
+ dhoro end = i + chunkSize;
+ jodi (end > dorghyo(content)) {
+ end = dorghyo(content);
+ }
+ dhoro chunk = angsho(content, i, end);
+ stream_lekho(logStream, chunk);
+}
+
+stream_bondho(logStream);`}
+
+
+
+
+
+ {/* Example 2: Data Transformation Pipeline */}
+
+
Example 2: Data Transformation Pipeline
+
+ Create a pipeline to transform and filter data in real-time:
+
+
+
+
+{`// Transform and filter data pipeline
+dhoro inputStream = stream_writable_srishti();
+dhoro outputStream = stream_writable_srishti();
+dhoro transformedCount = 0;
+
+// Transform: uppercase + filter (length > 5)
+stream_on(inputStream, "data", kaj(chunk) {
+ dhoro words = bibhajan(chunk, " ");
+ dhoro transformed = [];
+
+ ghuriye (dhoro i = 0; i < dorghyo(words); i = i + 1) {
+ dhoro word = words[i];
+
+ // Filter: only process words longer than 5 chars
+ jodi (dorghyo(word) > 5) {
+ dhoro upper = boro_hater(word);
+ transformed = dhaaka(transformed, upper);
+ transformedCount = transformedCount + 1;
+ }
+ }
+
+ // Write transformed data to output
+ jodi (dorghyo(transformed) > 0) {
+ dhoro result = joro(transformed, " ");
+ stream_lekho(outputStream, result + " ");
+ }
+});
+
+// Handle output stream data
+stream_on(outputStream, "data", kaj(chunk) {
+ dekho("Transformed:", chunk);
+});
+
+// Handle completion
+stream_on(inputStream, "end", kaj() {
+ stream_bondho(outputStream);
+ dekho("Transformation complete!");
+ dekho("Processed words:", transformedCount);
+});
+
+// Process input data
+dhoro input = "hello world banglacode programming language";
+stream_lekho(inputStream, input);
+stream_bondho(inputStream);`}
+
+
+
+
+
+ {/* Example 3: Network Data Streaming */}
+
+
Example 3: Network Data Streaming
+
+ Stream data from network to file efficiently:
+
+
+
+
+{`// Download and process data in streaming fashion
+proyash kaj downloadAndProcess() {
+ dhoro outputStream = stream_writable_srishti();
+ dhoro bytesProcessed = 0;
+
+ // Monitor data as it arrives
+ stream_on(outputStream, "data", kaj(chunk) {
+ bytesProcessed = bytesProcessed + dorghyo(chunk);
+
+ // Show progress every 10KB
+ jodi (bytesProcessed % 10240 == 0) {
+ dekho("Downloaded:", bytesProcessed, "bytes");
+ }
+ });
+
+ // Handle completion
+ stream_on(outputStream, "end", kaj() {
+ dekho("Download complete!");
+ dekho("Total bytes:", bytesProcessed);
+ });
+
+ // Simulate network data (in real app, use HTTP client)
+ dhoro data1 = "First chunk of data...";
+ dhoro data2 = "Second chunk of data...";
+ dhoro data3 = "Third chunk of data...";
+
+ // Write chunks as they arrive
+ stream_lekho(outputStream, data1);
+ opekha ghumaao(100);
+
+ stream_lekho(outputStream, data2);
+ opekha ghumaao(100);
+
+ stream_lekho(outputStream, data3);
+ stream_bondho(outputStream);
+
+ // Save to file
+ lekho("downloaded.txt", buffer_text(buffer_theke(outputStream.Buffer)));
+}
+
+downloadAndProcess();`}
+
+
+
+
+
+
+ {/* Best Practices */}
+
+ Best Practices
+
+
+
+
+ ✅ DO: Always Close Streams
+
+
+ Always close streams when you're done with them to free resources. Use stream_bondho() or stream_shesh() to properly terminate streams.
+
+
+
+
+
+ ✅ DO: Handle Events
+
+
+ Register handlers for "data", "end", and "error" events to create robust stream processing. This makes your code reactive and easier to maintain.
+
+
+
+
+
+ ✅ DO: Use Appropriate Buffer Sizes
+
+
+ Set high water marks based on your data size. Default is 16KB, but adjust for large files (64KB-1MB) or small packets (4KB-8KB) for optimal performance.
+
+
+
+
+
+ ✅ DO: Process Data in Chunks
+
+
+ Break large operations into smaller chunks. This prevents memory overflow and keeps your application responsive while processing large datasets.
+
+
+
+
+
+ ❌ DON'T: Write to Closed Streams
+
+
+ Attempting to write to a closed stream will result in an error. Always check stream state or handle errors properly in production code.
+
+
+
+
+
+ ❌ DON'T: Ignore Backpressure
+
+
+ Respect the return value of stream_lekho(). If it returns false, the buffer is full - pause writes until drained to avoid memory issues.
+
+
+
+
+
+ ❌ DON'T: Mix Sync and Async
+
+
+ Don't mix synchronous file reads with asynchronous stream processing. Keep your data flow consistent - either all sync or all async.
+
+
+
+
+
+ ❌ DON'T: Load Everything First
+
+
+ Avoid loading entire files into memory before streaming. That defeats the purpose! Use streams from the start for true streaming performance.
+
+
+
+
+ {/* Performance Tips */}
+
+ Performance Tips
+
+
+
+
+
🚀
+
+
Optimal Chunk Sizes
+
+ For file I/O: 8KB-64KB chunks work best. For network data: 4KB-16KB. For large datasets: 64KB-1MB. Test your specific use case to find the sweet spot.
+
+
+
+
+
+
💾
+
+
Memory Efficiency
+
+ Streams keep memory usage constant regardless of data size. A 10GB file uses only ~16KB RAM when processed with default streams - that's a 625,000x improvement!
+
+
+
+
+
+
⚡
+
+
Parallel Processing
+
+ Combine streams with Worker Threads for parallel data processing. Each worker can process its own stream for maximum throughput.
+
+
+
+
+
+
🔄
+
+
Pipeline Efficiency
+
+ Use stream_pipe() to create efficient data pipelines. The piping mechanism handles backpressure automatically, optimizing throughput.
+
+
+
+
+
+
+ {/* Common Patterns */}
+
+ Common Patterns
+
+
+
+
Pattern 1: Transform Stream
+
+
+
+{`// Create reusable transform stream
+kaj transformStream(inputStream, transformFn) {
+ dhoro outputStream = stream_writable_srishti();
+
+ stream_on(inputStream, "data", kaj(chunk) {
+ dhoro transformed = transformFn(chunk);
+ stream_lekho(outputStream, transformed);
+ });
+
+ stream_on(inputStream, "end", kaj() {
+ stream_bondho(outputStream);
+ });
+
+ ferao outputStream;
+}
+
+// Usage
+dhoro input = stream_writable_srishti();
+dhoro output = transformStream(input, kaj(data) {
+ ferao boro_hater(data); // Uppercase transform
+});`}
+
+
+
+
+
+
+
Pattern 2: Buffered Reader
+
+
+
+{`// Read file in fixed-size chunks
+kaj readInChunks(filepath, chunkSize, callback) {
+ dhoro content = poro(filepath);
+ dhoro stream = stream_writable_srishti();
+
+ stream_on(stream, "data", callback);
+
+ ghuriye (dhoro i = 0; i < dorghyo(content); i = i + chunkSize) {
+ dhoro end = i + chunkSize;
+ jodi (end > dorghyo(content)) {
+ end = dorghyo(content);
+ }
+ stream_lekho(stream, angsho(content, i, end));
+ }
+
+ stream_bondho(stream);
+}
+
+// Usage
+readInChunks("data.txt", 1024, kaj(chunk) {
+ dekho("Processing chunk:", dorghyo(chunk), "bytes");
+});`}
+
+
+
+
+
+
+
Pattern 3: Stream Aggregator
+
+
+
+{`// Aggregate stream data
+kaj aggregateStream(stream, reduceFn, initialValue) {
+ dhoro accumulated = initialValue;
+
+ stream_on(stream, "data", kaj(chunk) {
+ accumulated = reduceFn(accumulated, chunk);
+ });
+
+ stream_on(stream, "end", kaj() {
+ dekho("Final result:", accumulated);
+ });
+}
+
+// Usage: Count total characters
+dhoro stream = stream_writable_srishti();
+aggregateStream(stream, kaj(total, chunk) {
+ ferao total + dorghyo(chunk);
+}, 0);
+
+stream_lekho(stream, "Hello ");
+stream_lekho(stream, "World");
+stream_bondho(stream);`}
+
+
+
+
+
+
+ {/* Comparison with Other APIs */}
+
+ Streams vs Regular I/O
+
+
+
+
+ ❌ Without Streams (Bad for Large Files)
+
+
+
+
+{`// Loads entire 10GB file into memory!
+dhoro content = poro("huge.log");
+
+dhoro lines = bibhajan(content, "\\n");
+dhoro errors = 0;
+
+ghuriye (dhoro i = 0; i < dorghyo(lines); i = i + 1) {
+ jodi (khuje(lines[i], "ERROR") != mittha) {
+ errors = errors + 1;
+ }
+}
+
+dekho("Errors:", errors);
+
+// Memory usage: 10GB+
+// Time: Very slow (disk → RAM all at once)`}
+
+
+
+
+
+
+
+ ✅ With Streams (Optimal)
+
+
+
+
+{`// Processes 10GB file with only 16KB RAM!
+dhoro stream = stream_writable_srishti();
+dhoro errors = 0;
+
+stream_on(stream, "data", kaj(chunk) {
+ dhoro lines = bibhajan(chunk, "\\n");
+ ghuriye (dhoro i = 0; i < dorghyo(lines); i = i + 1) {
+ jodi (khuje(lines[i], "ERROR") != mittha) {
+ errors = errors + 1;
+ }
+ }
+});
+
+// ... write chunks to stream ...
+
+// Memory usage: ~16KB constant
+// Time: Much faster (streaming)`}
+
+
+
+
+
+
+ {/* Related APIs */}
+
+
+ {/* Summary */}
+
+ Summary
+
+
+ The Streams API in BanglaCode provides a powerful and memory-efficient way to process large amounts of data. By breaking data into smaller chunks and processing them incrementally, streams enable you to build scalable applications that handle files and datasets of any size.
+
+
+ Key benefits:
+
+
+ - Memory Efficiency: Process gigabytes of data with only kilobytes of RAM
+ - Performance: Start processing immediately without waiting for entire files to load
+ - Backpressure: Automatic flow control prevents memory overflow
+ - Event-Driven: React to data as it arrives for real-time processing
+ - Composability: Chain streams together to create data processing pipelines
+
+
+ Use streams whenever you're working with large files, network data, or any scenario where you want to process data incrementally rather than all at once.
+
+
+
dekho("a" in obj);
delete obj.a;
+ kaj* count(max) {"{"}
+ utpadan 1;
+ {"}"}
dhoro double = x => x * 2;
dhoro [a, b] = [10, 20];
diff --git a/Documentation/app/docs/url-parsing/page.tsx b/Documentation/app/docs/url-parsing/page.tsx
new file mode 100644
index 0000000..4eadf15
--- /dev/null
+++ b/Documentation/app/docs/url-parsing/page.tsx
@@ -0,0 +1,1117 @@
+export const metadata = {
+ title: 'URL Parsing API - BanglaCode',
+ description: 'Learn how to parse, manipulate, and construct URLs in BanglaCode with comprehensive URL and query string handling.',
+};
+
+export default function URLParsingDoc() {
+ return (
+
+
URL Parsing API
+
+
+ The URL Parsing API in BanglaCode provides powerful tools for parsing, manipulating, and constructing URLs. Whether you're building APIs, handling query parameters, or working with web services, these functions make URL operations simple and reliable.
+
+
+ {/* Quick Start */}
+
+ Quick Start
+
+
+
+{`// Parse a URL
+dhoro url = url_parse("https://api.example.com:8080/users?role=admin&page=2#results");
+
+dekho("Protocol:", url.Protocol); // "https:"
+dekho("Hostname:", url.Hostname); // "api.example.com"
+dekho("Port:", url.Port); // "8080"
+dekho("Pathname:", url.Pathname); // "/users"
+dekho("Search:", url.Search); // "?role=admin&page=2"
+dekho("Hash:", url.Hash); // "#results"
+
+// Work with query parameters
+dhoro params = url_query_params(url.Search);
+dekho("Role:", url_query_get(params, "role")); // "admin"
+dekho("Page:", url_query_get(params, "page")); // "2"`}
+
+
+
+
+ {/* Core Concepts */}
+
+ Core Concepts
+
+
+
+
URL Object (ইউআরএল অবজেক্ট)
+
+ A URL object represents a parsed URL with all its components: protocol, hostname, port, pathname, query string, and hash. It provides structured access to each part of a URL for easy manipulation.
+
+
+
+
+
URLSearchParams (কোয়েরি প্যারামিটার)
+
+ URLSearchParams provides a convenient interface for working with URL query strings. It supports getting, setting, appending, and deleting parameters, making query string manipulation straightforward and error-free.
+
+
+
+
+
Query String Manipulation
+
+ Query strings encode key-value pairs in URLs (e.g., ?name=value&key=data). The API handles encoding/decoding automatically, supports multiple values per key, and provides methods to iterate over all parameters.
+
+
+
+
+
URL Encoding
+
+ Special characters in URLs must be encoded. The API automatically handles URL encoding when setting parameters, ensuring your URLs are always valid and safe to use in HTTP requests.
+
+
+
+
+ {/* API Reference */}
+
+ API Reference
+
+
+ {/* url_parse */}
+
+
+ url_parse(urlString)
+
+
+ Parses a URL string and returns a URL object with all its components.
+
+
+
Parameters:
+
+ urlString (string): The URL to parse
+
+
+
Returns:
+
URL object with properties:
+
+ Href: Full URL stringProtocol: Protocol scheme (e.g., "https:")Username: Username for authenticationPassword: Password for authenticationHostname: Domain name or IP addressPort: Port number (if specified)Host: Hostname + port (if present)Pathname: Path portion of the URLSearch: Query string (including "?")Hash: Fragment identifier (including "#")Origin: Protocol + hostname + port
+
+
+
+
+{`dhoro url = url_parse("https://user:pass@api.example.com:8080/v1/users?active=true#top");
+
+dekho(url.Href); // "https://user:pass@api.example.com:8080/v1/users?active=true#top"
+dekho(url.Protocol); // "https:"
+dekho(url.Username); // "user"
+dekho(url.Password); // "pass"
+dekho(url.Hostname); // "api.example.com"
+dekho(url.Port); // "8080"
+dekho(url.Host); // "api.example.com:8080"
+dekho(url.Pathname); // "/v1/users"
+dekho(url.Search); // "?active=true"
+dekho(url.Hash); // "#top"
+dekho(url.Origin); // "https://api.example.com:8080"`}
+
+
+
+
+
+ {/* url_query_params */}
+
+
+ url_query_params(queryStringOrURL)
+
+
+ Creates a URLSearchParams object from a query string or URL object.
+
+
+
Parameters:
+
+ queryStringOrURL (string or URL object): Query string (with or without "?") or URL object
+
+
+
Returns:
+
URLSearchParams object for manipulating query parameters
+
+
+
+
+{`// From query string
+dhoro params1 = url_query_params("?name=John&age=30");
+dhoro params2 = url_query_params("name=John&age=30"); // Works without "?"
+
+// From URL object
+dhoro url = url_parse("https://api.com/users?role=admin");
+dhoro params3 = url_query_params(url.Search);
+
+// Empty params
+dhoro params4 = url_query_params(""); // Create empty params`}
+
+
+
+
+
+ {/* url_query_get */}
+
+
+ url_query_get(params, key)
+
+
+ Gets the value of a query parameter. Returns the first value if multiple exist.
+
+
+
Parameters:
+
+ params (URLSearchParams): The params objectkey (string): The parameter name
+
+
+
Returns:
+
String value of the parameter, or null if not found
+
+
+
+
+{`dhoro params = url_query_params("?name=John&age=30&tag=js&tag=go");
+
+dhoro name = url_query_get(params, "name"); // "John"
+dhoro age = url_query_get(params, "age"); // "30"
+dhoro tag = url_query_get(params, "tag"); // "js" (first value)
+dhoro missing = url_query_get(params, "city"); // null
+
+jodi (name != mittha) {
+ dekho("Name is:", name);
+} nahole {
+ dekho("Name not found");
+}`}
+
+
+
+
+
+ {/* url_query_set */}
+
+
+ url_query_set(params, key, value)
+
+
+ Sets a query parameter value. Replaces all existing values for that key.
+
+
+
Parameters:
+
+ params (URLSearchParams): The params objectkey (string): The parameter namevalue (string): The value to set
+
+
+
Returns:
+
None (modifies params in place)
+
+
+
+
+{`dhoro params = url_query_params("?name=John&age=30");
+
+// Set new parameter
+url_query_set(params, "city", "Boston");
+dekho(url_query_toString(params)); // "name=John&age=30&city=Boston"
+
+// Replace existing parameter
+url_query_set(params, "age", "31");
+dekho(url_query_toString(params)); // "name=John&age=31&city=Boston"
+
+// Set replaces all values if multiple exist
+url_query_set(params, "tag", "first");
+url_query_append(params, "tag", "second");
+url_query_set(params, "tag", "only"); // Removes "first" and "second"
+dekho(url_query_get(params, "tag")); // "only"`}
+
+
+
+
+
+ {/* url_query_append */}
+
+
+ url_query_append(params, key, value)
+
+
+ Appends a query parameter value. Allows multiple values for the same key.
+
+
+
Parameters:
+
+ params (URLSearchParams): The params objectkey (string): The parameter namevalue (string): The value to append
+
+
+
Returns:
+
None (modifies params in place)
+
+
+
+
+{`dhoro params = url_query_params("?name=John");
+
+// Append multiple values for same key
+url_query_append(params, "tag", "javascript");
+url_query_append(params, "tag", "golang");
+url_query_append(params, "tag", "python");
+
+dekho(url_query_toString(params));
+// "name=John&tag=javascript&tag=golang&tag=python"
+
+// Get only returns first value
+dekho(url_query_get(params, "tag")); // "javascript"
+
+// Get all values
+dhoro allTags = url_query_values(params); // ["John", "javascript", "golang", "python"]`}
+
+
+
+
+
+ {/* url_query_delete */}
+
+
+ url_query_delete(params, key)
+
+
+ Removes a query parameter and all its values.
+
+
+
Parameters:
+
+ params (URLSearchParams): The params objectkey (string): The parameter name to remove
+
+
+
Returns:
+
None (modifies params in place)
+
+
+
+
+{`dhoro params = url_query_params("?name=John&age=30&city=Boston");
+
+dekho(url_query_toString(params));
+// "name=John&age=30&city=Boston"
+
+// Delete a parameter
+url_query_delete(params, "age");
+dekho(url_query_toString(params));
+// "name=John&city=Boston"
+
+// Delete removes all values if multiple exist
+url_query_append(params, "tag", "js");
+url_query_append(params, "tag", "go");
+url_query_delete(params, "tag"); // Removes both values
+dekho(url_query_has(params, "tag")); // mittha`}
+
+
+
+
+
+ {/* url_query_has */}
+
+
+ url_query_has(params, key)
+
+
+ Checks if a query parameter exists.
+
+
+
Parameters:
+
+ params (URLSearchParams): The params objectkey (string): The parameter name to check
+
+
+
Returns:
+
Boolean: shotti (true) if parameter exists, mittha (false) otherwise
+
+
+
+
+{`dhoro params = url_query_params("?name=John&age=30");
+
+jodi (url_query_has(params, "name")) {
+ dekho("Name exists:", url_query_get(params, "name"));
+}
+
+jodi (url_query_has(params, "email")) {
+ dekho("Email exists");
+} nahole {
+ dekho("Email not found"); // This will print
+}
+
+// Use for conditional logic
+jodi (!url_query_has(params, "page")) {
+ url_query_set(params, "page", "1"); // Set default page
+}`}
+
+
+
+
+
+ {/* url_query_keys */}
+
+
+ url_query_keys(params)
+
+
+ Returns an array of all query parameter keys.
+
+
+
Parameters:
+
+ params (URLSearchParams): The params object
+
+
+
Returns:
+
Array of strings containing all parameter names (includes duplicates)
+
+
+
+
+{`dhoro params = url_query_params("?name=John&age=30&city=Boston");
+
+dhoro keys = url_query_keys(params);
+dekho(keys); // ["name", "age", "city"]
+
+// Iterate over keys
+ghuriye (dhoro i = 0; i < dorghyo(keys); i = i + 1) {
+ dhoro key = keys[i];
+ dhoro value = url_query_get(params, key);
+ dekho(key, "=", value);
+}
+
+// Multiple values for same key
+url_query_append(params, "tag", "js");
+url_query_append(params, "tag", "go");
+dhoro allKeys = url_query_keys(params);
+// ["name", "age", "city", "tag", "tag"] - duplicates included`}
+
+
+
+
+
+ {/* url_query_values */}
+
+
+ url_query_values(params)
+
+
+ Returns an array of all query parameter values.
+
+
+
Parameters:
+
+ params (URLSearchParams): The params object
+
+
+
Returns:
+
Array of strings containing all parameter values
+
+
+
+
+{`dhoro params = url_query_params("?name=John&age=30&city=Boston");
+
+dhoro values = url_query_values(params);
+dekho(values); // ["John", "30", "Boston"]
+
+// Get all values including duplicates
+url_query_append(params, "tag", "javascript");
+url_query_append(params, "tag", "golang");
+dhoro allValues = url_query_values(params);
+// ["John", "30", "Boston", "javascript", "golang"]
+
+// Iterate over values
+ghuriye (dhoro i = 0; i < dorghyo(values); i = i + 1) {
+ dekho("Value", i, ":", values[i]);
+}`}
+
+
+
+
+
+ {/* url_query_toString */}
+
+
+ url_query_toString(params)
+
+
+ Converts URLSearchParams back to a query string.
+
+
+
Parameters:
+
+ params (URLSearchParams): The params object
+
+
+
Returns:
+
String: URL-encoded query string (without leading "?")
+
+
+
+
+{`dhoro params = url_query_params("");
+
+url_query_set(params, "name", "John Doe");
+url_query_set(params, "age", "30");
+url_query_set(params, "city", "New York");
+
+dhoro queryString = url_query_toString(params);
+dekho(queryString); // "name=John+Doe&age=30&city=New+York"
+
+// Build complete URL
+dhoro baseUrl = "https://api.example.com/users";
+dhoro fullUrl = baseUrl + "?" + queryString;
+dekho(fullUrl);
+// "https://api.example.com/users?name=John+Doe&age=30&city=New+York"
+
+// Special characters are automatically encoded
+url_query_set(params, "search", "hello world & more");
+dekho(url_query_toString(params));
+// "name=John+Doe&age=30&city=New+York&search=hello+world+%26+more"`}
+
+
+
+
+
+
+ {/* Real-World Examples */}
+
+ Real-World Examples
+
+
+ {/* Example 1: API Request Building */}
+
+
Example 1: API Request Building with Query Parameters
+
+ Build API requests dynamically with filters, pagination, and sorting:
+
+
+
+
+{`// Build API URL with dynamic filters
+kaj buildAPIRequest(baseUrl, filters) {
+ dhoro params = url_query_params("");
+
+ // Add filters if provided
+ jodi (url_query_has(filters, "status")) {
+ url_query_set(params, "status", url_query_get(filters, "status"));
+ }
+
+ jodi (url_query_has(filters, "role")) {
+ url_query_set(params, "role", url_query_get(filters, "role"));
+ }
+
+ // Add pagination
+ dhoro page = url_query_has(filters, "page") ?
+ url_query_get(filters, "page") : "1";
+ dhoro limit = url_query_has(filters, "limit") ?
+ url_query_get(filters, "limit") : "20";
+
+ url_query_set(params, "page", page);
+ url_query_set(params, "limit", limit);
+
+ // Add sorting
+ jodi (url_query_has(filters, "sortBy")) {
+ url_query_set(params, "sortBy", url_query_get(filters, "sortBy"));
+ url_query_set(params, "order",
+ url_query_has(filters, "order") ?
+ url_query_get(filters, "order") : "asc"
+ );
+ }
+
+ dhoro queryString = url_query_toString(params);
+ ferao baseUrl + "?" + queryString;
+}
+
+// Usage
+dhoro userFilters = url_query_params("?status=active&role=admin&page=2&sortBy=name");
+dhoro apiUrl = buildAPIRequest("https://api.example.com/users", userFilters);
+dekho(apiUrl);
+// "https://api.example.com/users?status=active&role=admin&page=2&limit=20&sortBy=name&order=asc"
+
+// Make API request
+dhoro response = http_get(apiUrl);
+dekho("Found", dorghyo(response.users), "users");`}
+
+
+
+
+
+ {/* Example 2: GitHub API URL Parsing */}
+
+
Example 2: GitHub API URL Parsing and Manipulation
+
+ Parse and modify GitHub API URLs for repository operations:
+
+
+
+
+{`// Parse GitHub repository URL
+kaj analyzeGitHubURL(githubUrl) {
+ dhoro url = url_parse(githubUrl);
+
+ // Extract repository information
+ dhoro pathParts = bibhajan(url.Pathname, "/");
+ dhoro owner = pathParts[1];
+ dhoro repo = pathParts[2];
+
+ dekho("Repository:", owner + "/" + repo);
+ dekho("API Base:", url.Origin);
+
+ // Parse query parameters
+ dhoro params = url_query_params(url.Search);
+
+ jodi (url_query_has(params, "page")) {
+ dekho("Page:", url_query_get(params, "page"));
+ }
+
+ jodi (url_query_has(params, "per_page")) {
+ dekho("Per Page:", url_query_get(params, "per_page"));
+ }
+
+ // Build issues API URL
+ dhoro issuesParams = url_query_params("");
+ url_query_set(issuesParams, "state", "open");
+ url_query_set(issuesParams, "labels", "bug");
+ url_query_set(issuesParams, "sort", "created");
+ url_query_set(issuesParams, "direction", "desc");
+
+ dhoro issuesUrl = url.Origin + "/repos/" + owner + "/" + repo +
+ "/issues?" + url_query_toString(issuesParams);
+
+ dekho("Issues URL:", issuesUrl);
+ ferao issuesUrl;
+}
+
+// Usage
+dhoro repoUrl = "https://api.github.com/repos/golang/go?page=1&per_page=30";
+dhoro issuesEndpoint = analyzeGitHubURL(repoUrl);
+// Repository: golang/go
+// API Base: https://api.github.com
+// Page: 1
+// Per Page: 30
+// Issues URL: https://api.github.com/repos/golang/go/issues?state=open&labels=bug&sort=created&direction=desc
+
+// Fetch issues
+dhoro response = http_get(issuesEndpoint);
+dekho("Found", dorghyo(response), "open bug issues");`}
+
+
+
+
+
+ {/* Example 3: Search/Filter URL Construction */}
+
+
Example 3: Search and Filter URL Construction
+
+ Build complex search URLs with multiple filters and tags:
+
+
+
+
+{`// Build search URL with multiple filters
+kaj buildSearchURL(searchTerm, tags, options) {
+ dhoro baseUrl = "https://example.com/search";
+ dhoro params = url_query_params("");
+
+ // Add search term (encoded automatically)
+ jodi (searchTerm != "" && searchTerm != mittha) {
+ url_query_set(params, "q", searchTerm);
+ }
+
+ // Add multiple tags
+ jodi (tags != mittha && dorghyo(tags) > 0) {
+ ghuriye (dhoro i = 0; i < dorghyo(tags); i = i + 1) {
+ url_query_append(params, "tag", tags[i]);
+ }
+ }
+
+ // Add optional filters
+ jodi (options != mittha) {
+ jodi (url_query_has(options, "category")) {
+ url_query_set(params, "category", url_query_get(options, "category"));
+ }
+
+ jodi (url_query_has(options, "minPrice")) {
+ url_query_set(params, "minPrice", url_query_get(options, "minPrice"));
+ }
+
+ jodi (url_query_has(options, "maxPrice")) {
+ url_query_set(params, "maxPrice", url_query_get(options, "maxPrice"));
+ }
+
+ jodi (url_query_has(options, "sortBy")) {
+ url_query_set(params, "sortBy", url_query_get(options, "sortBy"));
+ }
+ }
+
+ // Build final URL
+ dhoro queryString = url_query_toString(params);
+ ferao queryString != "" ? baseUrl + "?" + queryString : baseUrl;
+}
+
+// Usage 1: Simple search
+dhoro url1 = buildSearchURL("laptop computers", mittha, mittha);
+dekho(url1);
+// "https://example.com/search?q=laptop+computers"
+
+// Usage 2: Search with tags
+dhoro tags = ["electronics", "computers", "portable"];
+dhoro url2 = buildSearchURL("gaming laptop", tags, mittha);
+dekho(url2);
+// "https://example.com/search?q=gaming+laptop&tag=electronics&tag=computers&tag=portable"
+
+// Usage 3: Full featured search
+dhoro filters = url_query_params("?category=electronics&minPrice=500&maxPrice=2000&sortBy=price");
+dhoro url3 = buildSearchURL("laptop", tags, filters);
+dekho(url3);
+// "https://example.com/search?q=laptop&tag=electronics&tag=computers&tag=portable&category=electronics&minPrice=500&maxPrice=2000&sortBy=price"
+
+// Parse existing search URL to modify
+dhoro existingUrl = url_parse(url3);
+dhoro existingParams = url_query_params(existingUrl.Search);
+
+// Modify filters
+url_query_set(existingParams, "maxPrice", "1500");
+url_query_delete(existingParams, "sortBy");
+url_query_set(existingParams, "sortBy", "rating");
+
+dhoro modifiedUrl = existingUrl.Origin + existingUrl.Pathname +
+ "?" + url_query_toString(existingParams);
+dekho("Modified:", modifiedUrl);`}
+
+
+
+
+
+
+ {/* Best Practices */}
+
+ Best Practices
+
+
+
+
+ ✅ DO: Always Validate URLs
+
+
+ Check that URLs are valid before parsing. Handle parsing errors gracefully and provide meaningful error messages to users.
+
+
+
+
+
+ ✅ DO: Use url_query_has() Before Getting
+
+
+ Always check if a parameter exists before getting its value. This prevents null reference errors and makes your code more robust.
+
+
+
+
+
+ ✅ DO: Let the API Handle Encoding
+
+
+ The API automatically encodes special characters in query parameters. Don't manually encode - let url_query_set() and url_query_append() handle it.
+
+
+
+
+
+ ✅ DO: Use Append for Multiple Values
+
+
+ Use url_query_append() when you need multiple values for the same parameter (e.g., tags, filters). Use url_query_set() to replace all values.
+
+
+
+
+
+ ❌ DON'T: Manually Build Query Strings
+
+
+ Never concatenate query strings manually with "&" and "=". Use URLSearchParams to ensure proper encoding and avoid injection vulnerabilities.
+
+
+
+
+
+ ❌ DON'T: Assume Parameter Existence
+
+
+ Don't assume query parameters exist without checking. url_query_get() returns null for missing parameters - always handle this case.
+
+
+
+
+
+ ❌ DON'T: Trust User Input URLs
+
+
+ Always validate and sanitize URLs from user input. Check the protocol, hostname, and parameters to prevent security issues like SSRF.
+
+
+
+
+
+ ❌ DON'T: Modify URL Strings Directly
+
+
+ Don't use string manipulation to modify URLs. Parse the URL, modify the URLSearchParams, then reconstruct - this ensures correctness.
+
+
+
+
+ {/* Performance Tips */}
+
+ Performance Tips
+
+
+
+
+
🚀
+
+
Cache Parsed URLs
+
+ If you're parsing the same URL multiple times, cache the parsed result. URL parsing is relatively fast but caching can improve performance in tight loops.
+
+
+
+
+
+
💾
+
+
Reuse URLSearchParams Objects
+
+ Create a URLSearchParams object once and modify it as needed rather than creating new ones. This is more efficient for building multiple similar URLs.
+
+
+
+
+
+
⚡
+
+
Batch Parameter Operations
+
+ When setting multiple parameters, do all operations before calling url_query_toString(). Convert to string only once at the end.
+
+
+
+
+
+
🔄
+
+
Avoid Redundant Parsing
+
+ Don't parse a URL, convert it to string, and parse it again. Keep the parsed objects in memory and only convert to strings when needed for HTTP requests.
+
+
+
+
+
+
📦
+
+
Minimize Query String Size
+
+ Keep query strings concise. Use short parameter names and remove unnecessary parameters. Large query strings can impact performance and may hit browser/server limits.
+
+
+
+
+
+
+ {/* Common Patterns */}
+
+ Common Patterns
+
+
+
+
Pattern 1: URL Builder Helper
+
+
+
+{`// Reusable URL builder
+kaj URLBuilder(baseUrl) {
+ dhoro params = url_query_params("");
+
+ ferao {
+ setParam: kaj(key, value) {
+ url_query_set(params, key, value);
+ ferao ei; // Return self for chaining
+ },
+
+ appendParam: kaj(key, value) {
+ url_query_append(params, key, value);
+ ferao ei;
+ },
+
+ removeParam: kaj(key) {
+ url_query_delete(params, key);
+ ferao ei;
+ },
+
+ build: kaj() {
+ dhoro queryString = url_query_toString(params);
+ ferao queryString != "" ? baseUrl + "?" + queryString : baseUrl;
+ }
+ };
+}
+
+// Usage with method chaining
+dhoro url = URLBuilder("https://api.example.com/users")
+ .setParam("status", "active")
+ .setParam("role", "admin")
+ .setParam("page", "1")
+ .appendParam("tag", "verified")
+ .appendParam("tag", "premium")
+ .build();
+
+dekho(url);
+// "https://api.example.com/users?status=active&role=admin&page=1&tag=verified&tag=premium"`}
+
+
+
+
+
+
+
Pattern 2: Query Parameter Merger
+
+
+
+{`// Merge query parameters from multiple sources
+kaj mergeQueryParams(params1, params2) {
+ dhoro merged = url_query_params("");
+
+ // Add all from first params
+ dhoro keys1 = url_query_keys(params1);
+ dhoro values1 = url_query_values(params1);
+ ghuriye (dhoro i = 0; i < dorghyo(keys1); i = i + 1) {
+ url_query_append(merged, keys1[i], values1[i]);
+ }
+
+ // Add all from second params (may override)
+ dhoro keys2 = url_query_keys(params2);
+ dhoro values2 = url_query_values(params2);
+ ghuriye (dhoro i = 0; i < dorghyo(keys2); i = i + 1) {
+ // Use set to override, or append to add multiple
+ url_query_set(merged, keys2[i], values2[i]);
+ }
+
+ ferao merged;
+}
+
+// Usage
+dhoro defaultParams = url_query_params("?limit=20&sort=asc");
+dhoro userParams = url_query_params("?page=5&filter=active");
+dhoro finalParams = mergeQueryParams(defaultParams, userParams);
+
+dekho(url_query_toString(finalParams));
+// "limit=20&sort=asc&page=5&filter=active"`}
+
+
+
+
+
+
+
Pattern 3: URL Router
+
+
+
+{`// Route handler based on URL path and params
+kaj routeRequest(urlString) {
+ dhoro url = url_parse(urlString);
+ dhoro path = url.Pathname;
+ dhoro params = url_query_params(url.Search);
+
+ // Route based on path
+ jodi (path == "/api/users") {
+ // Handle users endpoint
+ dhoro page = url_query_has(params, "page") ?
+ url_query_get(params, "page") : "1";
+ dhoro limit = url_query_has(params, "limit") ?
+ url_query_get(params, "limit") : "20";
+
+ ferao handleUsers(page, limit, params);
+
+ } nahole jodi (path == "/api/products") {
+ // Handle products endpoint
+ dhoro category = url_query_get(params, "category");
+ dhoro minPrice = url_query_get(params, "minPrice");
+ dhoro maxPrice = url_query_get(params, "maxPrice");
+
+ ferao handleProducts(category, minPrice, maxPrice);
+
+ } nahole jodi (khuje(path, "/api/users/") == 0) {
+ // Handle specific user by ID
+ dhoro pathParts = bibhajan(path, "/");
+ dhoro userId = pathParts[3];
+
+ ferao handleUserById(userId, params);
+ }
+
+ ferao {status: 404, message: "Route not found"};
+}
+
+// Helper functions
+kaj handleUsers(page, limit, params) {
+ dhoro filters = [];
+
+ jodi (url_query_has(params, "status")) {
+ joro(filters, "status=" + url_query_get(params, "status"));
+ }
+
+ jodi (url_query_has(params, "role")) {
+ joro(filters, "role=" + url_query_get(params, "role"));
+ }
+
+ dekho("Fetching users: page=" + page + ", limit=" + limit);
+ dekho("Filters:", joro(filters, ", "));
+
+ ferao {status: 200, data: "users list"};
+}
+
+// Usage
+dhoro result = routeRequest("https://api.com/api/users?page=2&status=active&role=admin");
+dekho(result);`}
+
+
+
+
+
+
+
Pattern 4: Pagination Helper
+
+
+
+{`// Build paginated URLs
+kaj buildPaginationURLs(currentUrl, totalPages) {
+ dhoro url = url_parse(currentUrl);
+ dhoro params = url_query_params(url.Search);
+
+ dhoro currentPage = url_query_has(params, "page") ?
+ text_shongkha(url_query_get(params, "page")) : 1;
+
+ dhoro baseUrl = url.Origin + url.Pathname;
+
+ // Build URL for specific page
+ dhoro buildPageUrl = kaj(pageNum) {
+ dhoro newParams = url_query_params(url.Search);
+ url_query_set(newParams, "page", shongkha_text(pageNum));
+ ferao baseUrl + "?" + url_query_toString(newParams);
+ };
+
+ dhoro urls = {
+ first: buildPageUrl(1),
+ prev: currentPage > 1 ? buildPageUrl(currentPage - 1) : mittha,
+ current: currentUrl,
+ next: currentPage < totalPages ? buildPageUrl(currentPage + 1) : mittha,
+ last: buildPageUrl(totalPages)
+ };
+
+ ferao urls;
+}
+
+// Usage
+dhoro currentUrl = "https://api.com/users?status=active&page=3&limit=20";
+dhoro pagination = buildPaginationURLs(currentUrl, 10);
+
+dekho("First:", pagination.first);
+dekho("Previous:", pagination.prev);
+dekho("Next:", pagination.next);
+dekho("Last:", pagination.last);`}
+
+
+
+
+
+
+ {/* Related APIs */}
+
+
+ {/* Summary */}
+
+ Summary
+
+
+ The URL Parsing API in BanglaCode provides comprehensive tools for working with URLs and query parameters. Whether you're building web APIs, parsing external URLs, or constructing complex query strings, these functions make URL operations safe, reliable, and easy.
+
+
+ Key benefits:
+
+
+ - Complete URL Parsing: Extract all components from any URL string
+ - Safe Query Handling: Automatic encoding/decoding prevents injection attacks
+ - Flexible Parameters: Support for single and multiple values per key
+ - Easy Manipulation: Simple API for getting, setting, and deleting parameters
+ - API Integration: Perfect for building REST API clients and web services
+
+
+ Use the URL Parsing API whenever you need to work with web addresses, build API requests, handle query parameters, or route requests based on URL patterns. Combined with the HTTP API, it provides everything you need for web and API development.
+
+
+
+
+
Worker Threads (কাজ কর্মী)
+
+ True parallel processing with worker threads for CPU-intensive tasks, enabling multi-core utilization in BanglaCode.
+
+
+
+ {/* Overview */}
+
+ Overview
+
+ Worker Threads enable true parallelism in BanglaCode by running code in separate threads. Unlike async/await which handles
+ concurrency, workers leverage multiple CPU cores for CPU-bound tasks:
+
+
+ - Parallel execution: Run multiple tasks simultaneously on different CPU cores
+ - Non-blocking: Workers run independently without blocking the main thread
+ - Message passing: Communicate via messages (no shared memory)
+ - Isolated state: Each worker has its own environment and variables
+
+
+
+ ⚡ Use Cases: Image processing, data analysis, cryptography, large file parsing,
+ mathematical computations, video encoding, or any CPU-intensive task that would block the main thread.
+
+
+
+ {/* Quick Start */}
+
+ Quick Start
+
+
+ {`// Create a worker
+dhoro worker = kaj_kormi_srishti(kaj() {
+ dekho("Worker running on separate thread!");
+
+ // Perform CPU-intensive task
+ dhoro sum = 0;
+ ghuriye (dhoro i = 0; i < 1000000; i = i + 1) {
+ sum = sum + i;
+ }
+ dekho("Computation complete:", sum);
+});
+
+// Send messages to worker
+kaj_kormi_pathao(worker, "Process this data");
+
+// Terminate when done
+process_ghum(2000);
+kaj_kormi_bondho(worker);`}
+
+
+
+ {/* API Reference */}
+
+ API Reference
+
+ {/* kaj_kormi_srishti */}
+
+
+ kaj_kormi_srishti(fn, data?)
+
+
কাজ কর্মী সৃষ্টি - Create worker
+
Creates a new worker thread that executes the given function in parallel.
+
+
+ {`// Basic worker
+dhoro worker = kaj_kormi_srishti(kaj() {
+ dekho("Worker started");
+});
+
+// Worker with initial data
+dhoro worker = kaj_kormi_srishti(kaj() {
+ dhoro config = kaj_kormi_tothya;
+ dekho("Config:", config);
+}, {"threads": 4, "mode": "fast"});`}
+
+
+
+
Parameters:
+
+ fn (Function) - Function to execute in worker threaddata (Any, optional) - Initial data accessible via kaj_kormi_tothya
+
Returns: Worker object
+
+
+
+ kaj_kormi_pathao(worker, message)
+
+
কাজ কর্মী পাঠাও - Send to worker
+
Sends a message to the worker thread. Worker can receive via message handlers.
+
+
+ {`kaj_kormi_pathao(worker, "START");
+kaj_kormi_pathao(worker, {"action": "process", "data": [1, 2, 3]});
+kaj_kormi_pathao(worker, 42);`}
+
+
+
+
Parameters:
+
+ worker (Worker) - Target workermessage (Any) - Message to send (string, number, object, array)
+
Returns: null
+
+
+
+ kaj_kormi_bondho(worker)
+
+
কাজ কর্মী বন্ধ - Stop worker
+
Terminates the worker thread immediately. Worker will stop execution and clean up resources.
+
+
+ {`kaj_kormi_bondho(worker); // Stop worker immediately`}
+
+
+
+
Parameters:
+
+ worker (Worker) - Worker to terminate
+
Returns: null
+
+
+
+ kaj_kormi_shuno(worker, callback)
+
+
কাজ কর্মী শুনো - Listen to worker
+
Sets up a listener for messages from the worker. Called when worker sends data back to parent.
+
+
+ {`kaj_kormi_shuno(worker, kaj(data) {
+ dekho("Worker sent:", data);
+
+ jodi (data == "DONE") {
+ kaj_kormi_bondho(worker);
+ }
+});`}
+
+
+
+
Parameters:
+
+ worker (Worker) - Worker to listen tocallback (Function) - Handler called with message data
+
Returns: null
+
+
+
+ kaj_kormi_tothya
+
+
কাজ কর্মী তথ্য - Worker data
+
Special variable accessible inside worker function containing initial data passed during worker creation.
+
+
+ {`dhoro worker = kaj_kormi_srishti(kaj() {
+ // Access initial data
+ dhoro config = kaj_kormi_tothya;
+ dekho("Processing with config:", config);
+}, {"mode": "fast", "threads": 4});`}
+
+
+
+
+ {/* Real-World Examples */}
+
+ Real-World Examples
+
+ {/* Example 1: Parallel Data Processing */}
+
+
Example 1: Parallel Data Processing
+
+ Process large datasets in parallel by dividing work across multiple workers.
+
+
+
+ {`// Divide array processing across 4 workers
+dhoro data = [];
+ghuriye (dhoro i = 0; i < 1000; i = i + 1) {
+ data = dhaaka(data, i);
+}
+
+dhoro numWorkers = 4;
+dhoro chunkSize = dorghyo(data) / numWorkers;
+dhoro workers = [];
+dhoro results = [];
+
+// Create workers for each chunk
+ghuriye (dhoro i = 0; i < numWorkers; i = i + 1) {
+ dhoro start = i * chunkSize;
+ dhoro end = start + chunkSize;
+ dhoro chunk = [];
+
+ ghuriye (dhoro j = start; j < end; j = j + 1) {
+ chunk = dhaaka(chunk, data[j]);
+ }
+
+ dhoro worker = kaj_kormi_srishti(kaj() {
+ dhoro chunk = kaj_kormi_tothya;
+ dhoro sum = 0;
+
+ // Process chunk
+ ghuriye (dhoro k = 0; k < dorghyo(chunk); k = k + 1) {
+ sum = sum + chunk[k] * chunk[k]; // Square each number
+ }
+
+ dekho("Worker", i, "completed. Sum:", sum);
+ }, chunk);
+
+ workers = dhaaka(workers, worker);
+}
+
+// Wait for all workers
+process_ghum(2000);
+
+// Clean up
+ghuriye (dhoro i = 0; i < dorghyo(workers); i = i + 1) {
+ kaj_kormi_bondho(workers[i]);
+}
+
+dekho("All workers completed!");`}
+
+
+
+
Example 2: CPU-Intensive Prime Calculation
+
+ Offload CPU-heavy computation to worker without blocking main thread.
+
+
+
+ {`// Main thread remains responsive
+dekho("Starting prime calculation...");
+
+dhoro primeWorker = kaj_kormi_srishti(kaj() {
+ // Check if number is prime
+ kaj isPrime(n) {
+ jodi (n <= 1) { ferao mittha; }
+ ghuriye (dhoro i = 2; i * i <= n; i = i + 1) {
+ jodi (n % i == 0) { ferao mittha; }
+ }
+ ferao sotti;
+ }
+
+ // Find all primes up to 10000
+ dhoro primes = [];
+ ghuriye (dhoro i = 2; i <= 10000; i = i + 1) {
+ jodi (isPrime(i)) {
+ primes = dhaaka(primes, i);
+ }
+ }
+
+ dekho("Found", dorghyo(primes), "primes");
+}, khali);
+
+// Main thread continues executing
+dekho("Main thread still responsive!");
+
+// Wait for worker to complete
+process_ghum(3000);
+kaj_kormi_bondho(primeWorker);`}
+
+
+
+
Example 3: Batch Processing with Multiple Workers
+
+ Process multiple items in parallel with a worker pool pattern.
+
+
+
+ {`// Simulate processing multiple files in parallel
+dhoro files = ["file1.txt", "file2.txt", "file3.txt", "file4.txt"];
+dhoro workers = [];
+dhoro completed = 0;
+
+ghuriye (dhoro i = 0; i < dorghyo(files); i = i + 1) {
+ dhoro worker = kaj_kormi_srishti(kaj() {
+ dhoro filename = kaj_kormi_tothya;
+
+ dekho("Processing", filename);
+
+ // Simulate heavy processing
+ dhoro operations = 0;
+ ghuriye (dhoro j = 0; j < 1000000; j = j + 1) {
+ operations = operations + 1;
+ }
+
+ dekho("Completed", filename);
+ }, files[i]);
+
+ workers = dhaaka(workers, worker);
+}
+
+// Wait for all workers
+process_ghum(3000);
+
+// Terminate all workers
+ghuriye (dhoro i = 0; i < dorghyo(workers); i = i + 1) {
+ kaj_kormi_bondho(workers[i]);
+}
+
+dekho("All files processed!");`}
+
+
+
+
+ {/* Best Practices */}
+
+ Best Practices
+
+
+
+
✅ DO:
+
+ - Use for CPU-bound tasks: Image processing, data analysis, cryptography
+ - Always terminate workers: Call
kaj_kormi_bondho() when done to free resources
+ - Divide work efficiently: Split large tasks into chunks for parallel processing
+ - Limit worker count: Create workers based on CPU core count (typically 2-8 workers)
+ - Pass immutable data: Send copies of data to avoid race conditions
+
+
+
+
+
❌ DON'T:
+
+ - Don't use for I/O operations: Use async/await instead (file reading, network requests)
+ - Don't create too many workers: More workers than CPU cores causes overhead
+ - Don't share state: Workers have isolated environments - pass data via messages
+ - Don't forget cleanup: Unterminated workers consume memory and CPU
+ - Don't use for small tasks: Worker overhead can exceed computation time
+
+
+
+
+ {/* Performance Considerations */}
+
+ Performance Considerations
+
+
+
⚡ Optimization Tips:
+
+ -
+ Worker pool pattern: Reuse workers for multiple tasks instead of creating new ones
+
+ -
+ Optimal worker count: Number of workers = CPU cores (check with
cpu_sonkha())
+
+ -
+ Chunk size matters: Balance between parallelism and overhead (chunks too small = overhead, too large = less parallel)
+
+ -
+ Measure overhead: Worker creation has cost - only use for tasks > 100ms
+
+
+
+
When to Use Workers vs Async:
+
+
+
✓ Use Workers for:
+
+ - Heavy computations (math, crypto)
+ - Data processing (parsing, transforming)
+ - Image/video processing
+ - Tasks that block > 100ms
+
+
+
+
✓ Use Async for:
+
+ - Network requests (HTTP, WebSocket)
+ - File I/O (reading/writing)
+ - Database queries
+ - Any I/O-bound operation
+
+
+
+
+
+ {/* Common Use Cases */}
+
+ Common Use Cases
+
+
+
Data Processing
+
+ Parse and transform large datasets (CSV, JSON) in parallel chunks for faster processing.
+
+
+
+
Cryptography
+
+ Hash generation, encryption/decryption operations that are CPU-intensive.
+
+
+
+
Mathematical Computation
+
+ Prime finding, matrix operations, statistical analysis running in parallel.
+
+
+
+
Batch Processing
+
+ Process multiple files, images, or documents simultaneously with worker pool.
+
+
+
+
+ {/* Related Features */}
+
+
+ {/* Summary */}
+
+ Summary
+
+ Worker Threads bring true parallel processing to BanglaCode, enabling efficient multi-core CPU utilization for
+ compute-intensive tasks. Use workers for CPU-bound operations, async/await for I/O-bound operations.
+
+
+ Key takeaways: Create workers with kaj_kormi_srishti(), communicate via messages,
+ always terminate with kaj_kormi_bondho(), and optimize worker count based on CPU cores.
+
+
+