tak trochu się zastanawiałem i nie wiem czy są jakieś różnice w wydajności, bądź ważniejsze w sposobie rozwiązywania problemów niuanse... np. w necie większość konstrukcji obiektów wygląda w ten sposób:

[JAVASCRIPT] pobierz, plaintext 
java script:
function obiekt($f)
{
    var $c=$f||1;
    delete($f);
    alert($c);
    this.bzdura=function(b){$c*=b;};
    this.cos=function(){alert($c);};
}
b=new obiekt;
g=new obiekt(4);
b.bzdura(3);
g.bzdura(10);
g.cos();
b.cos();
void(0);
[JAVASCRIPT] pobierz, plaintext 

no i właśnie a pro po publicznych metod i publicznych zmiennych odnośnie tego this.cokolwiek - akurat mi się nie wygodnie pisze, jakoś wolę taką konstrukcję bez this.cokolwiek i bez pisania new podczas tworzenia nowego obiektu:

[JAVASCRIPT] pobierz, plaintext 
java script:
function obiekt($f)
{
    var $c=$f||1;
    delete($f);
    alert($c);
    return {
        bzdura:function(b){$c*=b;},
        cos:function(){alert($c);}
    };
}
b=obiekt();
g=obiekt(4);
b.bzdura(3);
g.bzdura(10);
g.cos();
b.cos();
void(0);
[JAVASCRIPT] pobierz, plaintext 

i tu moje pytanie - jak jest poprawniej, czy są jakieś znaczące tutaj różnice??...
może tak przy okazji jakieś linki do trudniejszych artykułów a ciekawszych z niuansami

z góry dziękuje ...

sorki za podbicie ale znalazłem jeden motyw w tym co ja używam a ktoś mógłby uznać to za wadę - brak zdefiniowanego instanceof - więc odrazu rozwiązanie na instance of without new - tu już może spowolnienie lekkie - na pętlę nie chce mi się sprawdzać - choć raczej nie powinno być gdyż jest zwrócona tylko referencja... a jak jest sporo metod publicznych to jednak wolę pisać jak w poście wyżej drugi przykład zamiast dla każdej metody poprzedzać this...

instance of without new (przykład na zdefiniowanie instancji):

ps. aby instancja zosttała zwrócona to funkcja do której przyrównujemy czy istnieje instancja musi być w zasięgu w miejscu gdzie ją sprawdzamy...

dalej szukam jakichś za i przeciw który sposób lepszy - lub niech ktoś napisze, że to jeden h*

lub jeśli ktoś chce pisać new a nie chce co chwila pisać this wewnątrz gdyż woli notację json:

Specjalnie dla Ciebie, wielki test:

[JAVASCRIPT] pobierz, plaintext 
function ms() {
  var d = new Date();
  return d.getTime();
}
 
function benchmark(fn, iterations) {
  var time = ms();
  for (var i = 0; i < iterations; i++) fn();
  return ms() - time;
}
 
function A(x) {
  this.y = x;
  this.t = function() {
    return this.y++;
  };
};
 
B = function(x) {
  this.y = x;
  this.t = function() {
    return this.y++;
  };
};
 
C = function(x) {
  return {
    y : x,
    t : function() {
      return this.y++;
    }
  };
};
 
D = function(x) { this.y = x; };
D.prototype = {
  y : null,
  t : function() {
    return this.y++;
  }
};
 
iterations = 1000000;
 
td = benchmark(function() { d = new D(3); d.t(); }, iterations);
tc = benchmark(function() { c = new C(2); c.t(); }, iterations);
tb = benchmark(function() { b = new B(1); b.t(); }, iterations);
ta = benchmark(function() { a = new A(0); a.t(); }, iterations);
 
alert("Wyniki: " + [ta, tb, tc, td].join(', ') + 'ms');
alert("Sprawdzenie: " + [a.y, b.y, c.y, d.y].join(', '));
[JAVASCRIPT] pobierz, plaintext 

Oto wyniki:

Firefox 3.6 beta 5: 5054, 6622, 5887, 2726 ms

Opera 10.10: 2102, 2079, 2925, 1381 ms

Chrome 4.0.249.43: 310, 302, 369, 75 ms

IE 8: 8085, 8315, 10457, 6007 ms

Są to średnie z 3 testów dla wszystkich przeglądarek z wyjątkiem IE, nie chciało mi się tyle czekać.

