blank.gif
triangle.gif Voi siete qui: /  Inizio pagina  /  Javascript  /  Request    
blank.gif
blank.gif
tl.gif Curriculum Vitae (it) tr.gif tl.gif Certifications tr.gif tl.gif Business-qualifications tr.gif tl.gif Java-developer tr.gif tl.gif Cources tr.gif tl.gif Personality tr.gif tl.gif Profile tr.gif tl.gif Projects tr.gif tl.gif Results tr.gif tl.gif Languages tr.gif tl.gif Education tr.gif
blank.gif
blank.gif
arrow-headline.gif Navigation
arrow-headline.gif Risorse
 

Test di Request.js

Questo demo vi mostrerà come :

  • Crea un Anonimo in funzione javascript
  • Create a singleton in javascript
  • Create a Request object in javascript

Questa demo ed esempi di mostrarvi come facilmente si può usare la funzione javascript singleton.
Si supponga, che si desidera scaricare una richiesta parametri.

Demo del singleton funzione javascript
   // Per prima cosa si deve includere l'oggetto singleton
   <script type="text/javascript" src="Request.js.php"></script>
   // Allora dovete provare la nuova funzione singleton 
  <script type="text/javascript">
	  alert("test di:"+Request.getParameter("Di"));
  </script>

L´intento del Singleton pattern, come definito in Design Patterns è "Assicurarsi che non ci sarà un solo esempio, a livello globale e di fornire un unico punto di accesso ad essa".

Il pattern Singleton è probabilmente il più largamente usato il design pattern in Java.

Per qualche motivo, non sono molte le persone di scrittura di codice javascript con il pattern Singleton in JavaScript, Nonostante il fatto che è estremamente semplice da utilizzare e implementare.

La soluzione più semplice è quella di utilizzare un anonimo costruttore.

Anonmyous un costruttore si chiama così perché non ha un nome. Vedi l´esempio.


Design Patterns in JavaScript: Singleton Anche se JavaScript non può veramente attuare il pattern Singleton, Perché JavaScript non è un linguaggio object-oriented, È possibile simulare un vantaggio di Singleton pattern utilizzando un anonimo La funzione di creare un nuovo oggetto memorizzati in una variabile globale.

Table of Contents

  • Il pattern Singleton e JavaScript
  • Anonimo La funzione è la chiave
  • Utilizzando le funzioni Anonimo
  • Il pattern Singleton e JavaScript

In informatica, il design pattern singleton è progettato per limitare Instantiation di una classe di uno (o alcuni) degli oggetti. Questo è utile quando esattamente un oggetto è necessaria per coordinare le azioni in tutto il sistema.

I programmi JavaScript sono di solito abbastanza semplice da gestire che il Singleton Pattern non è assolutamente necessario. , Ma è buona pratica utilizzare comunque a Chiarire codice.

Se un programma richiede una sola istanza di un oggetto, perché non scrivere il codice per Rendere tale obbligo chiaro?

Se si utilizza un approccio object-oriented per la tua Codice JavaScript, poi seguendo il metodo descritto in questo articolo aiuterà Chiarire quali sono le funzioni per la creazione di singoli oggetti (tonnellate), e che funzioni Sono per la creazione di più oggetti.

La chiave è quella di utilizzare le funzioni per creare anonimo Qualsiasi oggetti che dovrebbe essere limitato a una singola istanza del tuo programma.

Il Singleton pattern può essere simulato in JavaScript:

Utilizzando un anonimo costruttore per creare una funzione di oggetto e il risparmio Restituito oggetto in una variabile

Ad esempio:

	var mySingleton = new function() { 
		// Fare qualcosa di utile
	}

La funzione è la chiave Anonimo Anonimo funzioni sono fondamentali nel nostro attuazione del Singleton pattern; Perché non hanno nome, non possono essere chiamati più di una volta.

"[Non] più di una volta" parte è ciò che vogliamo.

Perché potrei usiamo un nome funzione?

Normalmente una funzione ha un nome nella sua definizione.

Per esempio, in questa funzione, il nome è "SingleObject" e viene dopo il Funzione delle parole chiave e prima della chiamata di funzione operatore ().

	// Questo non è un anonimo funzione,
	// Perché ha un nome, SingleObject
	function SingleObject()	{ 
		// Fare qualcosa di utile
	}

