Esempi di non banale e utile esempio di 'con' la parola chiave?

Question

Trovo ancora la with parola chiave un po'...enigmatico.

Brevemente, with si comporta come questo:

with (obj) {
    // do stuff
}

Questo aggiunge obj il capo del campo di applicazione della catena e poi esegue il blocco di.Quando il blocco è finito si rimuove obj dalla testa dell'ambito di applicazione della catena.

Secondo MDC, questo ti permette di fare cose come

var a, x;
var r = 10;
with(Math) {
    a = PI * r * r;
    x = r * cos(PI / 2);
}

Così posso fa riferimento a proprietà di Math -- come PI -- direttamente, senza dire Math.PI.Che è bello, ma inutile.

Qualcuno può fornire un esempio di un utilizzo interessante di with?

Answer 1

In alternativa alla soluzione chiusura standard utilizzando funzioni all'interno di un ciclo:

<a  href="#">blah</a><br>
<a  href="#">blah</a><br>
<a  href="#">foo</a><br>
<script>
    (function() {
    var anchors = document.getElementsByTagName('a');
        for ( var i = anchors.length; i--; ) {
            var link = anchors[i];
            with ({ number: i }) {
                link.onclick = function() {
                    alert(number);
                };
            }
        }
    })();
</script>

Si ringrazia nlogax per la fornitura di una soluzione che ho praticamente strappato via: Javascript problema Loop infame?

Ecco la soluzione standard:

<script>
    (function() {
    var anchors = document.getElementsByTagName('a');
    for ( var i = anchors.length; i--; ) {
        var link = anchors[i];
        (function(i) {
            link.onclick = function() {
                alert(i)
            }
        })(i);
    }
    })();
</script>

Answer 2

Va detto qui che la dichiarazione with in JavaScript è ampiamente deprecato.

Con Dichiarazione considerati nocivi .

Non posso dire che qualsiasi meglio di lui (sul serio, seguire il link), ma insomma, se si esegue questa operazione:

with (mySuperLongObjectReferenceThatIHateTyping) {
  propertyAlpha = 'a';
  propertyBeta = 2;
  propertyGamma = false;
}

Non si può sapere, cercando in quel codice se si sta assegnando valori di proprietà dell'oggetto mySuperLongObjectReferenceThatIHateTyping o dell'oggetto globale (finestra).

Crockford raccomanda questo:

var o = mySuperLongObjectReferenceThatIHateTyping;
o.propertyAlpha = 'a';
o.propertyBeta = 2;
o.propertyGamma = false;

Il che è inequivocabile. Oppure si potrebbe anche utilizzare una funzione in modo da avere portata e non si crea un'altra variabile globale:

(function(o) {
  o.propertyAlpha = 'a';
  o.propertyBeta = 2;
  o.propertyGamma = false;
})(mySuperLongObjectReferenceThatIHateTyping);

Answer 3

di John Resig javascript microtemplating mostra qualche interessante con i con.

Answer 4

Io lo uso regolarmente per aggiungere più proprietà CSS a un oggetto style, ad esempio

with(document.body.style) {
    color = 'green';
    background = 'red';
}

Inoltre, l'ho usato almeno una volta per assegnare le proprietà di un oggetto a variabili locali senza dover memorizzare un riferimento all'oggetto stesso.

E 'anche un'alternativa alle chiusure quando si vuole scattare una 'fotografia' del valore di una variabile:

var foo = [];
for(var i = 10; i--;)
    with({ i : i }) foo[i] = function() { document.writeln(i); };

// prints 0..9
for(var i = 0; i < foo.length; ++i)
    foo[i]();

Tieni presente che with può seriamente influire sulle prestazioni come la catena di prototipi dell'oggetto si è aggiunto per l'ambiente lessicale deve essere controllato prima quando risolvere qualsiasi nome di variabile.

Answer 5

L'istruzione with a JS è come l'istruzione with a dire VB.net. È semplicemente un modo per evitare ripetizioni con proprietà / metodi di un oggetto.

Per esempio, assumere un controllo etichetta viene modificata in base a un evento / azione. Quello controllo etichetta ha proprietà quali FontColor, CssClass, visibilità ecc.

Al posto della scrittura programmatore:

myLabel.FontColor=Color.Blue
myLabel.CSSClass="SomeCSSClass"
myLabel.Visiblity=True
myLabel.Text = "Hello World"

Si può accorciare a che:

With myLabel
  .Text = "Hello World"
  .FontColor = Color.Blue
  .CssClass="SomeCSSClass"
  .Visibility=True
End With

Answer 6

Io non sono esperto in Javascript, sto iniziando a capire come pensa che dovrebbe essere utilizzato, quindi il mio parere non dovrebbe avere lo stesso peso di quella di qualcuno che è esperto nel linguaggio specifico.Io sarei interessato a risposte per la mia idea.

Sto sperimentando uno stile di definire la classe di oggetti dipende dalla Javascript con istruzione.Io sostengo che questo è un uso legittimo.

