Pokazywanie postów oznaczonych etykietą mixin. Pokaż wszystkie posty
Pokazywanie postów oznaczonych etykietą mixin. Pokaż wszystkie posty

sobota, 20 października 2012

[HTML|JS|CSS] JavaScript Patterns: Code Reuse

JavaScript jest językiem, w którym nie występują klasy, a zatem klasyczne dziedziczenie znane chociażby z C++ musimy zastępować pewnymi wzorcami. Dzięki ich zastosowaniu będziemy mogli wiele razy używać niektórych fragmentów kodu.

  • Classical pattern

Wzorzec ten ma imitować dziedziczenie klas z języków obiektowych, stąd nazwa. Istnieje kilka sposobów jego implementacji. Poniżej przykład, w którym wykorzystuje się obiekt prototype. Zasada działania jest prosta. Jeżeli przy wywołaniu funkcji nie ma jej w konstruktorze danego obiektu, jej sygnatura poszukiwana jest w referencji __proto__ wskazującej na obiekt prototype. Podobnie rzecz ma się z properties.


function Parent1(n){
 this.name = n || 'Parent2';
}

Parent1.prototype.say = function(){
 console.log('My name is: ' + this.name);
};

function Child1(n){
 Parent1.apply(this,arguments);
}
Child1.prototype = new Parent1();

var c1 = new Child1('Child1');
console.log(c1.name);
c1.say();
delete c1.name;
c1.say();

Konsola:

Child1
My name is: Child1
My name is: Parent1

  • Klass

Ideą tego wzorca jest emulacja klas z języków obiektowych, a więc doprowadzenie do takiego API jak w poniższym przykładzie.


var car1 = new car('simple car');
car1.printName();
var car2 = new bmw('bmw car');
car2.printName();

Definicję funkcji konstruktorów wprowadza się za pomocą specjalnej funkcji klass. Przyjmuje ona funkcję konstruktora dla parenta oraz listę properties (jako obiekt), charakterystycznych dla nowego obiektu.


var car = klass(null, {
	__construct : function(name){
		console.log('constructing car...');
		this.name = name;
	},
	printName : function(){
		console.log(this.name);
	}
});

var bmw = klass(car, {
	__construct : function(){
		console.log('constructing bmw');
	},
	printName : function(){
		console.log('bmw printer');
		bmw.uber.printName.call(this);
	}
});

Cała "magia" zawarta jest w funkcji klass:

var klass = function(Parent, props){
	var Child, F, i;
	Child = function(){
		if(Child.uber && Child.uber.hasOwnProperty("__construct")){
			Child.uber.__construct.apply(this, arguments);
		}
		if(Child.prototype.hasOwnProperty("__construct")){
			Child.prototype.__construct.apply(this, arguments);
		}
	};
	Parent = Parent || Object;
	F = function(){};
	F.prototype = Parent.prototype;
	Child.prototype = new F();
	Child.uber = Parent.prototype;
	Child.prototype.constructor = Child;

	for(i in props){
		if (props.hasOwnProperty(i)){
			Child.prototype[i] = props[i];
		}
	}
	return Child;
};

Przy użyciu pomocniczego obiektu funkcji F(), obiekt Child przejmuje prototype swojego parenta podanego jako argument funkcji. Obiekty uber i prototype służą do wywoływania konstruktorów będących wyżej w hierarchii dziedziczenia w momencie konstrukcji obiektu. Ostatecznie kopiowane są również properties obiektu parent.

  • Prototypical inheritance

Jest to prostszy od powyższych i często wystarczający wzorzec, w którym mechanizm dziedziczenia polega na przekazaniu prototypu rodzica do prototypu dziecka. Warto zwrócić uwagę na to jak w obiekcie dziedziczącym zachowuje się funkcja definiowana w prototype, a jak ta z obiektu parenta.

function object(parent){
	var F = function(){};
	F.prototype = parent;
	return new F();
}

function Parent3(){
	this.name = 'Parent3';
	var that = this;
	this.print = function(){
		console.log(that.name);
	};
}

Parent3.prototype.printName = function(){
	console.log(this.name);
};

var newparent = {
	name: "ParentName"
};

var child = object(newparent);
console.log(child.name);

//errors
//child.printName();
//child.print();

var parent3 = new Parent3('Parent3');
var child3 = object(parent3);

child3.name = "Child3";
child3.printName();
child3.print();

Konsola wypisze dwa różne wyniki, ponieważ jedynie funkcja z prototypu będzie wywołana z property z obiektu dziedziczącego. Ponadto obiekt z którego chcemy dziedziczyć musi być tworzony przez operator new.

ParentName
Child3
Parent3

  • Mixin


