Functions

1
// Array search helpers
2
dhoro first = khojo_prothom([1, 3, 8, 10], kaj(x) { ferao x > 5; });      // 8
3
dhoro idx = khojo_index([1, 3, 8, 10], kaj(x) { ferao x > 5; });           // 2
4
dhoro last = khojo_shesh([1, 3, 8, 10], kaj(x) { ferao x % 2 == 0; });     // 10
5
6
// String helpers
7
ache_text("banglacode", "code");        // sotti
8
shuru_diye("banglacode", "bang");       // sotti
9
shesh_diye("banglacode", "code");       // sotti
10
baro("ha", 3);                          // "hahaha"
11
text_at("bangla", -1);                  // "a"
12
13
// Number + URI helpers
14
purno_sonkhya("42");                    // 42
15
doshomik_sonkhya("3.14abc");            // 3.14
16
sonkhya_na("abc");                      // sotti
17
uri_ongsho_encode("hello world");       // "hello%20world"
18
19
// Date + Regex helpers
20
dhoro ts = tarikh_ekhon();
21
tarikh_format(ts, "2006-01-02");
22
regex_test("[a-z]+", "bangla");         // sotti
23
regex_search("la", "bangla");           // 4
24
25
// Object helpers
26
nijer_ache({a: 1}, "a");                // sotti
27
jora_theke([["x", 10], ["y", 20]]);     // {x: 10, y: 20}
28
ekoi_ki(1, 1);                           // sotti
29
30
// Timers
31
dhoro id = setInterval(kaj() { dekho("tick"); }, 1000);
32
clearInterval(id);

1
// Basic function definition
2
kaj greet() {
3
    dekho("Namaskar!");
4
}
5
6
// Call the function
7
greet();  // Output: Namaskar!

1
kaj greetPerson(naam) {
2
    dekho("Namaskar,", naam);
3
}
4
5
greetPerson("Rahim");   // Namaskar, Rahim
6
greetPerson("Karim");   // Namaskar, Karim
7
8
// Multiple parameters
9
kaj add(a, b) {
10
    dekho(a, "+", b, "=", a + b);
11
}
12
13
add(5, 3);  // 5 + 3 = 8

1
kaj add(a, b) {
2
    ferao a + b;
3
}
4
5
dhoro sum = add(10, 20);
6
dekho(sum);  // 30
7
8
// Use return value directly
9
dekho(add(5, 3) * 2);  // 16
10
11
// Function without return returns null
12
kaj sayHello() {
13
    dekho("Hello!");
14
}
15
16
dhoro result = sayHello();
17
dekho(result == khali);  // sotti

1
kaj getGrade(score) {
2
    jodi (score >= 90) {
3
        ferao "A";
4
    }
5
    jodi (score >= 80) {
6
        ferao "B";
7
    }
8
    jodi (score >= 70) {
9
        ferao "C";
10
    }
11
    jodi (score >= 60) {
12
        ferao "D";
13
    }
14
    ferao "F";
15
}
16
17
dekho(getGrade(85));  // B
18
dekho(getGrade(55));  // F

1
// Anonymous function assigned to variable
2
dhoro multiply = kaj(x, y) {
3
    ferao x * y;
4
};
5
6
dekho(multiply(4, 5));  // 20
7
8
// Functions as array elements
9
dhoro operations = [
10
    kaj(a, b) { ferao a + b; },
11
    kaj(a, b) { ferao a - b; },
12
    kaj(a, b) { ferao a * b; },
13
    kaj(a, b) { ferao a / b; }
14
];
15
16
dekho(operations[0](10, 5));  // 15 (addition)
17
dekho(operations[2](10, 5));  // 50 (multiplication)

1
// Function that takes a function as argument
2
kaj applyOperation(a, b, operation) {
3
    ferao operation(a, b);
4
}
5
6
kaj add(x, y) { ferao x + y; }
7
kaj multiply(x, y) { ferao x * y; }
8
9
dekho(applyOperation(5, 3, add));       // 8
10
dekho(applyOperation(5, 3, multiply));  // 15
11
12
// Function that returns a function
13
kaj makeMultiplier(factor) {
14
    ferao kaj(n) {
15
        ferao n * factor;
16
    };
17
}
18
19
dhoro double = makeMultiplier(2);
20
dhoro triple = makeMultiplier(3);
21
22
dekho(double(5));   // 10
23
dekho(triple(5));   // 15

1
kaj makeCounter() {
2
    dhoro count = 0;
3
4
    ferao kaj() {
5
        count = count + 1;
6
        ferao count;
7
    };
8
}
9
10
dhoro counter1 = makeCounter();
11
dhoro counter2 = makeCounter();
12
13
dekho(counter1());  // 1
14
dekho(counter1());  // 2
15
dekho(counter1());  // 3
16
17
dekho(counter2());  // 1 (separate counter)
18
dekho(counter2());  // 2

1
kaj createBankAccount(initialBalance) {
2
    dhoro balance = initialBalance;
3
4
    ferao {
5
        deposit: kaj(amount) {
6
            balance = balance + amount;
7
            dekho("Deposited:", amount, "- Balance:", balance);
8
        },
9
        withdraw: kaj(amount) {
10
            jodi (amount > balance) {
11
                dekho("Insufficient funds!");
12
                ferao mittha;
13
            }
14
            balance = balance - amount;
15
            dekho("Withdrew:", amount, "- Balance:", balance);
16
            ferao sotti;
17
        },
18
        getBalance: kaj() {
19
            ferao balance;
20
        }
21
    };
22
}
23
24
dhoro account = createBankAccount(1000);
25
account.deposit(500);     // Deposited: 500 - Balance: 1500
26
account.withdraw(200);    // Withdrew: 200 - Balance: 1300
27
dekho(account.getBalance());  // 1300

