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

czwartek, 18 października 2012

[HTML|JS|CSS] JavaScript Patterns: Tworzenie obiektów

Tym razem kilka wzorców projektowych charakterystycznych dla języka JavaScript, które przydają się przy tworzeniu obiektów. Z jakimi podstawowymi problemami spotyka się programista w tym języku ? Przede wszystkim jest to brak klas i przestrzeni nazw. Poniżej użyteczne wzorce.

  • Przestrzeń nazw

Spore zapotrzebowanie na zmienne globalne powoduje zaśmiecanie obiektu okna. Aby temu zapobiec tworzy się jeden globalny obiekt będący odpowiednikiem modułu reprezentującego pewne właściwości.

var mymodule = mymodule || {};
mymodule.length = 3;
mymodule.maxusers = 15;
mymodule.config = {};
mymodule.config.initialtext = "hello world";

  • Prywatne składowe

Aby uzyskać efekt prywatnych składowych obiektu można skorzystać z konstrukcji closure.

function Person(name){
 var myname = name;
 this.getName = function(){
  return myname;
 };
 this.setName = function(str){
  myname = str;
 };
}

var sb = new Person("John");
console.log(sb.myname);
console.log(sb.getName());
sb.setName("Joe");
console.log(sb.getName());

  • Wzorzec modułu

Połączenie kilku mniejszych wzorców, mające na celu utworzenie obiektu będącego modułem z prywatnymi zmiennymi, metodami itd.

var mymodule = {};
mymodule.array = {};
mymodule.array.utils = function(){
 //private members
 var logged = 0;
 var logger = function(i,e){
  logged++;
  console.log("Index:" + i + ", element: " + e);
 };
 //public members
 var totalLogged = function(){
  return logged;
 };
 var printArray = function(array){
  for (var i = array.length - 1; i >= 0; i--) {
   logger(i,array[i]);
  }
 };
 //public API
 return{
  print : printArray,
  total : totalLogged
 };
}();

var myarray = ['one','two','three'];

mymodule.array.utils.print(myarray);
console.log(mymodule.array.utils.total());

  • Sandbox

Ulepszona wersja wzorca przestrzeni nazw. Ponieważ każda funkcja jest obiektem, możemy w niej enkapsulować serwisy i przez samą funkcję się do nich odwoływać oraz zwracać je za pomocą callbacku.

function Sandbox(){
 var args = Array.prototype.slice.call(arguments),
 callback = args.pop(),
 modules = (args[0] && typeof args[0] === "string") ? args : args[0],
 i;

 if(! (this instanceof Sandbox)){
  return new Sandbox(modules, callback);
 }

 for(i = 0; i < modules.length; i += 1){
  Sandbox.modules[modules[i]](this);
 }

 return callback(this);
}

Sandbox.modules = {};
Sandbox.modules.vector = function(box) {
 box.sum = function(v){
  var sum = 0;
  for (var i = v.length - 1; i >= 0; i--) {
   sum += v[i];
  }
  return sum;
 };
 box.normalize = function(v,sumfun){
  var sum = sumfun(v);
  var arr = [];
  for (var i = v.length - 1; i >= 0; i--) {
   arr.push(v[i]/sum);
  }
  console.log(arr);
 };
};

Sandbox('vector', function(box){
 var a = [1,2,3,4];
 console.dir(box.sum(a));
 box.normalize(a,box.sum);
});

  • Statyczne pola

Aby uzyskać konstrukcję składniową statycznego pola, znaną z języków obiektowych typu C++, należy pamiętać o tym, że każda funkcja jest obiektem, do którego można dynamicznie przypisywać właściwości.

function Computer(){
 Computer.instances++;
 return {
  ram : 4096,
  hdd : 1024
 };
}

Computer.instances = 0;

var computers = [new Computer(), new Computer()];
console.log(Computer.instances);

  • Chaining pattern


Jest to wzorzec umożliwiający wywoływanie wielu funkcji w łańcuchu, co poprawia czytelność kodu i zmniejsza jego ilość, kosztem utrudnień w testowaniu.
var number = {
 value : 0,
 add : function(x){
  this.value += x;
  return this;
 },
 multiply : function(x){
  this.value *= x;
  return this;
 },
 print : function(){
  return this.value;
 }
};

console.log(number.add(10).multiply(12).print());

środa, 10 października 2012

[HTML|JS|CSS] Node.js: Wprowadzenie

