Zum Inhalt

Types

Alle im Framework definierten generellen Typen, Objekte, Strukturen sind im Namespace Alvine.Types zusammengefasst.

Version

Mit Hilfe des Versionsobjektes lässt sich die Version des Frameworks abfragen und gegen eine Mindestanforderung prüfen.

// Neue Version aus Zeichenkette erstellen
version = new Alvine.Types.Version('3.2.1');

// Neue Version aus integer erstellen
version = new Alvine.Types.Version(3,2,1);

//Nur Hautversionsnummer (ergibt 2.0.0)
version = new Alvine.Types.Version('2');

Eine Version kann gegen eine Andere mit der Funktion Version.compareTo() geprüft werden. Diese Methode gibt 1 zurück, wenn das Objekt größer als der übergebene Wert ist und -1 im umgekehrten Fall. 0 wird zurück gegeben, wenn die beiden Versionen identisch sind.

version = new Alvine.Types.Version(4,3,18);
if(version.compareTo(new Alvine.Types.Version(3,3,2))>0) {
   // ... code
};    

Observer

Das Observer-Objekt nimmt neben einer Callback-Funktion noch weitere Argumente auf. Dieses Objekt dient als Übergabe-Objekt für die verschiedenen Observer Pattern.

observer = new Alvine.Types.Observer(function() {
                    // ...
                        }, 'arg1', 'arg2', ...); // arg1, arg2, ... wird an update als Parameter übergeben
observer.update(subject);

Über die Methoden Observer.addTag(tag) können dem Observer Tags zugeordnet werden und per Observer.removeTag(tag) wieder entfernt werden. Der Parameter tag kann entweder eine Zeichenkette oder ein Array von Zeichenketten sein. Mit Observer.getTags() kann eine Collection der Tags geholt werden.

ObserverList

Das ObserverList-Objekt kann von Objekten benutzt werden um das Observer-Pattern zu implementieren.

obj = {
   this.observers = new Alvine.Types.ObserverList();
   }

obj.prototype.attachObserver = function (observer) {
    this.observers.attach(observer);
    return this;
};

obj.prototype.detachObserver = function (observer) {
    this.observers.detach(observer);
    return this;
};

obj.changeValue(newValue) {
    this.observers.notify(this);
}

Map

Eine Map optimiert den Zugriff auf Objektfunktionen mittels Map.set(key, value) und Map.get(key, default)

map = new Alvine.Types.Map()
// Key/Value setzen
map.set('marke','bmw')
// Weiteren Wert
map.set('farbe','rot')

// Werte holen
map.get('farbe');
// -> rot

Über einen zweiten Parameter kann ein Default-Wert definiert werden. Ist in der Map der entsprechenden Schlüssel nicht definiert wird der Defaultwert zurückgegeben.

map = new Alvine.Types.Map()
// Werte holen
map.get('leistung','700');
// -> 700 (leistung ist kein Schlüssel in der Map)

Die Map.toString() Funktion gibt alle Key/Values als Zeichenkette aus. Über die Eigenschaften Map.keyValueSeparator (Standard :) und Map.entrySeparator (Standard ,) können die Trennzeichen definiert werden.

map.toString()
// -> "marke:bmw,farbe:rot"

Möchte man Änderungen an einer Map überwachen, so kann man mittels eines Observers-Objektes eine Funktion an die Map anhängen.

observer = new Alvine.Types.Observer(function(map) {
                            console.log('updated');
                        });
// -> updated

// Observer einhängen
map.attachObserver(observer);

// ruft die im Observer definierte Callback-Funktion auf.
map.set('key','value')
// -> updated

Achtung

Die Observer werden nur bei Änderungen an der Map aufgerufen und nicht bei Änderungen von Objekten die in der Map eingetragen sind.

obj = {}

// update() wird nicht aufgerufen
map.set('key', obj);

// update() wird nicht aufgerufen
obj.new='3';

Alle Observer lassen sich über die Methode Map.detachObservers(recursive) entfernen. Wird für den Parameter recursive true übergeben, so wird die Map rekursiv durchlaufen.

Eine Map kann auch auf bestimmte Objekte eingeschränkt werden. So kann über den Konstruktor der Name von Objekten die erlaubt sind angegeben werden. Wird ein anderer Wert übergeben, so wird eine Exception geschmissen.

map = new Alvine.Types.Map('Alvine.Util.UUID');
map.set(key, new Alvine.Util.UUID());
// -> OK
map.set(key, 'string value');
// -> exception

Die Anzahl der Einträge kann über Map.getCount() abgefragt werden. Über Map.containKey(key) kann geprüft werden, ob ein Schlüssel in der Map vorhanden ist und mit Map.getKeys() lassen sich alle Schlüssel holen.

Objekte die man mit dieser Einschränkung benutzen will, müssen die Eigenschaft objectName besitzen.

obj = {
    objectName: 'myName';
}
map = new Alvine.Types.Map('myName');

Alternativ zum Namen kann man auch ein Funktionsobjekt übergeben. Die Prüfung erfolgt dann nicht über die Zeichenkette, sondern über den instanceof Operator.

