Domanda

Ho letto questa risposta e i suoi commenti e sono curioso: ci sono ragioni per non usare this / Self / Me ?

A proposito: mi dispiace se questo è stato chiesto in precedenza, sembra che sia impossibile cercare la parola this su SO.

È stato utile?

Soluzione

Avvertenza: risposta puramente soggettiva di seguito.

Penso che il migliore "motivo" perché non usare questo / io / me è brevità. Se è già una variabile / funzione membro, perché aggiungere ridondante il prefisso?

Personalmente evito l'uso di this / self / me a meno che non sia necessario disambiguare una particolare espressione per il compilatore. Molte persone non sono d'accordo con questo, ma non ho mai avuto un vero punto critico in qualsiasi gruppo per cui ho lavorato.

Altri suggerimenti

Penso che la maggior parte degli scenari comuni siano stati trattati nei due post già citati; principalmente brevità e ridondanza vs chiarezza - un'aggiunta minore: in C #, è necessario utilizzare "questo". per accedere a un "metodo di estensione" per il tipo corrente, ad esempio

this.Foo();

dove Foo () è dichiarato esternamente come:

public static void Foo(this SomeType obj) {...}

Chiarisce in alcuni casi, come questo esempio in c #:

public class SomeClass
{
    private string stringvar = "";

    public SomeClass(string stringvar)
    {
        this.stringvar = stringvar;
    }
}

Se usi StyleCop con tutte le regole attive, ti fa inserire this. in. Da quando ho iniziato a usarlo, trovo che il mio codice sia più leggibile, ma questa è una preferenza personale.

Penso che questo non sia un problema, perché aggiunge solo più leggibilità al codice, il che è una buona cosa.

Per alcune lingue, come PHP, è persino obbligatorio aggiungere un prefisso con $ this- > se devi utilizzare campi o metodi di classe.

Non mi piace il fatto che renda alcune righe inutilmente più lunghe di quanto potrebbero essere, se PHP avesse un modo per fare riferimento ai membri della classe senza di esso.

Personalmente trovo che this.whatever sia meno leggibile. Potresti non notare la differenza in un metodo a 2 righe, ma aspetta di ottenere this.variable e this.othervariable ovunque in una classe.

Inoltre, penso che l'uso di this. sia stato trovato in sostituzione di una parte della tanto odiata notazione ungherese. Alcune persone là fuori hanno scoperto che è ancora più chiaro per il lettore vedere che una variabile è un membro della classe, e questo. ha fatto il trucco. Ma perché prenderci in giro e non usare il semplice " m_ " o semplicemente " _ " per questo, se abbiamo bisogno di maggiore chiarezza? Sono 5 caratteri contro 2 (o anche 1). Meno battitura a macchina, stesso risultato.

Detto questo, la scelta dello stile è ancora una questione di preferenza personale. È difficile convincere qualcuno a leggere il codice in un certo modo utile per cambiarlo.

beh, eclipse colora campi, argomenti e variabili locali in diversi colori, quindi almeno lavorando in un ambiente eclipse non è necessario distinguere sintatticamente i campi per contrassegnarli in modo speciale come " campi " per te e le generazioni a venire.

In effetti era stato chiesto prima, nella variabile "quotata in java" contesto:

Prefissi la variabile dell'istanza con "this" in java?

Il motivo principale ricorrente sembra essere:

  

" aumenta il rumore visivo che devi scorrere per trovare il significato del codice. "

Leggibilità, in altre parole ... che non compro, trovo questo. molto utile.

Mi sembra una sciocchezza. L'uso di 'this' può rendere il codice più gradevole e non vedo problemi con esso. Politiche del genere sono stupide (almeno quando non dici nemmeno alle persone perché sono a posto).

'questo.' nel codice mi suggerisce sempre che il programmatore ha usato l'intellisense (o altri equivalenti IDE) per fare il suo lavoro pesante.

Sono certamente colpevole di questo, tuttavia, per motivi puramente vanitosi, li rimuovo in seguito.

Le uniche altre ragioni per cui le uso sono qualificare una variabile ambigua (cattiva pratica) o costruire un metodo di estensione

Qualificazione di una variabile

string name; //should use something like _name or m_name

public void SetName(string name)
{
     this.name = name;
}

quanto a me uso this per chiamare i metodi di un oggetto istanziato mentre self è per un metodo statico

In VB.NET una delle pratiche comuni che uso è il seguente codice:

Class Test
    Private IntVar AS Integer
    Public Function New(intVar As Integer)
       Me.Intvar = intvar
    End Function    
End Class

Non sempre, ma soprattutto Me / this / self è abbastanza utile. Chiarisce l'ambito di cui stai parlando.

In un tipico metodo setter (tratto dalla risposta di lagerdalek):

string name;

public void SetName(string name)
{
     this.name = name;
}

Se non l'hai usato, il compilatore non saprebbe che ti riferivi alla variabile membro.
L'uso di this. è di dire al compilatore che è necessario accedere a una variabile membro - che non rientra nell'ambito immediato del metodo. La creazione di una variabile all'interno di un metodo con lo stesso nome di una variabile membro è perfettamente legale, proprio come sovrascrivere un metodo in una classe che ha esteso un'altra classe è perfettamente legale.
Tuttavia, se hai ancora bisogno di usare il metodo della super classe, usi super. secondo me usando questo. non è peggio che usare super. e consente al programmatore una maggiore flessibilità nel proprio codice.

Per quanto mi riguarda, la leggibilità non ci arriva nemmeno, riguarda l'accessibilità delle variabili.

Alla fine è sempre una questione di scelta personale. Personalmente, utilizzo questa convenzione di codifica:

public class Foo
{
  public string Bar
  {
    get
    {
      return this.bar;
    }
    /*set
    {
      this.bar = value;
    }*/
  }
  private readonly string bar;

  public Foo(string bar)
  {
    this.bar = bar;
  }
}

Quindi per me "questo " è effettivamente necessario per rendere leggibile il costruttore.

Modifica: lo stesso esempio è stato pubblicato da " sinje " mentre stavo scrivendo il codice sopra.

Non solo utilizzo spesso " questo " ;. A volte uso " quello " ;.

class Foo
{
    private string bar;

    public int Compare(Foo that)
    {
        if(this.bar == that.bar)
        {
            ...

E così via. & Quot; That " nel mio codice di solito significa un'altra istanza della stessa classe.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top