Zdecydowanym faworytem jest klasa utworzona z prototypu, czyli nasze D. Rozwiązanie z funkcją zwracającą obiekt © nie sprawdza się za dobrze w większości przeglądarek. Rozwiązania z funkcją i nieszczęsnym this-em (A i uzyskują podobny średni wynik, z przewagami zależnymi od przeglądarki.

Pewnie za wcześnie na poważne wnioski, ale ten banalny test wykazuje pewną wyższość konstrukcji z prototypem. Test sprawdza specyficzną rzecz - mianowicie szybkość tworzenia, inicjowania i użycia egzemplarza klasy. Innym razem trzeba sprawdzić jak będą kształtowały się profile wydajności w przypadku iteracji samego użycia egzemplarza, bez jego tworzenia. Sytuacja tworzenia egzemplarza w każdej iteracji jest raczej nietypowa - przez co niezbyt miarodajna.

Żeby zakończyć ten odcinek jakimś morałem - wydaje mi się, że ogólny wniosek płynący z tego doświadczenia - 1 ch. Są pewne różnice w wydajności, ale generalnie jeśli nie liczymy taktów procka jak w demie na C64 - style klas zostaną chyba w całości w kwestii upodobań danego programisty.

PS, mały update, sprawdziłem jeszcze

[JAVASCRIPT] pobierz, plaintext 
E = function(x) { this.y = x; };
E.prototype.y = null;
E.prototype.t = function() {
  return this.y++;
}
[JAVASCRIPT] pobierz, plaintext 

Uzyskuje nieznacznie gorsze wyniki od D we wszystkich przeglądarkach z wyjątkiem FF, gdzie wychodzi odrobinę szybciej, ale może to być mimo wszystko błąd pomiaru.

Myślę sobie, że silniki JS chyba optymizują jakoś definicje via prototype. Ja więc zostaję przy nich, z ulubionym stylem Class.prototype = JSON.

może będzie ciekawa dyskusja ... i a pro po mi chodziło o troszku inny sposób tworzenia obiektów, coś ala jak obiekt C ale bez parametru new (i tu czas jest TNC zbliżony a nawet ciutkę szybszy od ta) , poza tym zawsze powinno się używać var gdyż inaczej zmienne lądują do globalnego window lub czasem powodują błędy jeśli w tym window nie były zdefiniowane - no chyba, że się chce przypisać wartość w window - ale wcześniej tam powinny być zdefiniowane...

pobawiłem się tym skryptem by wyciągnąć dodatkowe wnioski...
no nie trzeba było definiować w prototype pustej zmiennej y skoro jest w funkcji - czas też minimalnie szybszy...

jedna zasadnicza uwaga to w niektórych obiektach często się przydają (choć nie zawsze) zmienne prywatne (definiowane wewnątrz funkcji przez var), więc aby mieć dostęp do niektórych rzeczy zależnych od zmiennych prywatnych lub by móc je "ustawiać" to kilka metod prywatnych należało by zdefiniować w funkcji (i tu najszybciej wypada akurat definicja this.metoda/zmienna)...

wniosek - wszystkie publiczne metody korzystające z publicznych zmiennych/metod i tak jest najszybciej zdefiniować przez rozszerzenie konstruktorem prototype (jednak rozszerzając przez prototype nie mamy dostępu do zmiennych/funkcji prywatnych - chyba, że przez metody publiczne)

ps. w językach skryptowych szybszy jest zapis ++i od zapisu i++

ogólnie może jeszcze ktoś ciekawie podsumuje...
i masz niezły komputer ;p (testy zrobiłem z tym na operze 10.10 na suśle i czasy wyszły mniejsze ;p):

[JAVASCRIPT] pobierz, plaintext 
function ms() {
  var d = new Date();
  return d.getTime();
}
 
function benchmark(fn, iterations) {
  var time = ms();
  for (var i = 0; i < iterations; i++) fn();
  return ms() - time;
}
 
function A(x) {
  this.y = x;
  this.t = function() {
    return this.y++;
  };
};
 
 
var B = function(x) {
  this.y = x;
  this.t = function() {
    return this.y++;
  };
};
B.prototype={c:99};
 
var C = function(x) {
  return {
    y : x,
    t : function() {
      return this.y++;
    }
  };
};
 
var D = function(x) { this.y = x; };
D.prototype = {
  y : null,
  t : function() {
    return this.y++;
  }
};
 
var G = function(x) { this.y = x; };
G.prototype = {
  t : function() {
    return this.y++;
  }
};
 
var F = function(x) {var ob=function(){};
	ob.prototype={
    y : x,
    t : function() {
      return this.y++;
    }
  };
  return new ob;
};
 
var iterations = 1000000,
 
 
tc = benchmark(function() {var c = new C(2); c.t(); }, iterations),
TNC = benchmark(function() {var nc = C(9); nc.t(); }, iterations),
TNG = benchmark(function() {var ng = new G(9); ng.t(); }, iterations),
TNF = benchmark(function() {var nf = F(11); nf.t(); }, iterations),
tb = benchmark(function() {var b = new B(1); b.t(); }, iterations),
td = benchmark(function() {var d = new D(3); d.t(); }, iterations),
ta = benchmark(function() {var a = new A(0); a.t(); }, iterations);
 
alert("Wyniki: " + [ta, tb, tc, td, TNC, TNG, TNF].join(', ') + 'ms');
/*alert("Sprawdzenie: " + [a.y, b.y, c.y, d.y, nc.y].join(', ')); //teraz nie ma prawa bytu 
*/
/*
Wyniki: 8516, 8094, 11139, 2888, 8439, 2630, 15315ms
*/
[JAVASCRIPT] pobierz, plaintext