Perché la funzione SingleObject ha un nome, può essere chiamato più di una volta Utilizzando il suo nome. Ecco un esempio:

	// In primo luogo, definire SingleObject
	function SingleObject()	{ 
		// Fare qualcosa di utile
	}
	// SingleObject ora utilizzare più di una volta a creare diversi oggetti dello stesso
    // Con ogni oggetto memorizzato in una diversa variabile 
	var firstObject  = SingleObject(); 
	var secondObject = SingleObject();

Sopra, possiamo vedere che SingleObject è stato utilizzato per creare due oggetti: firstObject E secondObject.

Anche se sono diversi casi essi sono lo stesso oggetto, Tornato da SingleObject.

L´intera idea del Singleton pattern è quello di evitare di avere due lo stesso oggetto.

E il solo modo per impedire la creazione di due oggetti è la stessa per progettare il nostro codice sono Che il codice e SingleObject può essere chiamato una sola volta, e il solo modo per che Fare è quella di utilizzare un anonimo funzione (che non ha alcun nome).

Utilizzando le funzioni Anonimo

Perché un anonimo funzione non ha un nome, è necessario utilizzare la nuova parola chiave a Fare un ´istanza di esso e quindi, per poter utilizzare i nuovi oggetti più tardi, Si deve memorizzare un riferimento ad esso in una variabile tramite l´operatore di assegnamento =, In modo che tu possa fare riferimento ad esso nel codice.

	// Utilizzare la nuova parola chiave e memorizzare in una variabile di riferimento 
	var SingleObject = new function() { 
		this.myMethod = function() {
			alert("Il mio Metodo");
		} 
	}

	// Ora posso utilizzare il mio oggetto, in questo modo
	SingleObject.myMethod();

L´oggetto creato in precedenza con la funzione anonima è stato immagazzinato nella variabile SingleObject. Questa variabile ora contiene un riferimento alla nostra singleton oggetto.

Adesso il nostro oggetto myMethod s può essere utilizzato con il punto e operatore chiamata di funzione Operatore () in questo modo: SingleObject.myMethod ().

Nota che ho sopra utilizzare due funzioni anonime.

Prima di creare il mio SingleObject oggetto e anche nel mio SingleObject definizione di MyMethod creare il mio metodo.

Anche se non si tratta di un obbligo di utilizzare un anonimo funzione per creare il myMethod Metodo, si è conveniente, perché tutto il codice su una sola riga fit. Si trattava di un requisito, Però, che sono un anonimo utilizzare la funzione per creare il mio oggetto singleton, SingleObject, In modo che il codice di creare l´oggetto potrebbe essere chiamato una sola volta.


Clicca per testare l´oggetto Richiesta
Test di Request.js

Questo è il codice di esempio utilizzato per eseguire la demo


<h4>Test di Request.js</h4>
<p>Clicca per testare l'oggetto Richiesta<br />
<a href="./?Personalizzato=Più test" title="Clicca qui">Test di Request.js</a> 
<script type="text/javascript" src="Request.js.php"></script>
<script type="text/javascript">
    var index = Request.getSize();
    Request.setKey  (index,'Personalizzato');
    Request.setValue(index,'Più test');
    if (index!==0) {
        alert('Test del Personalizzato:'+Request.getParameter('Personalizzato'));
    }
    for (var i=0;i<Request.getSize();i++) {
        alert(Request.getKey(i)+'='+Request.getValue(i));
    }
</script>
</p>