function myname() {
}

Map = new Alvine.Types.Map(myname);

Die beiden Funktionen Map.checkLimitation(objectName/Instance) und Map.isLimitToObject(object) zeichnen für die Überprüfung verantwortlich.

Um über ein Map zu iterieren lässt sich die Methode Map.each(callback) verwenden.

map = new Alvine.Types.Map();
map.each(function(obj, index) {
// ...
});

Über die Methode Map.promoteNotification() kann man das Benachrichtigen der Observer deaktivieren und mit Map.promoteNotification() wieder einschalten. Wird die Methode mit dem Parameter true übergeben, so wir das Verhalten auch bei Einträgen die eine Map oder Colection sind rekursive durchgeführt.

map = new Alvine.Types.Map();
map.preventNotification(true);
// Keine Notification an Observer senden
map.set('k','v');

map.promoteNotification(true);  
// Notification wird gesendet
map.set('k','v');

Collection

Eine Collection ist im wesentlichen ein erweitertes Array und kann beliebige Objekte und Werte aufnehmen.

collection = new Alvine.Types.Collection();
collection.append(new Alvine.Util.UUID());
collection.append('Hans Mustermann');
collection.append('Berlin');
collection.append(1425);
collection.append(4.5);
collection.toString();
// -> 7e571823-2c11-4237-84e6-82374cb54878,Hans Mustermann,Berlin,1425,4.5

Das Trennzeichen bei der Ausgabe ist im Standard ein Komma, dies kann aber über die Eigenschaft separator geändert werden.

Eine Collection kann auch auf bestimmte Objekte eingeschränkt werden. So kann über den Konstruktor der Name von Objekten die erlaubt sind angegeben werden. Wird ein anderer Wert übergeben, so wird eine Exception geschmissen.

collection = new Alvine.Types.Collection('Alvine.Util.UUID');
collection.append(new Alvine.Util.UUID());
// -> OK
collection.append('string value');
// -> exception

Objekte die man mit dieser Einschränkung benutzen will, müssen die Eigenschaft objectName besitzen.

obj = {
    objectName: 'myName';
}
collection = new Alvine.Types.Collection('myName');

Alternativ zum Namen kann man auch ein Funktionsobjekt übergeben. Die Prüfung erfolgt dann nicht über die Zeichenkette, sondern über den instanceof Operator.

function myname() {
}

collection = new Alvine.Types.Collection(myname);

Die beiden Funktionen Collection.checkLimitation(objectName/Instance) und Collection.isLimitToObject(object) zeichnen für die Überprüfung verantwortlich.

Um über eine Collection zu iterieren, kann die Methode Collection.each(callback) verwendet werden. Die Methode erwartet eine Callbackfuntion die mit den in der Collection gespeicherten Werten und Schlüsseln aufgrufen wird.

collection.each(function(value, key) {
    // 
});

Eine weitere wichtige Methode ist Collection.contains(). Diese Methode prüft ob ein Wert in der Collection enthalten ist. Die Prüfung, ob ein Wert enthalten ist, erfolgt über den identisch Operator ===.

version = new Alvine.Types.Version('1.2.3');
collection = new Alvine.Types.Collection();
collection.append('Hans Mustermann');
collection.append('Berlin');
collection.append(version);
collection.append(1425);
collection.append(4.5);

collection.contains(1425);
// -> true
collection.contains(4.5);
// -> true
collection.contains(4.9);
// -> false
collection.contains('München');
// -> false
collection.contains('Berlin');
// -> true
collection.contains(version);
// -> true
collection.contains(new Alvine.Types.Version('1.2.3'));    
// -> false

Einträge aus der Collection entfernt man mit der Methode Collection.remove().

Möchte man Änderungen an einer Collection überwachen, so kann man mittels eines Observers-Objektes eine Funktion an die Map anhängen.

observer = new Alvine.Types.Observer(function(collection) {
                        console.log('updated');
                    });
    // -> updated

// Observer einhängen
collection.attachObserver(observer);

// ruft die im Observer definierte Callback-Funktion auf.
collection.append('value')
// -> updated

Achtung

Die Observer werden nur bei Änderungen an der Collection aufgerufen und nicht bei Änderungen von Objekten die in der Collection hängen.

Alle Observer lassen sich über die Methode Collection.detachObservers(recursive) entfernen. Wird für den Parameter recursive true übergeben, so wird die Collection rekursiv durchlaufen.

Über die Methode Collection.preventNotification kann man das benachrichtigen der Observer deaktivieren und mit Collection.promoteNotification wieder einschalten. Wird die Methode mit dem Parameter true übergeben, so wir das Verhalten auch bei Einträgen die eine Map oder Colection sind rekursive durchgeführt.

collection = new Alvine.Types.Collection();
collection.preventNotification(true);
// Keine Notification an Observer senden
collection.append('...');

collection.promoteNotification(true);   
// Notification wird gesendet
collection.append('...');

Type

In Type sind Hilfsfunktinen wie Alvine.Types.Type.getType() gebündelt.

getType