Node.js jest bardzo modnym ostatnio środowiskiem pozwalającym na tworzenie aplikacji internetowych, przeważnie web serwerów.  Aplikacje te pisane są w JavaScripcie, z całym zestawem jego wad i zalet, na pewno jednak wyróżnia je duża skalowalność, o czym można przeczytać wszędzie gdzie pisze się coś na temat Node'a. Przy projektowaniu środowiska zastosowano event - driven programming - podejście w którym wykonywanie programu determinowane jest przez zdarzenia i odpowiadające im callbacki. Zatem każda funkcja w Node.js jest asynchroniczna.

Aby uprościć architekturę wprowadza się pojęcie modułów. Są to wydzielone, logiczne fragmenty kodu, które możemy importować do Node'a za pomocą instrukcji require(nazwa modułu). Domyślnie Node.js szuka modułu w folderze o nazwie node_modules. Możemy także podać ścieżkę do naszego modułu, rozpoczynającą się od ./, np. require('./mymodules/module').

Aby zainstalować środowisko należy pobrać z tej strony instalator dla naszego systemu operacyjnego. Wraz z serwerem zainstalowany zostanie npm, manager pakietów podobny np. do ruby gems. Poleceniem

npm install <nazwa_pakietu>

możemy pobrać dowolny pakiet.

Do uruchamiania aplikacji napisanych w node warto pobrać pakiet supervisor, który należy zainstalować globalnie.

npm install supervisor -g

Po napisaniu naszej aplikacji, np w pliku mojaaplikacja.js możemy uruchamiać ją za pomocą supervisora poleceniem

supervisor mojaaplikacja.js

Dzięki temu każda zmiana w pliku mojaaplikacja.js spowoduje restart serwera.

Kolejnym pakietem, który warto zainstalować jest express, który zainstalować należy w folderze z naszym projektem.

npm install express

Jest to pakiet, pozwalający w łatwy sposób tworzyć aplikacje internetowe.

Poniżej przykład użycia własnego modułu wraz z pierwszą aplikacją z użyciem expressa.
Plik mymodule.js

var name = "Michael";

var obj = {
 speak : function(){
  console.log("My name is " + name);
 }
}

console.log('Processing module during require directive');
module.exports = exports = obj;

Plik serwera

var express = require('express');
var mymodule = require('./mymodules/mymodule.js')
var app = express();

app.get('/', function(req, res){
 mymodule.speak();
   res.send('Hello World');
});

app.listen(8080);

niedziela, 7 października 2012

[HTML|JS|CSS] AngularJS: Filters

Filtry są bardzo użytecznym narzędziem pozwalającym na wyświetlanie danych w sposób sformatowany do naszych potrzeb. Angular JS udostępnia kilka przydatnych filtrów, z których możemy w każdej chwili skorzystać podając ich nazwę w expression, w konwencji  {{text | filtr}}. Poniżej przedstawiono najważniejsze filtry. Dla każdego property z poniższego kontrolera można zastosować filtry z widoku.

function filtersController($scope){
 $scope.text = "hello world";
 $scope.cost = 1000000000;
 $scope.population = 38276149;
 $scope.time = new Date();
 $scope.entity = {
  name : "Johnny",
  surname : "Depp",
  country : "USA"
 }
 $scope.numbers = [1,2,3,4,5,6,7,8,9];
 $scope.leet = "HeLLo WoRLd"; 
}


<!doctype html>
<html ng-app>
<head>
<meta charset="utf-8">
 <script src="http://ajax.googleapis.com/ajax/libs/angularjs/1.0.2/angular.min.js"></script>
 <script src="scripts/myscript.js"></script>
</head>
<body ng-controller="filtersController"> 
 <div>{{text | uppercase}}</div>
 <div> {{cost | currency:"PLN" }} </div>
 <div> {{population | number}} </div>
 <div> {{time | date:'yyyy-MM-dd HH:mm:ss'}}</div>
 <div> {{entity | json}} </div>
 <div> {{numbers | limitTo:4}} </div>
 <div> {{numbers | limitTo:-4}} </div>
 <div> {{leet | lowercase}} </div>
</body>
</html>

Po uruchomieniu strony otrzymano poniższy widok:


Jeżeli dostarczone filtry nam nie wystarczają, możemy stworzyć własny filtr. Deklarujemy go w podobny sposób jak dyrektywę:

angular.module('filters', []).
 filter('oddUpper',function(){
 return function(text){
  var text = text.toUpperCase();
  var text2 = text.toLowerCase();
  var oddUpper = "";
  for (var i = 0, length = text.length; i < length; i+=1) {
   oddUpper += i % 2 == 0 ? text.charAt(i) : text2.charAt(i);
  };
  return oddUpper;
 }
});

Widok korzysta z filtrów użytkownika w identyczny sposób jak z normalnych filtrów.

<p>My custom filter</p>
<div>{{title | oddUpper}}</div>