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

niedziela, 23 września 2012

[HTML|JS|CSS] KnockoutJS : Custom Binding

KnockoutJS umożliwia tworzenie data bindingu według własnych reguł. Ponadto programista ma możliwość tworzenia reużywalnych ViewModeli, gdzie dane mogą być przekazywane np. poprzez argumenty. Poniższy przykład wykorzystuje te zagadnienia.

<h3 data-bind="text: question"></h3> 
<table>
    <thead><tr><th>Option</th></thead>
    <tbody data-bind="foreach: answers">
        <tr>
            <td data-bind="text: answerText"></td>             
        </tr>    
    </tbody>
</table>
<h3>Your answer:</h3>
<select data-bind="options: letters, value: answer"></select>
<button data-bind="slideBinding: isAnswered() > 0">Finished</button>

Dla przycisku zdefiniowany został specjalny rodzaj bindingu nazwany slideBinding.Aby utworzyć taki binding należy w pliku ze skryptem dodać odpowiedni obiekt slideBinding w ko.bindingHandlers

ko.bindingHandlers.slideBinding = {
  init: function(element, valueAccessor) {
        var shouldDisplay = valueAccessor();
        $(element).css('display','none');
    },
    update: function(element, valueAccessor) {
        var shouldDisplay = valueAccessor();
        shouldDisplay ? $(element).slideDown() : $(element).slideUp();
    }
};

Należy zdefiniować funkcje dla inicjalizacji i zmiany którejś z zależności. Pod valueAccessor dostępne jest wyrażenie logiczne podawane w widoku ( w tym przypadku isAnswered() > 0). Wewnątrz obu funkcji można wykonywać operacje na elemencie, w tym przypadku przy użyciu biblioteki jQuery.

Pozostała część ViewModelu odpowiada za przetworzenie wartości podawanych jako argumenty w odpowiednie properties. Kontrolkę można tworzyć w wielu kontekstach podając za każdym razem inne pytanie i zestaw odpowiedzi.

function answerText(text){
    this.answerText = text;
}

function QuizViewModel(question,answers){
    var self = this;
    self.question = ko.observable(question);
    self.answers = $.map(answers,function(text){return new answerText(text)})
    self.answer = ko.observable("");    
    self.letters = ko.observableArray(["","a","b","c","d"]);                 

    this.isAnswered = ko.computed(function() {
        if(self.answer()===""){ return 0; }
        else{ return 1; }       
    },this);
}

ko.applyBindings(new QuizViewModel("Capital city of Ecuador",
    ["Quito","La Paz","Caracas","Lima"]));

sobota, 22 września 2012

[HTML|JS|CSS] KnockoutJS : Kolekcje

Data binding do kolekcji elementów jest czymś powszechnie stosowanym. Potrzeba wyświetlania zestawów danych na własne potrzeba pojawia się przy każdym większym projekcie. KnockoutJS daje możliwość prostego bindingu przy użyciu atrybutów oraz odpowiednich typów w ViewModelu.

Wyświetlanie kolekcji

Binding do kolekcji tworzy się w widoku za pomocą dyrektywy foreach, a po dwukropku podajemy nazwę kolekcji z ViewModelu. Jeżeli w przykładzie poniżej people jest kolekcją obiektów, to name, surname oraz added są kolejnymi properties takich obiektów.

<div data-bind="foreach: people">
 <div>
      <strong data-bind="text: name"></strong>
      <strong data-bind="text : surname"></strong>
      <strong data-bind="text : added"></strong> 
 </div>
</div>

W ViewModelu kolekcja musi być typu ko.observableArray, co zapewni śledzenie zmian. Warto przygotować sobie również funkcję - konstruktor do szybkiego tworzenia obiektów.

//funkcja konstruktora dla osoby

function Person(name, surname){
 var self = this;
 self.name = name; 
 self.surname = surname;
 self.added = new Date();
}

function AppViewModel() {

    // pozostala czesc inicjalizacji
    
    this.people = ko.observableArray([
     new Person("John","Doe"),
     new Person("Jack","The Ripper")
     ]);   
}