Qui c´è il codice sorgente


   1:/**
   2: * This class simulates the servlet request object, in a very primitive matter
   3: * class Request {
   4: *    void init();
   5: *    int getKey();
   6: *    void setKey(int i);
   7: *    int getValue();
   8: *    void setValue(int i);
   9: *    int getSize();
  10: *    String getParameter(string key);
  11: * }
  12: * @package javascript
  13: * @author    http://Finn-Rasmussen.com
  14: * @copyright http://Finn-Rasmussen.com
  15: * @date 2004-02-11
  16: * @version 1.0
  17: */
  18:
  19:/**
  20: * The constructor function simulates the java request object
  21: * The Request object is instanciated with the singeton pattern
  22: * The Singleton pattern is simulated in JavaScript by: 
  23: * - Using an anonymous constructor to create a function object 
  24: * - And saving the returned object in an external variable
  25: * <code>
  26: * Assume the url is : test.html?Say=Hello World
  27: * usage:
  28: *   alert( Request.getParameter('Say'));
  29: * Or
  30: *   Request.setKey  (i,key); // Use custom i, key and value
  31: *   Request.setValue(i,value);
  32: *   for (var i=0;i<Request.getSize();i++) {
  33: *      alert(Request.getKey(i)+'='+Request.getValue(i));
  34: *   }
  35: *   alert(Request.getParameter(key));
  36: * </code>
  37: */
  38:var Request = new function() {
  39:        // proporties
  40:        this.key      = new Array();
  41:        this.value    = new Array();
  42:
  43:        // methods
  44:        /**
  45:         * Get the key from the request object
  46:         * @param int index The index of the array
  47:         * @return String   The key at position index
  48:         */
  49:        this.getKey = function(index) {
  50:                return this.key[index];
  51:        }
  52:        
  53:        /**
  54:         * Set the key in the request object
  55:         * @param int    index The index of the array
  56:         * @param String key   The key to set
  57:         */
  58:        this.setKey = function(index,key) {
  59:                this.key[index] = key;
  60:        }
  61:        
  62:        /**
  63:         * Get the value from the request object
  64:         * @param int index The index of the array
  65:         * @return String   The value at position index
  66:         */
  67:        this.getValue = function(index) {
  68:                return this.value[index];
  69:        }
  70:        
  71:        /**
  72:         * Set the value in the request object
  73:         * @param int    index The index of the array
  74:         * @param String value The value to set
  75:         */
  76:        this.setValue = function(index,value) {
  77:                this.value[index] = value;
  78:        }
  79:
  80:
  81:        /**
  82:         * Get the size of the key/value pair for the request object
  83:         * @return int The size of the array
  84:         */
  85:        this.getSize = function() {
  86:                if (this.key.length!==this.value.length) {
  87:                        alert("Error in Request.js, function getSize(), differences found in the length
length of this.key.length="+this.key.length+"
length of this.value.length="+this.value.length);
  88:                }
  89:                return this.key.length;
  90:        }
  91:
  92:        /**
  93:         * Simulates the java request object used in jsp/servlet
  94:         * Get the value from the key in the request object
  95:         * @param  String key The key to use as lookup
  96:         * @return String The value associated with the key
  97:         */
  98:        this.getParameter = function(key) {
  99:                var value = '';
 100:                for (var i=0;i<this.getSize();i++) {
 101:                        if (key===this.getKey(i)) {
 102:                                // Found a match
 103:                                value = this.getValue(i);
 104:                        }
 105:                }
 106:                return value;
 107:        }
 108:        
 109:        /**
 110:         * The init methode parses the query string and inserts the key/value pairs into the array
 111:         */
 112:        this.init = function() {
 113:                var url      = '' + document.location.href;
 114:                var query    = url.split('?');
 115:                if (query[1]) { // Any query string?
 116:                        var pairs = query[1].split('&'); // Get all key/value pairs x=a&y=b&z=c ...
 117:                        for(var i=0;i<pairs.length;i++) {
 118:                                var keyValue = pairs[i].split('='); // Find key/value pair x=a
 119:                                if (keyValue[1]) {
 120:                                        this.setKey  (i,keyValue[0]); // Create request elements
 121:                                        this.setValue(i,keyValue[1]);
 122:                                } else {
 123:                                        // value = '', So skip this
 124:                                }
 125:                        }
 126:                } else {
 127:                        // No request parameters found
 128:                }
 129:        }
 130:        
 131:        /**
 132:         * Initialize the request object with any request parameters, if any.
 133:         */
 134:        this.init();
 135:}

Demo dei seguenti JavaScript

La seguente demo campioni ti mostrerà come creare un singleton in javascript e come formattare la data e l´importo formato con il locale per la vostra zona

triangle.gif

Dansk

Deutch

English (UK)

France

Italy

Norsk

Svensk

English (USA)


 
blank.gif
triangle.gif Copyright @ 1999-2010 Web specializzata www.Finn-Rasmussen.com Powered by myPHP Version (5.2.6-1+lenny9) 1.11
blank.gif
Valid XHTML 1.0 Strict Valid CSS!
Messages