Pregunta

Leí esta respuesta y sus comentarios y tengo curiosidad: ¿Hay alguna razón para no usar this / Self / Me ?

Por cierto: lo siento si esto se ha preguntado antes, parece que es imposible buscar la palabra this en SO.

¿Fue útil?

Solución

Advertencia: respuesta puramente subjetiva a continuación.

Creo que la mejor "razón" por no usar esto / self / me es brevedad. Si ya es una variable / función miembro, ¿por qué agregar redundantemente el prefijo?

Personalmente, evito el uso de this / self / me a menos que sea necesario desambiguar una expresión particular para el compilador. Muchas personas no están de acuerdo con esto, pero nunca he tenido que ser un verdadero punto de conflicto en ningún grupo para el que he trabajado.

Otros consejos

Creo que la mayoría de los escenarios comunes se han cubierto en las dos publicaciones ya citadas; principalmente brevedad y redundancia frente a claridad: una adición menor: en C #, se requiere usar " this " para acceder a un " método de extensión " para el tipo actual, es decir,

this.Foo();

donde Foo () se declara externamente como:

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

Se aclara en algunos casos, como este ejemplo en c #:

public class SomeClass
{
    private string stringvar = "";

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

Si usa StyleCop con todas las reglas activadas, le hace poner el this. . Desde que comencé a usarlo, creo que mi código es más legible, pero esa es una preferencia personal.

Creo que esto no es un problema, porque solo agrega más legibilidad al código, lo cual es algo bueno.

Para algunos lenguajes, como PHP, incluso es obligatorio prefijar con $ this- > si necesita usar campos o métodos de clase.

No me gusta el hecho de que hace que algunas líneas sean innecesariamente más largas de lo que podrían ser, si PHP tuviera alguna forma de hacer referencia a los miembros de la clase sin ella.

Personalmente encuentro que this.whatever es menos legible. Es posible que no note la diferencia en un método de 2 líneas, pero espere hasta obtener this.variable y this.othervariable en todas partes de una clase.

Además, creo que el uso de this. se encontró como un reemplazo de una parte de la notoria notación húngara. Algunas personas descubrieron que aún es más claro para el lector ver que una variable es un miembro de la clase, y this. hizo el truco. Pero, ¿por qué engañarnos y no usar el viejo y simple " m_ " o simplemente " _ " para eso, si necesitamos la claridad adicional? Son 5 caracteres vs. 2 (o incluso 1). Menos tipeo, mismo resultado.

Dicho esto, la elección del estilo sigue siendo una cuestión de preferencia personal. Es difícil convencer a alguien que solía leer código de cierta manera que es útil para cambiarlo.

bueno, eclipse hace campos de color, argumentos y variables locales en diferentes colores, por lo que al menos en el entorno de eclipse no hay necesidad de distinguir sintácticamente los campos para marcarlos especialmente como " campos " para ti y para las generaciones venideras.

Se preguntó antes de hecho, en la variable "en java" contexto:

¿Prefiere su variable de instancia con ‘this’ en java?

La razón recurrente principal parece ser:

  

" aumenta el ruido visual que necesita filtrar para encontrar el significado del código. "

Legibilidad, en otras palabras ... que no compro, encuentro esto. muy útil.

Eso me parece una tontería. El uso de 'this' puede hacer que el código sea más agradable, y no veo ningún problema con él. Políticas como esa son estúpidas (al menos cuando ni siquiera le dices a la gente por qué están en su lugar).

'esto'. en el código siempre me sugiere que el codificador ha usado intellisense (u otros equivalentes IDE) para hacer su trabajo pesado.

Ciertamente soy culpable de esto, sin embargo, por razones puramente vanidosas, lo elimino después.

Las únicas otras razones por las que las uso son para calificar una variable ambigua (mala práctica) o construir un método de extensión

Calificación de una variable

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

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

en cuanto a mí, uso this para llamar a métodos de un objeto instanciado mientras que self es para un método estático

En VB.NET, una de las prácticas comunes que uso es el siguiente código:

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

No todo el tiempo, pero principalmente Me / this / self es bastante útil. Aclara el alcance del que está hablando.

En un método de establecimiento típico (tomado de la respuesta de lagerdalek):

string name;

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

Si no lo usó, el compilador no sabría que se refería a la variable miembro.
El uso de this. es decirle al compilador que necesita acceder a una variable miembro, que está fuera del alcance inmediato del método. Crear una variable dentro de un método que tenga el mismo nombre que una variable miembro es perfectamente legal, al igual que reemplazar un método en una clase que ha ampliado otra clase es perfectamente legal. Sin embargo, si todavía necesita usar el método de la superclase, use super. en mi opinión usando esto. no es peor que usar super. y permite al programador una mayor flexibilidad en su código.

En lo que a mí respecta, la legibilidad ni siquiera entra en juego, se trata de la accesibilidad de sus variables.

Al final, siempre es una cuestión de elección personal. Personalmente, uso esta convención de codificación:

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;
  }
}

Entonces para mí " esto " es realmente necesario para que el constructor sea legible.

Editar: exactamente el mismo ejemplo ha sido publicado por "sinje" mientras escribía el código anterior.

No solo uso con frecuencia " this " ;. A veces uso " that " ;.

class Foo
{
    private string bar;

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

Y así sucesivamente. " Eso " en mi código generalmente significa otra instancia de la misma clase.

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top