ko.applyBindings(new AppViewModel());

Powyższy kod wyświetli dane sformatowane do naszych potrzeb.

Dodawanie elementów

Jeżeli zajdzie potrzeba dynamicznego dodawania do kolekcji elementów, można stworzyć odpowiednią funkcję wewnątrz ViewModelu.
Od strony widoku można dodać przycisk z bindingiem do zdarzenia click.

<button data-bind="click: addPerson">Add</button>

W ViewModelu należy z kolei dodać funkcję, w której zwiększamy kolekcję używając funkcji push. Wszystkie zmiany w kolekcji spowodują automatyczne zmiany w widoku.

function AppViewModel() {
    //pozostala czesc inicjalizacji
    var that = this;
    this.addPerson = function(){
     that.people.push(new Person(that.firstName, that.lastName));      
    };
}

Edytowanie elementów

Dzięki śledzeniu zależności, każda zmiana wartości automatycznie odświeży kolekcję. Aby edytować elementy za pomocą elementu select, należy nieco zmodyfikować widok:

<div data-bind="foreach: people">
   <div>
 <!--pozostale elementy-->
 <select data-bind="options: $root.jobs, value: job, optionsText: 'name'"></select>
 <strong data-bind="text : job().salary"></strong>
   </div>
</div>

Obiekt select dostaje informacje o tym, z której kolekcji ma pobierać listę wartości (tablica jobs z ViewModelu), do którego property elementu z kolekcji people przypisać wartość (obserwowalny element job) oraz które property z elementów jobs wyświetlać jako opcję do wyboru.

Tymczasem po stronie ViewModelu:

function Person(name, surname,job){
 var self = this;
 //pozostale properties
 self.job = ko.observable(job);
}

function AppViewModel() {    

    this.jobs = [
    {name: "manger", salary : 6000},
    {name: "tester", salary : 2000},
    {name: "developer", salary : 4000}
    ];

    var that = this;
}

Jak widzimy jobs to kolekcja obiektów. Wyświetlamy tylko property name, ale po wybraniu obiektu mamy też dostęp do property salary. Możemy je wyświetlać w widoku za pomocą instrukcji data-bind="text : job().salary", jako odwołanie do property salary z obiektu job, który jest property elementu kolekcji people.

Usuwanie elementów

Po stronie widoku należy dodać element powodujący usunięcie elementu np. poprzez click.

<div data-bind="foreach: people">
 <div>
 <!--pozostale elementy -->
 <a data-bind="click: $root.removePerson">Remove item</a>
 </div>
</div>

Jako lokalizację funkcji podaje się $root, czyli najbardziej zewnętrzny ViewModel.


function AppViewModel() {
    var that = this;

    this.removePerson = function(person){
     that.people.remove(person);
    }
}


Agregacja wartości:

Pisanie swoich funkcji wyliczających pewne wartości na całej kolekcji staje się proste dzięki mechanizmowi śledzenie zależności. Gdy chcemy posumować wszystkie wartości i zbindować tę sumę do osobnego elementu, wartość zostanie odświeżona automatycznie przy każdej zmianie na kolekcji. Możemy także zbindować się do właściwości visible i wyświetlać dany element w zależności od spełnienia pewnego warunku logicznego. Na przykład:

<div data-bind="visible: totalSalary()>0">
 <p>Total salary:</p>
 <strong data-bind="text: totalSalary"></strong>
</div>

gdzie total salary jest typem ko.computed w ViewModelu.


that.totalSalary = ko.computed(function() {
   var total = 0;
   for (var i = 0; i < that.people().length; i++)
       total += that.people()[i].job().salary;
   return total;
});

piątek, 21 września 2012

[HTML|JS|CSS] KnockoutJS : DataBinding

Tworzenie data bindingu w Knockoucie jest proste i wymaga modyfikacji widoku (plik html) oraz viewmodelu(plik javascript). Aby stworzyć binding w dwie strony (tekst, który wpiszemy w kontrolkach input zostanie wyświetlony w innym miejscu), wystarczy kilka linijek kodu.

