JavaScript

function factorial(n) {
    if (n === 0) {
        return 1;
    }
    return n * factorial(n - 1); 
}

var nama = prompt("Nama:zulhaidi:akmal?");
alert("Selamat datang "+nama);

function add (i, j) {
    var add_pri = function (x, y) {
        return x + y;
    };

    return add_pri(i, j);
}

function showclosure () {
    var inc = makeinc(1);

    inc(); // 1
    inc(); // 2
    inc(); // 3
}

function makeinc (initialValue) {
    var count = initialValue;

    return function () {
        return count++;
    };
}

function unlimited_args () {
    for (var i = 0; i < arguments.length; i++) {
        alert(arguments[i]);
    }
}

unlimited_args(1, 2, 3);

/* Finds the lowest common multiple of two numbers */
function LCMCalculator (x, y) { // constructor function
    var checkInt = function (x) { // inner function
        if (x % 1 !== 0) {
            throw new TypeError(x + "is not an integer"); // exception throwing
        }
        return x;
    };
    this.a = checkInt(x)
    // ^ semicolons are optional (but beware since this may cause consecutive lines to be
    //erroneously treated as a single statement)
    this.b = checkInt(y);
}
// The prototype of object instances created by a constructor is 
// that constructor's "prototype" property.
LCMCalculator.prototype = { // object literal
    constructor : LCMCalculator, // when reassigning a prototype, set the constructor property appropriately
    gcd : function () { // method that calculates the greatest common divisor
        // Euclidean algorithm:
        var a = Math.abs(this.a), b = Math.abs(this.b), t;
        if (a < b) {
            // swap variables
            t = b; 
            b = a; 
            a = t; 
        }
        while (b !== 0) {
            t = b;
            b = a % b;
            a = t;
        }
        // Only need to calculate gcd once, so "redefine" this method.
        // (Actually not redefinition - it's defined on the instance itself,
        // so that this.gcd refers to this "redefinition" instead of LCMCalculator.prototype.gcd.)
        // Also, 'gcd' == "gcd", this['gcd'] == this.gcd
        this['gcd'] = function () { 
            return a; 
        };
        return a;
    },
    "lcm" /* can use strings here */: function () {
        // Variable names don't collide with object properties, e.g. |lcm| is not |this.lcm|.
        // not using |this.a * this.b| to avoid FP precision issues
        var lcm = this.a / this.gcd() * this.b; 
        // Only need to calculate lcm once, so "redefine" this method.
        this.lcm = function () { 
            return lcm; 
        };

        return lcm;
    },
    toString : function () {
        return "LCMCalculator: a = " + this.a + ", b = " + this.b;
    }
};

// Note: Array's map() and forEach() are predefined in JavaScript 1.6.
// They are currently not available in the JScript engine built into
// Microsoft Internet Explorer, but are implemented in Firefox, Chrome, etc.
// They are used here to demonstrate JavaScript's inherent functional nature.

[[25, 55],[21, 56],[22, 58],[28, 56]].map(function (pair) { // array literal + mapping function
    return new LCMCalculator(pair[0], pair[1]);
}).sort(function (a, b) { // sort with this comparative function
    return a.lcm() - b.lcm();
}).forEach(function (obj) {
    /* Note: print() is a JS builtin function available in Mozilla's js CLI;
     * It is functionally equivalent to Java's System.out.println().
     * Within a web browser, print() is a very different function
     * (opens the "Print Page" dialog),
     * so use something like document.write() or alert() instead.
     */
    // print       (obj + ", gcd = " + obj.gcd() + ", lcm = " + obj.lcm());
    // alert       (obj + ", gcd = " + obj.gcd() + ", lcm = " + obj.lcm());
    document.write(obj + ", gcd = " + obj.gcd() + ", lcm = " + obj.lcm() + "<br />");
});