Upotrijebite .apply () s "novim" operatorom. Je li moguće

U JavaScriptu želim stvoriti objektnu instancu (preko new operatora), ali konstruktoru proslijediti proizvoljan broj argumenata. Je li moguće?

Želim učiniti nešto poput ovoga (ali kôd u nastavku ne funkcionira):

 function Something(){ // init stuff } function createSomething(){ return new Something.apply(null, arguments); } var s = createSomething(a,b,c); // 's' is an instance of Something 

Odgovor

Iz odgovora je postalo jasno da ne postoji ugrađeni način pozivanja .apply() pomoću new operatora. Međutim, ljudi su predložili neka zaista zanimljiva rješenja problema.

Moje omiljeno rješenje bilo je to od Matthewa Crumleyja (promijenio sam ga da bih proslijedio svojstvo arguments ):

 var createSomething = (function() { function F(args) { return Something.apply(this, args); } F.prototype = Something.prototype; return function() { return new F(arguments); } })(); 
427
22 окт. Premasagar postavljen 22. listopada 2009-10-22 15:15 '09 u 15:15 2009-10-22 15:15
@ 35 odgovora
  • 1
  • 2

S ECMAScript5 Function.prototype.bind sve postaje prilično čisto:

 function newCall(Cls) { return new (Function.prototype.bind.apply(Cls, arguments)); // or even // return new (Cls.bind.apply(Cls, arguments)); // if you know that Cls.bind has not been overwritten } 

Može se koristiti na sljedeći način:

 var s = newCall(Something, a, b, c); 

ili čak izravno:

 var s = new (Function.prototype.bind.call(Something, null, a, b, c)); var s = new (Function.prototype.bind.apply(Something, [null, a, b, c])); 

Ovo i eval rješenje su jedini koji uvijek rade, čak i sa posebnim konstruktorima kao što je Date :

 var date = newCall(Date, 2012, 1); console.log(date instanceof Date); // true 

promijeniti

Neka objašnjenja: Moramo pokrenuti new za funkciju koja prihvaća ograničen broj argumenata. Metoda bind omogućuje nam da to učinimo na sljedeći način:

 var f = Cls.bind(anything, arg1, arg2, ...); result = new f(); 

Parametar anything nije važan, jer new ključna riječ ponovno postavlja kontekst f . Međutim, to je potrebno zbog sintaktičkih razloga. Sada da pozovemo bind : moramo proslijediti varijabilni broj argumenata, tako da to čini trik:

 var f = Cls.bind.apply(Cls, [anything, arg1, arg2, ...]); result = new f(); 

Neka ovo bude zamotano u funkciju. Cls se prosljeđuje kao izraz 0, tako da će biti naše anything .

 function newCall(Cls ) { var f = Cls.bind.apply(Cls, arguments); return new f(); } 

Zapravo, privremena varijabla f nije potrebna:

 function newCall(Cls ) { return new (Cls.bind.apply(Cls, arguments))(); } 

Konačno, moramo biti sigurni da je bind stvarno ono što nam treba. ( Cls.bind se može prepisati). Stoga ga zamijenite Function.prototype.bind , a mi ćemo dobiti konačni rezultat kao što je gore navedeno.

327
13 янв. odgovor dao user123444555621 13. siječnja 2012-01-13 01:20 '12 u 1:20 2012-01-13 01:20

Ovo je generičko rješenje koje svaki konstruktor može nazvati (osim za ugrađene konstruktore koji se ponašaju drugačije kada pozivaju funkcije kao što su String , Number , Date itd.) S nizom argumenata:

 function construct(constructor, args) { function F() { return constructor.apply(this, args); } F.prototype = constructor.prototype; return new F(); } 

Objekt stvoren pozivom construct(Class, [1, 2, 3]) bit će identičan objektu kreiranom pomoću new Class(1, 2, 3) .

Također možete izraditi specifičniju verziju, tako da ne morate svaki put proći konstruktor. Ovo je također malo učinkovitije, jer svaki put kada se nazove nije potrebno kreirati novu instancu interne funkcije.

 var createSomething = (function() { function F(args) { return Something.apply(this, args); } F.prototype = Something.prototype; return function(args) { return new F(args); } })(); 
border=0

Razlog stvaranja i pozivanja vanjske anonimne funkcije je očuvanje funkcije F od onečišćenja globalnog prostora naziva. To se ponekad naziva predložak predloška.

[Update]

Za one koji ga žele koristiti u TypeScriptu, jer TS daje pogrešku ako F vrati nešto:

 function construct(constructor, args) { function F() : void { constructor.apply(this, args); } F.prototype = constructor.prototype; return new F(); } 
254
22 окт. Odgovor dao Matthew Crumley 22. listopada 2009-10-22 19:52 '09 u 19:52 2009-10-22 19:52

Ako vaše okruženje podržava operatora distribucije ECMA skripta od 2015. ( ... ) , možete ga jednostavno koristiti na sljedeći način

 function Something() { // init stuff } function createSomething() { return new Something(...arguments); } 

Napomena. Sada kada su objavljene specifikacije ECMA Scripta 2015, a većina JavaScript motora ga aktivno implementira, to će biti preferirani način za to.

Podršku operatora Spread možete provjeriti u nekoliko većih okruženja, ovdje .

28
13 сент. Odgovor je dao thefourtheye Sep 13 2015-09-13 12:33 '15 u 12:33 2015-09-13 12:33

Pretpostavimo da imate konstruktora stavki koji preklapa sve argumente koje ste bacili na njega:

 function Items () { this.elems = [].slice.call(arguments); } Items.prototype.sum = function () { return this.elems.reduce(function (sum, x) { return sum + x }, 0); }; 

Možete stvoriti instancu s Object.create (), a zatim .apply () s ovom instancom:

 var items = Object.create(Items.prototype); Items.apply(items, [ 1, 2, 3, 4 ]); console.log(items.sum()); 

To na početku ispisuje 10, kao 1 + 2 + 3 + 4 == 10:

 $ node t.js 10 
26
19 мая '11 в 20:18 2011-05-19 20:18 odgovor je dat supack 19. svibnja '11 u 20:18 2011-05-19 20:18

U ES6, Reflect.construct() vrlo zgodan:

 Reflect.construct(F, args) 
12
21 июля '16 в 12:00 2016-07-21 12:00 odgovor je dao gfaceless 21. srpnja '16. u 12:00 2016-07-21 12:00

@Matthew Mislim da je bolje popraviti i svojstvo konstruktora.

 // Invoke new operator with arbitrary arguments // Holy Grail pattern function invoke(constructor, args) { var f; function F() { // constructor returns **this** return constructor.apply(this, args); } F.prototype = constructor.prototype; f = new F(); f.constructor = constructor; return f; } 
9
18 дек. Odgovor je dan 18. prosinca. 2012-12-18 14:09 '12 u 14:09 2012-12-18 14:09

Poboljšana verzija odgovora @Matthew. Ovaj oblik ima male prednosti koje se postižu pohranjivanjem privremene klase u zatvor, kao i fleksibilnost korištenja jedne funkcije za stvaranje bilo koje klase.

 var applyCtor = function(){ var tempCtor = function() {}; return function(ctor, args){ tempCtor.prototype = ctor.prototype; var instance = new tempCtor(); ctor.prototype.constructor.apply(instance,args); return instance; } }(); 

To će se koristiti prilikom pozivanja applyCtor(class, [arg1, arg2, argn]);

8
07 дек. Odgovor dao jordancpaul Dec 07 2010-12-07 12:05 '10 u 12:05 2010-12-07 12:05

Materijal init možete prenijeti na zasebnu metodu prototipa Something :

 function Something() { // Do nothing } Something.prototype.init = function() { // Do init stuff }; function createSomething() { var s = new Something(); s.init.apply(s, arguments); return s; } var s = createSomething(a,b,c); // 's' is an instance of Something 
7
22 окт. Odgovor dao Tim Down 22. listopada 2009-10-22 16:35 '09 u 16:35 2009-10-22 16:35

Taj je odgovor malo kasnio, ali je odlučio da ga svatko tko to vidi može iskoristiti. Postoji način vraćanja novog objekta pomoću application. Iako deklaracija objekta zahtijeva malu promjenu.

 function testNew() { if (!( this instanceof arguments.callee )) return arguments.callee.apply( new arguments.callee(), arguments ); this.arg = Array.prototype.slice.call( arguments ); return this; } testNew.prototype.addThem = function() { var newVal = 0, i = 0; for ( ; i < this.arg.length; i++ ) { newVal += this.arg[i]; } return newVal; } testNew( 4, 8 ) === { arg : [ 4, 8 ] }; testNew( 1, 2, 3, 4, 5 ).addThem() === 15; 

Za prvu if da radi u testNew morate to return this; na dnu funkcije. Dakle, primjer s vašim kodom:

 function Something() { // init stuff return this; } function createSomething() { return Something.apply( new Something(), arguments ); } var s = createSomething( a, b, c ); 

Update: Promijenio sam svoj prvi primjer kako bih dodao bilo koji broj argumenata, a ne samo dva.

6
12 сент. Odgovor daje Trevor Norris 12 sep. 2011-09-12 20:22 '11 u 20:22 2011-09-12 20:22

Upravo sam naišao na ovaj problem i riješio ga ovako:

 function instantiate(ctor) { switch (arguments.length) { case 1: return new ctor(); case 2: return new ctor(arguments[1]); case 3: return new ctor(arguments[1], arguments[2]); case 4: return new ctor(arguments[1], arguments[2], arguments[3]); //... default: throw new Error('instantiate: too many parameters'); } } function Thing(a, b, c) { console.log(a); console.log(b); console.log(c); } var thing = instantiate(Thing, 'abc', 123, {x:5}); 

Da, to je malo ružno, ali rješava problem i smrtonosno je jednostavno.

6
25 июля '14 в 23:09 2014-07-25 23:09 odgovor je dao alekop 25. srpnja 2014. u 23:09 2014-07-25 23:09

ako ste zainteresirani za rješenje temeljeno na eval

 function createSomething() { var q = []; for(var i = 0; i < arguments.length; i++) q.push("arguments[" + i + "]"); return eval("new Something(" + q.join(",") + ")"); } 
4
22 окт. odgovor je korisnik187291 22. listopada 2009-10-22 16:25 '09 u 16:25 2009-10-22 16:25

Pogledajte i kako to radi CoffeeScript.

s = new Something([a,b,c]...)

postaje:

 var s; s = (function(func, args, ctor) { ctor.prototype = func.prototype; var child = new ctor, result = func.apply(child, args); return Object(result) === result ? result : child; })(Something, [a, b, c], function(){}); 
3
20 мая '11 в 11:29 2011-05-20 11:29 odgovor je dao mbarkhau 20. svibnja '11 u 11:29 2011-05-20 11:29

Radi!

 var cls = Array; //eval('Array'); dynamically var data = [2]; new cls(...data); 
3
03 февр. Odgovor je dan infinito84 03. veljače. 2017-02-03 18:33 '17 u 18:33 2017-02-03 18:33

Ovaj pristup konstruktora radi sa ili bez new ključne riječi:

 function Something(foo, bar){ if (!(this instanceof Something)){ var obj = Object.create(Something.prototype); return Something.apply(obj, arguments); } this.foo = foo; this.bar = bar; return this; } 

Trebalo bi podržati Object.create , ali uvijek možete polyfill ako podržavate starije preglednike. Ovdje pogledajte tablicu podrške u MDN-u .

Ovdje JSBin da ga vidi u akciji s izdavanjem konzole .

2
13 марта '15 в 19:42 2015-03-13 19:42 odgovor daje muffinresearch 13. ožujka '15 u 19:42 2015-03-13 19:42

Ne možete pozvati konstruktora promjenljivog broja kao što želite s new operatorom.

Ono što možete učiniti je malo promijeniti konstruktora. Umjesto:

 function Something() { // deal with the "arguments" array } var obj = new Something.apply(null, [0, 0]); // doesn't work! 

Učinite to umjesto:

 function Something(args) { // shorter, but will substitute a default if args.x is 0, false, "" etc. this.x = args.x || SOME_DEFAULT_VALUE; // longer, but will only put in a default if args.x is not supplied this.x = (args.x !== undefined) ? args.x : SOME_DEFAULT_VALUE; } var obj = new Something({x: 0, y: 0}); 

Ili, ako morate koristiti niz:

 function Something(args) { var x = args[0]; var y = args[1]; } var obj = new Something([0, 0]); 
1
23 окт. Odgovor dao Anthony Mills Oct 23. \ t 2009-10-23 00:31 '09 u 0:31 2009-10-23 00:31

Otopina bez ES6 ili polifila:

 var obj = _new(Demo).apply(["X", "Y", "Z"]); function _new(constr) { function createNamedFunction(name) { return (new Function("return function " + name + "() { };"))(); } var func = createNamedFunction(constr.name); func.prototype = constr.prototype; var self = new func(); return { apply: function(args) { constr.apply(self, args); return self; } }; } function Demo() { for(var index in arguments) { this['arg' + (parseInt(index) + 1)] = arguments[index]; } } Demo.prototype.tagged = true; console.log(obj); console.log(obj.tagged); 


izlaz

Demo {arg1: "X", arg2: "Y", arg3: "Z"}


... ili "kraće":

 var func = new Function("return function " + Demo.name + "() { };")(); func.prototype = Demo.prototype; var obj = new func(); Demo.apply(obj, ["X", "Y", "Z"]); 


promijeniti
Mislim da je ovo dobro rješenje:

 this.forConstructor = function(constr) { return { apply: function(args) { let name = constr.name.replace('-', '_'); let func = (new Function('args', name + '_', " return function " + name + "() { " + name + "_.apply(this, args); }"))(args, constr); func.constructor = constr; func.prototype = constr.prototype; return new func(args); }}; } 
1
01 сент. Odgovor je dao Martin Wantke 01 rujna. 2017-09-01 15:14 '17 u 15:14 2017-09-01 15:14

@ Matthew je promijenio odgovor. Ovdje mogu proći bilo koji broj parametara za rad kao i obično (a ne niz). Osim toga, "nešto" nije teško kodirano:

 function createObject( constr ) { var args = arguments; var wrapper = function() { return constr.apply( this, Array.prototype.slice.call(args, 1) ); } wrapper.prototype = constr.prototype; return new wrapper(); } function Something() { // init stuff }; var obj1 = createObject( Something, 1, 2, 3 ); var same = new Something( 1, 2, 3 ); 
1
04 апр. odgovor je dao Eugen Konkov 04. travnja. 2015-04-04 17:10 '15 u 17:10 2015-04-04 17:10

Ovaj sloj jednog retka trebao bi to učiniti:

 new (Function.prototype.bind.apply(Something, [null].concat(arguments))); 
1
10 июля '15 в 15:43 2015-07-10 15:43 Odgovor je dao aleemb 10. srpnja '15 u 15:43 2015-07-10 15:43
 function createSomething() { var args = Array.prototype.concat.apply([null], arguments); return new (Function.prototype.bind.apply(Something, args)); } 

Ako vaš ciljani preglednik ne podržava ECMAScript 5 Function.prototype.bind , kôd neće raditi. To nije vjerojatno, pogledajte tablicu kompatibilnosti .

1
16 авг. odgovor daje korisnik2683246 16 aug. 2013-08-16 04:23 '13 u 4:23 2013-08-16 04:23

Rješenja Matthewa Crumleya u CoffeeScriptu:

 construct = (constructor, args) -> F = -> constructor.apply this, args F.prototype = constructor.prototype new F 

ili

 createSomething = (-> F = (args) -> Something.apply this, args F.prototype = Something.prototype return -> new Something arguments )() 
1
06 сент. Odgovor dao Benjie 06. rujna. 2011-09-06 17:32 '11 u 17:32 2011-09-06 17:32

Ovo je moja verzija createSomething :

 function createSomething() { var obj = {}; obj = Something.apply(obj, arguments) || obj; obj.__proto__ = Something.prototype; //Object.setPrototypeOf(obj, Something.prototype); return o; } 

Na temelju toga pokušao sam oponašati new ključnu riječ JavaScripta:

 //JavaScript 'new' keyword simulation function new2() { var obj = {}, args = Array.prototype.slice.call(arguments), fn = args.shift(); obj = fn.apply(obj, args) || obj; Object.setPrototypeOf(obj, fn.prototype); //or: obj.__proto__ = fn.prototype; return obj; } 

Testirao sam ga i čini se da radi dobro za sve scenarije. On također radi sa svojim konstruktorima Date . Evo nekoliko testova:

 //test new2(Something); new2(Something, 1, 2); new2(Date); //"Tue May 13 2014 01:01:09 GMT-0700" == new Date() new2(Array); //[] == new Array() new2(Array, 3); //[undefined × 3] == new Array(3) new2(Object); //Object {} == new Object() new2(Object, 2); //Number {} == new Object(2) new2(Object, "s"); //String {0: "s", length: 1} == new Object("s") new2(Object, true); //Boolean {} == new Object(true) 
0
13 мая '14 в 11:27 2014-05-13 11:27 odgovor je advncd 13. svibnja '14 u 11:27 2014-05-13 11:27

budući da je ES6 moguć preko operatora Spread, pogledajte https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator#Apply_for_new

Taj je odgovor već dan u komentaru na solopackaging.ru.site/questions/16554 / ... , ali čini se da je većina njih propustila

0
08 марта '17 в 12:52 2017-03-08 12:52 odgovor je dao Paul 8. ožujka 2006. u 12:52 2017-03-08 12:52

Da, možemo, javascript je više kao prototype inheritance u prirodi.

 function Actor(name, age){ this.name = name; this.age = age; } Actor.prototype.name = "unknown"; Actor.prototype.age = "unknown"; Actor.prototype.getName = function() { return this.name; }; Actor.prototype.getAge = function() { return this.age; }; 

kada stvaramo objekt s " new ", onda je naš stvoreni INHERITS objekt getAge (), ali ako smo se koristili, apply(...) or call(...) za pozivanje glumca, onda prenosimo objekt na "this" , ali objekt nećemo naslijediti od Actor.prototype

ako izravno ne podnesemo prijavu ili ne dopuštamo Actor.prototype, tada .... "this" će pokazati na "Actor.prototype", a this.name će pisati: Actor.prototype.name . Tako, utječući na sve ostale objekte stvorene s Actor... , budući da prepišemo prototip, a ne instancu

 var rajini = new Actor('Rajinikanth', 31); console.log(rajini); console.log(rajini.getName()); console.log(rajini.getAge()); var kamal = new Actor('kamal', 18); console.log(kamal); console.log(kamal.getName()); console.log(kamal.getAge()); 

Pokušajte upotrijebiti apply

 var vijay = Actor.apply(null, ["pandaram", 33]); if (vijay === undefined) { console.log("Actor(....) didn't return anything since we didn't call it with new"); } var ajith = {}; Actor.apply(ajith, ['ajith', 25]); console.log(ajith); //Object {name: "ajith", age: 25} try { ajith.getName(); } catch (E) { console.log("Error since we didn't inherit ajith.prototype"); } console.log(Actor.prototype.age); //Unknown console.log(Actor.prototype.name); //Unknown 

Prolaskom Actor.prototype na Actor.call() kao prvi argument, kada se izvodi funkcija Actor (), izvršava this.name=name , jer će "this" pokazivati ​​na Actor.prototype , this.name=name; means Actor.prototype.name=name; this.name=name; means Actor.prototype.name=name;

 var simbhu = Actor.apply(Actor.prototype, ['simbhu', 28]); if (simbhu === undefined) { console.log("Still undefined since the function didn't return anything."); } console.log(Actor.prototype.age); //simbhu console.log(Actor.prototype.name); //28 var copy = Actor.prototype; var dhanush = Actor.apply(copy, ["dhanush", 11]); console.log(dhanush); console.log("But now we've corrupted Parent.prototype in order to inherit"); console.log(Actor.prototype.age); //11 console.log(Actor.prototype.name); //dhanush 

Vraćajući se na izvorno pitanje kako koristiti new operator with apply , ovdje je moj prijem ....

 Function.prototype.new = function(){ var constructor = this; function fn() {return constructor.apply(this, args)} var args = Array.prototype.slice.call(arguments); fn.prototype = this.prototype; return new fn }; var thalaivar = Actor.new.apply(Parent, ["Thalaivar", 30]); console.log(thalaivar); 
0
25 февр. Odgovor dao Thalaivar 25. veljače. 2016-02-25 02:17 '16 u 2:17 2016-02-25 02:17

Zapravo, najlakši način:

 function Something (a, b) { this.a = a; this.b = b; } function createSomething(){ return Something; } s = new (createSomething())(1, 2); // s == Something {a: 1, b: 2} 
0
27 февр. odgovor daje korisnik3184743 27. veljače 2018-02-27 10:53 '18 u 10:53 sati 2018-02-27 10:53
 function FooFactory() { var prototype, F = function(){}; function Foo() { var args = Array.prototype.slice.call(arguments), i; for (i = 0, this.args = {}; i < args.length; i +=1) { this.args[i] = args[i]; } this.bar = 'baz'; this.print(); return this; } prototype = Foo.prototype; prototype.print = function () { console.log(this.bar); }; F.prototype = prototype; return Foo.apply(new F(), Array.prototype.slice.call(arguments)); } var foo = FooFactory('a', 'b', 'c', 'd', {}, function (){}); console.log('foo:',foo); foo.print(); 
0
17 дек. Odgovor daje korisnik2217522 17. prosinca. 2013-12-17 04:26 '13 u 4:26 2013-12-17 04:26

Dok su drugi pristupi izvedivi, oni su pretjerano složeni. U Clojureu, obično kreirate funkciju koja stvara instance / records i koristi ovu funkciju kao mehanizam za stvaranje instance. Prenošenje na javascript:

 function Person(surname, name){ this.surname = surname; this.name = name; } function person(surname, name){ return new Person(surname, name); } 

Koristeći ovaj pristup, izbjegavate korištenje new , osim kako je gore opisano. Ova funkcija, naravno, nema problema s apply ili bilo kojim drugim funkcijama funkcionalnog programiranja.

 var doe = _.partial(person, "Doe"); var john = doe("John"); var jane = doe("Jane"); 

Koristeći ovaj pristup, svi konstruktori vašeg tipa (na primjer, Person ) su konstruktori vanilije. Jednostavno proslijedite argumente i dodijelite ih svojstvima istog imena. Dlakavi detalji su uključeni u funkciju konstruktora (na primjer, Person ).

Nema potrebe brinuti se o stvaranju dodatnih funkcija konstruktora, jer su dobre prakse. Oni mogu biti prikladni jer omogućuju potencijalno nekoliko funkcija konstruktora s različitim nijansama.

0
14 окт. odgovor je dan Mario 14. listopada. 2016-10-14 19:27 '16 u 19:27 2016-10-14 19:27

Također je zanimljivo vidjeti kako je problem ponovne uporabe F() privremenog konstruktora riješen pomoću arguments.callee , kao i sama tvornica / tvornica: http://www.dhtmlkitchen.com/?category=/JavaScript/ 05/11 / ulaz = Dekorater-tvornica-aspekt

0
20 мая '11 в 19:08 2011-05-20 19:08 odgovor je dat polaretto 20. svibnja '11 u 19:08 2011-05-20 19:08

Revidirana odluka je iz @jordancpaul odgovora.

 var applyCtor = function(ctor, args) { var instance = new ctor(); ctor.prototype.constructor.apply(instance, args); return instance; }; 
0
05 марта '18 в 23:14 2018-03-05 23:14 odgovor je dat tech-e 5. ožujka u 23:14 2018-03-05 23:14

Svaka funkcija (čak i konstruktor) može uzeti varijabilni broj argumenata. Svaka funkcija ima varijablu "argumenata" koja se može proslijediti nizu pomoću [].slice.call(arguments) .

 function Something(){ this.options = [].slice.call(arguments); this.toString = function (){ return this.options.toString(); }; } var s = new Something(1, 2, 3, 4); console.log( 's.options === "1,2,3,4":', (s.options == '1,2,3,4') ); var z = new Something(9, 10, 11); console.log( 'z.options === "9,10,11":', (z.options == '9,10,11') ); 

Gore navedeni testovi daju sljedeće rezultate:

 s.options === "1,2,3,4": true z.options === "9,10,11": true 
0
18 сент. Odgovor daje Wil Moore III 18 sep. 2012-09-18 20:10 '12 u 20:10 2012-09-18 20:10

zašto činite stvari tako kompliciranim. Nakon novog, upotrijebite anonimnu funkciju koja vraća konstruktorsku funkciju koristeći niz s argumentima.

 function myConstructor(a,b,c){ this.a = a; this.b = b; this.c = c; } var newObject = new myConstructor(1,2,3); // {a: 1, b: 2, c: 3} var myArguments = [1,2,3]; var anotherObject = new function(){ return myConstructor.apply(this,myArguments); }; // {a: 1, b: 2, c: 3} 
-1
17 мая '16 в 7:59 2016-05-17 07:59 odgovor je dat Paweł 17. svibnja '16 u 7:59 2016-05-17 07:59
  • 1
  • 2