1
// Factorial
2
kaj factorial(n) {
3
    jodi (n <= 1) {
4
        ferao 1;
5
    }
6
    ferao n * factorial(n - 1);
7
}
8
9
dekho(factorial(5));  // 120
10
11
// Fibonacci
12
kaj fibonacci(n) {
13
    jodi (n <= 1) {
14
        ferao n;
15
    }
16
    ferao fibonacci(n - 1) + fibonacci(n - 2);
17
}
18
19
dekho(fibonacci(10));  // 55
20
21
// Sum of array using recursion
22
kaj sumArray(arr, index) {
23
    jodi (index >= dorghyo(arr)) {
24
        ferao 0;
25
    }
26
    ferao arr[index] + sumArray(arr, index + 1);
27
}
28
29
dekho(sumArray([1, 2, 3, 4, 5], 0));  // 15

1
kaj greet(naam, greeting) {
2
    // Check if parameter is provided
3
    jodi (greeting == khali) {
4
        greeting = "Namaskar";
5
    }
6
    dekho(greeting + ",", naam);
7
}
8
9
greet("Rahim", "Hello");     // Hello, Rahim
10
greet("Karim", khali);       // Namaskar, Karim

1
// Variadic function with rest parameter
2
kaj sum(...numbers) {
3
    dhoro total = 0;
4
    ghuriye (dhoro i = 0; i < dorghyo(numbers); i = i + 1) {
5
        total = total + numbers[i];
6
    }
7
    ferao total;
8
}
9
10
dekho(sum(1, 2, 3));           // 6
11
dekho(sum(1, 2, 3, 4, 5));     // 15
12
dekho(sum());                   // 0
13
14
// Mixed regular parameters with rest
15
kaj greetAll(greeting, ...names) {
16
    ghuriye (dhoro i = 0; i < dorghyo(names); i = i + 1) {
17
        dekho(greeting, names[i]);
18
    }
19
}
20
21
greetAll("Hello", "Alice", "Bob", "Charlie");
22
// Hello Alice
23
// Hello Bob
24
// Hello Charlie

1
// Spread in function calls
2
kaj sum(...numbers) {
3
    dhoro total = 0;
4
    ghuriye (dhoro i = 0; i < dorghyo(numbers); i = i + 1) {
5
        total = total + numbers[i];
6
    }
7
    ferao total;
8
}
9
10
dhoro nums = [1, 2, 3, 4, 5];
11
dekho(sum(...nums));  // 15
12
13
// Combine with regular arguments
14
dekho(sum(10, ...nums, 20));  // 10 + 1 + 2 + 3 + 4 + 5 + 20 = 45
15
16
// Spread in array literals
17
dhoro arr1 = [1, 2];
18
dhoro arr2 = [3, 4];
19
dhoro combined = [...arr1, ...arr2];  // [1, 2, 3, 4]
20
dhoro withExtra = [0, ...arr1, 99];   // [0, 1, 2, 99]
21
22
// Clone an array
23
dhoro original = [1, 2, 3];
24
dhoro copy = [...original];
25
26
// Spread with dekho
27
dhoro items = ["apple", "banana", "cherry"];
28
dekho(...items);  // apple banana cherry

1
// Process array with callback
2
kaj forEach(arr, callback) {
3
    ghuriye (dhoro i = 0; i < dorghyo(arr); i = i + 1) {
4
        callback(arr[i], i);
5
    }
6
}
7
8
dhoro numbers = [1, 2, 3, 4, 5];
9
10
forEach(numbers, kaj(value, index) {
11
    dekho("Index", index, ":", value);
12
});
13
14
// Custom map function
15
kaj map(arr, transform) {
16
    dhoro result = [];
17
    ghuriye (dhoro i = 0; i < dorghyo(arr); i = i + 1) {
18
        dhokao(result, transform(arr[i]));
19
    }
20
    ferao result;
21
}
22
23
dhoro doubled = map([1, 2, 3], kaj(n) { ferao n * 2; });
24
dekho(doubled);  // [2, 4, 6]
25
26
// Custom filter function
27
kaj filter(arr, predicate) {
28
    dhoro result = [];
29
    ghuriye (dhoro i = 0; i < dorghyo(arr); i = i + 1) {
30
        jodi (predicate(arr[i])) {
31
            dhokao(result, arr[i]);
32
        }
33
    }
34
    ferao result;
35
}
36
37
dhoro evens = filter([1, 2, 3, 4, 5, 6], kaj(n) { ferao n % 2 == 0; });
38
dekho(evens);  // [2, 4, 6]

1
// Memoized Fibonacci
2
kaj createMemoizedFib() {
3
    dhoro cache = {};
4
5
    ferao kaj(n) {
6
        jodi (n <= 1) {
7
            ferao n;
8
        }
9
10
        dhoro key = lipi(n);
11
        jodi (cache[key] != khali) {
12
            ferao cache[key];
13
        }
14
15
        dhoro result = ei(n - 1) + ei(n - 2);
16
        cache[key] = result;
17
        ferao result;
18
    };
19
}
20
21
dhoro fib = createMemoizedFib();
22
dekho(fib(40));  // Much faster with memoization!

1
kaj compose(f, g) {
2
    ferao kaj(x) {
3
        ferao f(g(x));
4
    };
5
}
6
7
kaj addOne(n) { ferao n + 1; }
8
kaj double(n) { ferao n * 2; }
9
10
dhoro addOneThenDouble = compose(double, addOne);
11
dekho(addOneThenDouble(5));  // 12 ((5+1)*2)
12
13
dhoro doubleThenAddOne = compose(addOne, double);
14
dekho(doubleThenAddOne(5));  // 11 ((5*2)+1)