À quoi sert" self " dans Swift?

Mise À Jour: 24 Novembre 2015

Oui, c'est la même chose que this dans Java et self dans Objective-C , mais avec Swift , l'auto n'est besoin lorsque vous appelez une propriété ou une méthode d'une fermeture ou de différencier les noms de propriété à l'intérieur de votre code ( par exemple initialiseurs). Vous pouvez donc utiliser presque tous les composants de votre classe en toute sécurité sans utiliser self sauf si vous faites l'appel d'une fermeture.

" la propriété de soi chaque instance d'un type a une propriété implicite appelé self , qui est exactement équivalent à l'instance elle-même. Vous utilisez la propriété self pour faire référence à l'instance courante dans son méthodes de la propre instance.

la méthode increment() dans l'exemple ci-dessus aurait pu être écrite comme ceci:

func increment() {
    self.count++
}

en pratique, vous n'avez pas besoin d'écrire self dans votre code très souvent. Si vous n'écrivez pas explicitement self , Swift présume que vous êtes se référant à une propriété ou à une méthode de l'instance courante chaque fois que vous utilisez un nom de propriété ou de méthode connu dans une méthode. Cette hypothèse est démontrée par l'utilisation de count (plutôt que self.count ) à l'intérieur des trois méthodes d'instance pour le compteur.

le principal exception à cette règle se produit lorsqu'un nom de paramètre pour une méthode d'instance a le même nom qu'une propriété de cette instance. Dans cette situation, le nom du paramètre a priorité, et il devient vous devez faire référence au bien d'une façon plus admissible. Vous utilisez la propriété self pour distinguer entre le nom du paramètre et le nom de la propriété.

ici, self désambiguise entre un paramètre de méthode appelé x et un propriété d'instance qui est également appelé x : "

Extrait De: Apple Inc. "Le Langage De Programmation Swift (Swift 2 Prerelease)."

C'est ainsi que Ray Wenderlich recommande L'utilisation de self dans Swift pour leurs tutoriels:

utilisation de soi

pour concision, évitez d'utiliser self puisque Swift ne l'exige pas pour accéder aux propriétés d'un objet ou invoquer ses méthodes.

utiliser self lorsque requis pour différencier les noms de propriétés et les arguments dans les initialiseurs, et quand référencement des propriétés dans les expressions de fermeture (tel que requis par le compilateur):

class BoardLocation {
  let row: Int, column: Int

  init(row: Int, column: Int) {
    self.row = row
    self.column = column

    let closure = {
      println(self.row)
    }
  }
}

et ce sont GitHub " recommandations sur self pour leurs applications:

ne faire explicitement référence à self que lorsque requis

lors de l'accès aux propriétés ou aux méthodes sur self , laisser la référence à self implicite par défaut:

private class History {
    var events: [Event]

    func rewrite() {
        events = []
    }
}

n'inclure le mot-clé explicite que lorsque la langue l'exige-par exemple, dans une fermeture, ou lorsque les noms de paramètres sont en conflit:

extension History {
    init(events: [Event]) {
        self.events = events
    }

    var whenVictorious: () -> () {
        return {
            self.rewrite()
        }
    }
}

justification: cela rend la sémantique de capture de soi se démarquer davantage dans les fermetures, et évite la verbosité ailleurs.

dans quelles situations il est nécessaire de l'utiliser

Il est nécessaire pour l'utiliser uniquement lorsque le nom d'une variable locale oublier le nom d'une propriété.

Cependant, comme une question de style (et la lisibilité), je l'utilise toujours:

