QL.túra miazmás

JavaScript referencia: w3schools.com
Viszonylag átfogó leírás a JavaScript-ről: en.wikipedia.org

Némileg furcsa (szokatlan?) az objektumok kezelése JavaScript-ben. Kezdjük a jól használható kisegítő függvényekkel.

1. Ha ki szeretnénk valamit íratni, akkor segít a kiírató függvény. Tetszőleges számú paraméterrel meghívható.

function s(x) {
    for (i = 0; i < arguments.length; i++)
        document.writeln(arguments[i] + "<BR/>");
}


vagy FireFox-ban a development console-ra is ki lehet íratni bármilyen szöveget.

function L() {
    var s = arguments.length + ": ";
    for(var i in arguments)
        s += "(" + typeof(arguments[i]) + ")" +
            arguments[i]+"\n";
    console.log(s);
}2. Sokat segít, ha ki tudjuk dump-olni egy objektum a teljes hierarchiáját (max. "max" mélységben, hogy egy nagyon összetett objektum használatával se pepecseljünk sok időt).

function dump(obj, max, n) {
    if (obj == null) return;

    function s(x) { document.writeln(x); }

    var arr = new Array();
    var i, tab = 0;
    if (n != undefined) tab = n;
    if (max == undefined) max = 5;
    if (tab > max) return;

    var sp = "" ;
    for(i = 0; i < tab; i++) sp += "  ";
    s((tab == 0 ? "<PRE>" : sp) + ">>> length " + obj.length);

    for (i in obj) arr.push(i);
    for (i in arr.sort()) {
        try {
            item = obj[arr[i]];
            type = typeof item;
        } catch (err) {
            item = "#ERR";
            type = "N/A";
        }
        s(sp + arr[i] + " (" + type + ") => " + item);
        if (type == "object") dump(item, max, tab + 1);
    }
    if (tab == 0) s("</PRE>");
}


Ezek után nekiállhatunk vizsgálódni. Nincs hash, hanem igazából a tömb (Array) is egy hash, csak az elemei numerikusak. Illetve a hash elemei egyből az objektum elemei is lesznek.

var a = new Array(2, 4);
dump(a);
a[10] = 3;
dump(a);
a["vizipok"] = "csodapok";
a.keresztes = "pok";
a["árvíz"] = "tűrő";
a.űrhajó = "space";
//a.0 = 10; // Exception: missing ; before statement
dump(a);

Ennek az eredménye

>>> length 2
0 (number) => 2
1 (number) => 4
>>> length 11
0 (number) => 2
1 (number) => 4
10 (number) => 3
>>> length 11
0 (number) => 2
1 (number) => 4
10 (number) => 3
keresztes (string) => pok
vizipok (string) => csodapok
árvíz (string) => tűrő
űrhajó (string) => space

Minden class a konstruktor függvény definiálásával képződik és az objektumok a "new Konsturktor_fuggveny()" meghívásával keletkeznek. A Konstruktor annyiban tér el egy normális függvénytól, hogy a this-sel definiálhatjuk az objektum tagjait. Ez lehet változó, vagy függvény. Bármikor definiálhatunk újabb class és object függvényeket is.

function O() {
    this.x = 1;
    this.func = function() { return "FUNC"; }
}
var o = new O();
o.fnc = function() { return "OBJ"; }
O.prototype.cfnc = function() { return "CLASS"; }
var p = new O();
dump(o);
dump(p);
s(o.fnc);
s(o.fnc());
s(o["fnc"]());
s(o.cfnc());
Ennek a kimenete:

>>> length undefined
cfnc (function) => function () {
    return "CLASS";
}
fnc (function) => function () {
    return "OBJ";
}
func (function) => function () {
    return "FUNC";
}
x (number) => 1

>>> length undefined
cfnc (function) => function () {
    return "CLASS";
}
func (function) => function () {
    return "FUNC";
}
x (number) => 1

function () { return "OBJ"; }
OBJ
OBJ
CLASS


Az utolsó előtti sorban látható megoldás nagyon rugalmassá teszi az objektumok kezelését, hiszen így tudunk egy objektum method-ot hívni, hogy csak menet közben derül ki a hívandó függvény neve. Egy elem létezését ellenőrizhetjük, hogy undefined-e az értéke. Ha igen, akkor nem létezik. (Megjegyzés: annak vizsgálatára, hogy egy változót egyláltalán definiáltunk-e, arra az "if (typeof valtozo == 'undeifined')..." megoldás lehet célravezető.)

Mivel minden függvény az Object objektumból származik, ezért ha meg szeretnénk tudni egy class nevét, akkor egy ehhez hasonló class függvényt kell definiálnunk:

Object.prototype.getClassName = function() {
    var q = typeof this == "object" ?
        this.constructor.toString() : this.toString();
    q = q.substr(q.indexOf(" ") + 1);
    return q.substr(0, q.indexOf('('));
}

Ennek segítségével class-okról és objektum példányokról is kideríthetjük, hogy milyen class-ok leszármazottai (az o az előző példában definiált objektum az O class-ból):

var a = new Array(1, 2, 3);
s(a.getClassName());
s(o.getClassName());
s(Array.getClassName());
s(String.getClassName());
s(Function.getClassName());
Eredménye:

Array
O
Array
String
Function
Ennyit mára a tudomány és technika vívmányaiból!

Hozzunk létre egy új ojjektumot minden nap!