Jest to specjalny wzorzec umożliwiający dziedziczenie z kilku prostych obiektów w jeden. Tworzy się specjalną funkcję mix, do której przekazywane są jako argumenty obiekty, które chcemy złączyć w całość.


function mix(){
	var arg, prop, child = {};
	for (arg = 0; arg < arguments.length; arg++) {
		for(prop in arguments[arg]){
			if(arguments[arg].hasOwnProperty(prop)){
				child[prop] = arguments[arg][prop];
			}
		}
	}
	return child;
}

var obj = mix({i : 1, one : "one"},
			{j : 1, two : "two"},
			{j : 2, three : "three"});

console.dir(obj);

W przypadku dwóch identycznie nazywających się properties w obiektach, wybrany zostanie ostatni.

{ i: 1, one: 'one', j: 1, two: 'two', three: 'three' }

sobota, 8 września 2012

[HTML|JS|CSS] Compass : Mixiny CSS3

Problemem CSS3 jest to, że nie każda jego funkcjonalność jest wspierana we wszystkich przeglądarkach. Wprowadzono zatem tzw. "vendor specific properties", lub "prefix properties", czyli właściwości, które należy ustawić kilkukrotnie, osobno dla silnika przeglądarek (Gecko, Webkit, Presto, Trident). Lista takich właściwości znajduje się tutaj. Przykładowo, aby ustawić zaokrąglenie dla rogów elementu w czterech silnikach, należy napisać:

.round {
  -webkit-border-radius: 5px;
  -moz-border-radius: 5px;
  -ms-border-radius: 5px;
  -o-border-radius: 5px;
  border-radius: 5px;
}

Pisanie styli w ten sposób staje się oczywiście męczące, ewentualne zmiany muszą być dokonywane w wielu miejscach, a i o błąd nietrudno. Tu z pomocą przychodzi Compass i jego gotowe Mixiny. Zamiast pisać powyższego kodu mamy możliwość skorzystania z Mixina @include border-radius(5px);

Compass wspiera 19 właściwości, pełna lista dostępna jest tutaj,

Przykładowo możemy chcieć zaokrąglić rogi, ustawić nieprzezroczystość oraz cień dla tekstu.

.round{
 @include border-radius(5px);
 background-color: red;
}

.round-left{
 @include border-left-radius(5px);
}

.half-transparent{
 @include opacity(0.4);
}

.shadowed{
 @include single-text-shadow;
}

Po transformacji otrzymamy:

.round {
  -webkit-border-radius: 5px;
  -moz-border-radius: 5px;
  -ms-border-radius: 5px;
  -o-border-radius: 5px;
  border-radius: 5px;
  background-color: red;
}

/* line 10, ../sass/style.scss */
.round-left {
  -moz-border-radius-topleft: 5px;
  -webkit-border-top-left-radius: 5px;
  border-top-left-radius: 5px;
  -moz-border-radius-bottomleft: 5px;
  -webkit-border-bottom-left-radius: 5px;
  border-bottom-left-radius: 5px;
}

/* line 14, ../sass/style.scss */
.half-transparent {
  filter: progid:DXImageTransform.Microsoft.Alpha(Opacity=40);
  opacity: 0.4;
}

/* line 18, ../sass/style.scss */
.shadowed {
  text-shadow: 0px 0px 1px #aaaaaa;
}

czwartek, 6 września 2012

[HTML|JS|CSS] Sass : Mixiny

Mixiny są czymś, co pozwala znacznie zredukować ilość kodu w pliku .scss. Są to bloki kodu, które możemy wstawiać do selektorów za pomocą instrukcji @include. Każdy mixin może zależeć od parametrów, które podawane są w nawiasie. Podczas deklaracji możemy sobie ustalić domyślną wartość paramtru. Wtedy nie musimy za każdym razem podawać tej samej wartości. Zawartość mixina w momencie tłumaczenia instruckji @include zostanie wstawiona w jej miejscu, nie naruszając pozostałych wartości w selektorze. Należy pamiętać, że jeżeli mixin definiuje właściwość zdefiniowaną również w selektorze poza mixinem, to zostanie zastosowana ostatnia wartość.

Przykład:

@mixin red-bordered($wdth : 5px)
{
 border-width : $wdth;
 border-color : red;
}

@mixin margined-slightly
{
 margin: 2px, 2px, 2px, 2px;
}

.bordered-button
{
 @include red-bordered;
 @include margined-slightly;
}

.bordered-div
{
 font-size: 15px;
 @include red-bordered(10px);
}

Po transformacji:

.bordered-button {
  border-width: 5px;
  border-color: red;
  margin: 2px, 2px, 2px, 2px; }

.bordered-div {
  font-size: 15px;
  border-width: 10px;
  border-color: red; }