• variable (puisque ce n'est ni déclarés localement ni un paramètre entrant).

• Je l'utilise comme récepteur d'appels de fonction (méthode), afin de différencier de telles méthodes des fonctions de haut niveau ou locales.

je vais vous expliquer pourquoi nous avons besoin de self .

quand on définit une classe, comme:

class MyClass {
    func myMethod()
}

nous créons un Class Object . Oui, La classe est un objet aussi.

alors peu importe le nombre d'instances créées en utilisant la classe, toutes les instances auront un point de référence à son Class Object .

vous pouvez imaginer que toutes les instances les méthodes définies par la classe sont dans L'objet Class, et il n'y en aura qu'une copie.

cela signifie que toutes les instances créées en utilisant la classe partagent la même méthode.

maintenant imaging que vous êtes le myMethod dans L'objet Class, et parce que vous êtes partagés pour toutes les instances, vous devez avoir un moyen de dire sur quelle instance vous travaillez.

quand quelqu'un dit instance1.myMethod() , ça veut dire "Salut! myMethod , merci de faire votre travail instance1 est l'objet que vous êtes en train de travailler."

comment référez-vous l'objet que l'appelant vous a envoyé, utilisez self .

corrigez-moi si je me trompe, merci.

"Dans la pratique, vous n'avez pas besoin d'écrire de soi dans votre code très souvent. Si vous ne vous écrivez pas explicitement vous-même, Swift suppose que vous faites référence à une propriété ou méthode de l'instance courante chaque fois que vous utilisez un propriété connue ou nom de méthode dans une méthode."

Extrait De: Apple Inc. "Le Langage De Programmation Swift."iBooks. https://itun.es/tw/jEUH0.l

tout D'abord: bonnes réponses, exemples et explications déjà postés ici, bien que je doive souligner quelque chose:

mot réservé: self dans swift est similaire à this mais ce n'est pas la même chose qu'en Java ou Javascript .

comme @Dave Gomez correctement cité:

chaque instance d'un type a une propriété implicite appelée soi, qui est exactement équivalent à la l'instance elle-même.

et ici commence une des principales différences, parce que:

1. "Chaque instance de" dans swift (au moins pour l'instant) est presque Chaque chose
2. Lorsqu'en Java (par exemple) vous ne pouvez utiliser que le mot this à l'intérieur d'une portée d'instance, dans swift vous pouvez l'utiliser presque Every-where

voici quelques exemples:

//Example 1:
var x="foo"
x.self="bar".self//compiles and run

//Example 2:
print.self(x);//compiles and run

//Example 3:
func myOther(self otherSelf:Person){}
myOther(self: personObject);//compiles and run

//Example 4:
class Foo{
      var bar=""
      init(){
          self.addSome()//this would be the same in Java
      }
      func addSome(){
          //But definitely not this:
          self.self.bar.self.self="some".self.self
      }
}
//Guess what - also compiles and run...
let f=Foo()
print(f.bar)

si vous voulez en savoir plus, s'il vous plaît voir: pourquoi 'self.soi " compiler et exécuter en swift

la question OP est sur ce que c'est dans swift, donc je ne vais pas ennuyer les lecteurs avec des explications ce que C'est en Java ou Javascript (mais si certains lecteurs ont besoin il suffit d'écrire un commentaire).

l'article suivant explique self en détail:

comment utiliser correctement le mot-clé "self" dans Swift

self est une propriété sur l'instance qui se réfère à elle-même. Il est utilisé pour accéder à la classe, la structure et l'instance d'énumération dans les méthodes.

quand on accède à self dans une méthode de type ( static func ou class func ), il se réfère au type réel (plutôt que d'un exemple).

Swift permet d'omettre self lorsque vous voulez accéder aux propriétés des instances.

Lorsqu'un paramètre de méthode a le même nom que la propriété d'instance, vous devez explicitement utiliser self.myVariable = myVariable pour faire une distinction. Notez que les paramètres de la méthode ont une priorité sur les propriétés de l'occurrence.

self est une propriété sur l'instance qui se réfère à elle-même. Il est utilisé pour accéder à la classe, la structure et l'instance d'énumération dans les méthodes. Quand un paramètre de méthode a le même nom que la propriété instance, vous devez explicitement utiliser self.mavariable = mavariable faire une distinction. Notez que les paramètres de la méthode ont une priorité sur les propriétés de l'occurrence.

    struct Weather {
let windSpeed: Int
  let chanceOfRain: Int
  init(windSpeed: Int, chanceOfRain: Int) {
    self.windSpeed = windSpeed
    self.chanceOfRain = chanceOfRain
  }

  func isDayForWalk() -> Bool {
    let comfortableWindSpeed = 5
    let acceptableChanceOfRain = 30
    return self.windSpeed <= comfortableWindSpeed
      && self.chanceOfRain <= acceptableChanceOfRain
  }

}
// A nice day for a walk
let niceWeather = Weather(windSpeed: 4, chanceOfRain: 25)  
print(niceWeather.isDayForWalk()) // => true