Mit der Funktion Alvine.Types.Type.getType() kann der Type einer Variable genauer als mit typeof bestimmt werden.

Alvine.Types.Type.getType(4)
// -> "number"
Alvine.Types.Type.getType(new Alvine.Types.Version(1))
// -> "object"
Alvine.Types.Type.getType(2)
// -> "number"
Alvine.Types.Type.getType()
// -> "undefined"
Alvine.Types.Type.getType(1)
// -> "number"
Alvine.Types.Type.getType([1,2])
// -> "array"
Alvine.Types.Type.getType({})
// -> "object"
Alvine.Types.Type.getType(this)
// -> "global"
Alvine.Types.Type.getType(window)
// -> "global"

Über ein true-Flag als zweiter Parameter kann zudem auf die ObjektName Eigenschaft der Alvine-Framework-Objekte zugegriffen werden. Besitzt das Objekt die objectName Eigenschaft, so wird diese zurückgegeben.

Alvine.Types.Type.getType(new Alvine.Types.Map(), true)
// -> "Alvine.Types.Map"

isString

Mit der Funktion Alvine.Types.Type.isString() kann geprüft werden ob der Wert eine Zeichenkette ist.

if(Alvine.Types.isString(value)) { ....

isObject

Mit der Funktion Alvine.Types.Type.isObject() kann geprüft werden ob der Wert ein Objekt ist.

if(Alvine.Types.isObject(value)) { ....

isSimple

Prüfen ob der Type einer Variable eine Zeichenkette, eine Zahl, ein Boolean oder undefined oder null ist.

if(Alvine.Types.isSimple(value)) {

isArray

Prüfen ob der Type einer Variable ein Array ist.

if(Alvine.Types.isArray(value)) {

ID

Das ID-Objekt wird mit einem eindeutigen Wert initialisiert und ist besonders für zufällige ID für DOM-Objekte sinnvoll. Die ID ist nur innerhalb einer Webseite eindeutig und nicht kryptografisch abgesichert. Für eine eindeutigere ID sollte man auf die UUID zurückgreifen.

id = new ID();
id.toString()
// -> Mzn6

clone

Die Funktion Alvine.Types.clone() kopiert eine Datenstruktur und erstellt somit ein neues Objekt. Objekte die eine Object.getClone() Methode besitzen werden durch diese Methode geclont. Bei den anderen wird durch alle Properties gelaufen und kopiert. In diesem Fall werden Eigenschaften nur dann kopiert wenn die Methode Object.hasOwnProperty true zurück gibt.

map = new Alvine.Types.Map()
clone = Alvine.Types.clone(map)

Object

Im Objekt-Namespace sind generelle Funktionen und Objekte zur Verwaltung und zum Handling von Objekten zusammengefasst. Das Objekt Alvine.Types.Objekt dient als SammelObjekt für alle abgeleiteten Objekte im Framework und stellt grundlegende Funktionen bereit.

object = new Alvine.Types.Object();

// Gibt das Objekt als json-Zeichenkette zurück.
object.toString()
// -> {}

Die Objektklasse wird folgendermaßen als Prototyp-Objekt verwendet:

MyObject.prototype = new Alvine.Types.Object();
MyObject.prototype.constructor = MyObject;

Jedes Objekt besitzt neben der toString-Methode auch eine Object.toJsonString() Methode. Diese Methode wandelt das Objekt in ein JSON um. Intern wird die Methode JSON.stringify(this) verwendet. Die Methode JSON.stringify() serialisiert entweder das Objekt selbst, oder, falls das Objekt eine Methode toJSON()

Wichtig

Die Schreibweise von toJSON ist entscheidend! Es gibt auch die Methode toJson(), die ist aber deprecated und ein Alias zu toJsonString()

initAlvineObject()

Diese Methode initialisiert ein eigenes Objekt mit der Eigenschaft objectName und weißt Standardwerte zu. Außerdem ruft die Methode testIsCalledAsConstructor() auf.

Um en neues Objekt zu definieren sollte diese Funktion direkt nach der Funktionsdeklaration stehen.

function MyObject(options) {
    Alvine.Types.initAlvineObject.call(this, 'MyObject', namespace, options);
}

MyObject.prototype.getDefaults = function() {
    return {
       key : 'value'
    };
};

MyObject.prototype = new Alvine.Types.Object();
MyObject.prototype.constructor = MyObject;

Über die Defaults werden die Eigenschaften des Objektes festgelegt, die mittels options überschrieben werden können. Wichtig: Die Defaults geben die möglichen Werte vor, über options können keine Eigenschaften angelegt werden.

obj = new MyObject();
// obj.key enthält value

obj = new MyObject({key: 'myvalue'})    
// obj.key enthält myvalue

obj = new MyObject({nokey: 'novalue'})    
// obj.nokey ist undefined

testIsCalledAsConstructor()

Diese Methode prüft ob die Funktion als Objekt-Konstruktor aufgerfen wurde und ob das Objekt von Alvine.Types.Objekt abgeleitet wurde. Treffen die Erwartungen nicht zu, so wird eine Exception geworfen.

Kommentare