<!DOCTYPE html>
<html>
<head>
 <meta charset="utf-8" />
</head>
<body>
 <label>Please introduce yourself</label>
 <input type="text" data-bind="value: firstName"></input>
 <input type="text" data-bind="value: lastName"></input>
 <strong>Hello,</strong>
 <strong data-bind="text: firstName"></strong>
 <strong data-bind="text: lastName"></strong>
 <script src="http://cdnjs.cloudflare.com/ajax/libs/knockout/2.1.0/knockout-min.js"></script>
 <script src="scripts/myscript.js"></script>
</body>
</html>

W widoku, deklaracja bindingu zachodzi poprzez atrybut data-bind z wartościami property elementu z widoku i elementu z viewmodelu.

function AppViewModel() {
    this.firstName = ko.observable("");
    this.lastName = ko.observable("");   
}

ko.applyBindings(new AppViewModel());

W viewmodelu tworzemy properties o typie ko.observable (jako argument podaje się wartość domyślną). Wartość w przypadku kontrolek typu input będzie aktualizowana w momencie, gdy kontrolka straci focus.

Dodatkowo możemy bindować się do właściwości wyliczanych za pomocą pewnej logiki. W widoku należy dodać nowy element, również bindowany do property.

<p>Full name length: <strong data-bind="text: fullNameLength"></strong></p>

W viewmodelu należy zdefiniować property jako ko.computed z funkcją zwracającą wyliczoną wartość. Aktualizacja następuje w momencie zmiany dowolnej zależności.

function AppViewModel() {
    //pozostale properties
    this.fullNameLength = ko.computed(function() {
     console.log('computing...');
     var f = this.firstName();
     var l = this.lastName();
     return f.length+l.length;    
}, this);
}

ko.applyBindings(new AppViewModel());

[HTML|JS|CSS] KnockoutJS: Wprowadzenie

KnockoutJS to biblioteka JavaScript wspomagająca tworzenie dynamicznych interfejsów użytkownika. Aplikacje to tworzone są w oparciu o znany chcociażby z WPF wzorzec MVVM.  Biblioteka dostępna jest na licencji MIT (open source), nie zawiera zależności (można z niej korzystać np. w połączeniu z jQuery) oraz wspierana jest przez wszystkie nowoczesne przeglądarki. Kolejną zaletą jest porządnie sporządzona dokumentacja dostępna tutaj. Główne cztery zalety biblioteki:

  1. Deklaratywny data binding - za pomocą prostych składniowo wyrażeń możemy powiązać elementy modelu DOM z modelem danych
  2. Automatyczne odświeżanie interfejsu - każda zmiana modelu danych powoduje odświeżenie dokumentu
  3. Śledzenie zależności - zmiana jednej wartości powoduje zmianę całego łańcucha wartości od niej zależnych
  4. Tworzenie szablonów - tworzenie zagnieżdżonych interfejsów, jako metod modelu danych
Pierwsza strona korzystająca z ViewModelu poniżej:

View(HTML):

<!DOCTYPE html>
<html>
<head>
 <meta charset="utf-8" />
 <script src="http://cdnjs.cloudflare.com/ajax/libs/jquery/1.8.1/jquery.min.js"></script>
</head>
<body>
 <strong>Hello,</strong>
 <strong data-bind="text: firstName"></strong>
 <strong data-bind="text: lastName"></strong>
 <script src="http://cdnjs.cloudflare.com/ajax/libs/knockout/2.1.0/knockout-min.js"></script>
 <script src="scripts/myscript.js"></script>
</body>
</html>


ViewModel(JavaScript):

function AppViewModel() {
    this.firstName = "John";
    this.lastName = "Doe";
}

ko.applyBindings(new AppViewModel());

Zatem, aby korzystać z Knockouta należy w htmlu osadzić atrybuty data-bind, w których podajemy property z viewModelu. W kodzie JavaScriptu należy stworzyć VewModel w postaci funkcji, a następnie zastosować go przy użyciu metody applyBindings, gdzie ko jest aliasem biblioteki.