Ogni classe-come oggetto in questo stile funziona come una fabbrica di oggetti per soddisfare un qualche scopo.

Questo stile non fare uso di la questo parola chiave per i metodi di istanza.

Questo stile concepisce che ogni oggetto generato da uno di questi classe di oggetti è quello di avere un aspetto pubblico e privato, aspetto.Un oggetto Javascript che rappresenta ognuno di questi aspetti.I titolari di riferimenti all'oggetto, in realtà si parla solo dell'aspetto pubblico.I metodi, tuttavia, sappiamo entrambi gli aspetti e mi implementare con le chiusure.

Non ho la pretesa che questo stile è applicabile ai casi in cui ci si cura molto di runtime tempo o le prestazioni della memoria.Ho volutamente sacrificare un po ' di ciascuno di quelli efficienza di programmazione.Mi aspettavo di trovare un sacco di casi in cui ho voglia di qualcosa di programma rapidamente e con poche possibilità di errore, e in cui le esigenze in fase di runtime non essere critico.

Dal momento che ho cercato di codice in un browser piuttosto che node.js una considerazione pratica dell'ambiente di sviluppo, per me, è che gli errori di sintassi in un grande file di origine può essere difficile da definire e correggere.Ho contrastare questo problema aggiungendo il codice in piccoli incrementi.Voglio, pertanto, la classe di oggetti per essere in grado di accettare un metodo di istanza di definizione alla volta, invece di richiedere che tutte le definizioni di metodo vengono visualizzati in un file di origine.

Dichiaro una classe come oggetto inizialmente senza alcuna istanza metodi definiti in esso, e ho posto la classe come oggetto in qualsiasi spazio dei nomi sono di programmazione in.

Allora chiamo la classe come oggetto ripetutamente a un metodo chiamato "init" e ogni volta che passo davanti a un inizializzatore, una funzione per essere chiamato durante l'inizializzazione di un'istanza.

Alla fine quando ho iniziare a utilizzare la classe come un oggetto, come una fabbrica per i suoi casi, ogni volta che lo chiedo per una nuova istanza, crea, pubblica e privata aspetti per esempio, il link l'aspetto privato al pubblico di uno, quindi chiama tutti gli inizializzatori che sono stati definiti, passando a loro l'aspetto privato di nuova istanza.

Nel mio stile, ogni attributo pubblico è un metodo.Tutte le variabili i cui valori non saranno le funzioni di vivere il lato privato.

Una cosa un inizializzatore può fare è creare una variabile sul lato privato.

Un'altra cosa un inizializzatore può fare è aggiungere un metodo sia il pubblico o il privato.

L'ordine è importante per l'esecuzione di inizializzatori -- classe come oggetto è necessario per la loro esecuzione, nello stesso ordine in cui sono definiti.Di conseguenza, ogni inizializzatore può contare su pubblico e privato, in aspetti dell'istanza di avere gli attributi che sono stati stabiliti dal precedente gli inizializzatori.Per il programmatore, questo crea in effetti un paio di ambiti lessicali, dal momento che il gli inizializzatori non sono stabilite dal condizionale o dinamica di codice di qualsiasi tipo;sono stabiliti, come i file di origine vengono eseguiti dal browser subito dopo si legge e li analizza.

Ora, in alcune lingue, in particolare il linguaggio Ruby e il linguaggio di Sé, è possibile scrivere un nudo identificatore e lo hanno interpretato come una chiamata di metodo sull'oggetto corrente.Così in Ruby, "pippo" si può dire "auto.pippo" e in Auto, "pippo" si può dire "auto pippo" (la sintassi di chiamata al metodo differisce tra queste lingue, ma fino al livello di dettaglio a cui mi riferisco alla semantica ora, "l'auto.pippo" in Ruby e "self pippo" in " Sé stesso).Questa abbreviazione di esistenza di un "sé" è particolarmente conveniente per le chiamate private metodi e le variabili di istanza.Il linguaggio Javascript non fornisce questo tipo di comodità.

In contesti all'interno di un metodo di istanza in cui voglio utilizzare un attributo privato o pubblico per il suo valore (nota, non sulla sinistra di un'assegnazione), mi piace la comodità di riferimento per l'attributo da solo il suo nome e non dover scrivere "var." o "sé". a sinistra per individuare (io uso "vars" per l'aspetto privato e "auto" per l'aspetto pubblico).Per questo motivo, ho avvolgere ogni inizializzatore in Javascript con istruzione.Questo sembra legittimo per me, perché il mio stile, la popolazione dell'oggetto mirato è lessicalmente stabilito.Per vedere gli attributi, il programmatore deve solo guardare il inizializzatori fornito in precedenza nel file di origine per la stessa classe di oggetti simili (che di per sé è identificato dal nome in codice sorgente, software-ingegneria fini, che possiamo considerare come una entità lessicale, anche se nessuno dei Javascript parser in grado di rilevare questo).