javascript var vs questo

Question

Se il mio codice è simile a questo, qual è il metodo preferito di usare var vs questo?

function MyObject() { 
    var self = this; 

    var a = 1; 
    this.b = 2; 

    var innerMethod = function() { 

     logMessage(a); 
     logMessage(self.b); 
    } 
} 

quanto ho capito, var sopravviverà più a lungo vive MyObject, così isnt questo lo stesso di utilizzare questo?

EDIT:

Per chiarire la questione più, io sono solo interessati ad accedere variabili da dentro l'oggetto, non dall'esterno.

Answer 1

con var a non puoi accedere alla variabile al di fuori del campo di applicazione però l'assegnazione con this si può accedere quando si effettua un oggetto

Aggiungiamo oggetti da this quando vogliamo le proprietà di esistere con la vita della object.We Usa var per le variabili locali.

"Sono interessato SOLO a accedere alle variabili dall'interno dell'oggetto, non dall'esterno."

risposta a questa affermazione è utilizzare var se si desidera utilizzare solo all'interno della funzione non fuori come variabile definita con var sono accessibili solo per il codice nel campo di applicazione in cui sono stati dichiarati, o in ambiti lessicalmente annidati.

modo Shomz suggerito è possibile controllare come:

var o = new MyObject(); 

una sarà indefinito come viene definito con var

o.a; // undefined 

mentre B saranno di ritorno 2 come è sulla this

o.b; // 2 

Answer 2

Se si desidera utilizzare le proprietà dopo aver creato un'istanza dell'oggetto, var non funziona, vedere di seguito:

function MyObject() { 
 
    var self = this; 
 

 
    var a = 1; 
 
    this.b = 2; 
 

 
    var innerMethod = function() { 
 

 
     logMessage(a); 
 
     logMessage(self.b); 
 
    } 
 
} 
 

 
var o = new MyObject(); 
 
console.log(o.a); // undefined 
 
console.log(o.b); // 2

Answer 3

Se si definisce una variabile come var, allora la sua portata è limitata alla funzione (che non può essere visto dall'esterno). In termini OO è in qualche modo come una proprietà privata, senza in realtà essere una proprietà.

Se si definisce una variabile come proprietà (this.name), è accessibile dall'esterno.

Lo stesso vale per le funzioni. Le funzioni dichiarate nell'ambito della funzione, ma non assegnate a una proprietà, sono visibili solo dall'interno. Se assegni una funzione a una proprietà, puoi accedere a quella funzione dall'esterno (purché la proprietà continui a puntare a quella funzione).

function Person(){ 

    // Declared variable, function scope 
    var name = "John";   

    // Property   
    this.surname = "Doe";  

    // Assign anonymous function to property 
    this.getName = function(){ 
     return name; 
    } 

    // Assign anonymous function to property 
    this.getSurname = function(){ 
     return this.surname; 
    } 

    // Declare function 
    function saluteCasually(){  
     console.log("Hi folks!"); 
    } 

    // Declare function 
    function salutePolitely(){   
     console.log("Nice to meet you"); 
    } 

    // Assign (not anonymous) function to property 
    this.salutePolitely = salutePolitely; 

} 

var person = new Person(); 

console.log(person.name);   // undefined 
console.log(person.getName());  // "John" 
console.log(person.surname);  // "Doe" 
console.log(person.getSurname()); // "Doe" 

person.saluteCasually(); // Error: person has not a property "saluteCasually". 
person.salutePolitely(); // Prints "Nice to meet you"; 

person.salutePolitely = function(){ // Properties can be messed with from anywhere! 
    console.log("Bananas"); 
} 
person.salutePolitely(); // Prints "Bananas"; 

Answer 4

Dipende da ciò che si vuole, utilizzando un VAR all'interno della funzione non renderlo accessibile al di fuori del campo di applicazione funzione, ma dal punto di vista delle prestazioni se si utilizza oggetti tenere tutto all'interno di esso, si è già memorizzato questo oggetto nella memoria perché definire di nuovo un'altra variabile.

come detto nella analisi della memoria 101 forma cromo devtools documentazione:

memoria può essere tenuto da un oggetto in due modi: direttamente dall'oggetto stesso, e implicitamente tenendo riferimenti ad altri oggetti, e quindi impedendo loro di essere automaticamente disposti da un garbage collector (GC in breve).

La dimensione della memoria che viene trattenuta dall'oggetto stesso viene chiamata dimensione ridotta. Gli oggetti JavaScript tipici hanno una memoria riservata per la loro descrizione e per la memorizzazione di valori immediati.

Di solito, solo gli array e le stringhe possono avere dimensioni superficiali significative. Tuttavia, le stringhe spesso hanno la loro memoria principale nella memoria del renderer, esponendo solo un piccolo oggetto wrapper nell'heap di JavaScript.

Tuttavia, anche un piccolo oggetto può contenere una grande quantità di memoria indirettamente, impedendo che altri oggetti vengano eliminati dal processo di garbage collection automatico. La dimensione della memoria che verrà liberata, quando l'oggetto stesso viene eliminato e i suoi oggetti dipendenti resi irraggiungibili dalle radici di GC, è detta dimensione mantenuta.

Devtools Docs