Quelle est la différence entre `let` et` var` dans swift?

Quelle est la différence entre let et var dans le langage Swift d’Apple?

À ma connaissance, il s’agit d’un langage compilé mais il ne vérifie pas le type au moment de la compilation. Cela me rend confus. Comment le compilateur connaît-il l’erreur de type? Si le compilateur ne vérifie pas le type, n’est-ce pas un problème avec l’environnement de production?

Le mot let clé let définit une constante:

 let theAnswer = 42 

La theAnswer ne peut pas être modifiée ultérieurement. C’est pourquoi tout ce qui est weak ne peut être écrit en utilisant let . Ils doivent changer pendant l’exécution et vous devez utiliser var place.

Le var définit une variable ordinaire.

Ce qui est intéressant:

La valeur d’une constante n’a pas besoin d’être connue au moment de la compilation , mais vous devez affecter la valeur exactement une fois.

Une autre caractéristique étrange:

Vous pouvez utiliser presque tous les caractères que vous aimez pour les noms de constante et de variable, y compris les caractères Unicode:

 let 🐶🐮 = "dogcow" 

Extraits de: Apple Inc. «Le langage de programmation rapide». IBooks. https://itunes.apple.com/WebObjects/MZStore.woa/wa/viewBook?id=881256329

MODIFIER

Parce que les commentaires demandant d’append d’autres faits à la réponse, la convertir en réponse wiki de la communauté . N’hésitez pas à modifier la réponse pour la rendre meilleure.

Selon le livre de langage de programmation rapide

Comme C, Swift utilise des variables pour stocker et faire référence aux valeurs par un nom d’identification. Swift utilise également largement les variables dont les valeurs ne peuvent pas être modifiées. Celles-ci sont connues sous le nom de constantes et sont beaucoup plus puissantes que les constantes dans C.

Les deux var et let sont des références , donc let est une référence const . Utiliser des types fondamentaux ne montre pas vraiment la différence entre const . La différence vient lorsque vous l’utilisez avec des instances de classe (types de référence):

 class CTest { var str : Ssortingng = "" } let letTest = CTest() letTest.str = "test" // OK letTest.str = "another test" // Still OK //letTest = CTest() // Error var varTest1 = CTest() var varTest2 = CTest() var varTest3 = CTest() varTest1.str = "var 1" varTest2.str = "var 2" varTest3 = varTest1 varTest1.str = "var 3" varTest3.str // "var 3" 

let est utilisé pour définir des constantes et var pour définir des variables.

Très simple:

  • let est constante.
  • var est dynamic.

Peu de description:

let crée une constante. (un peu comme une NSSsortingng ). Vous ne pouvez pas modifier sa valeur une fois que vous l’avez définie. Vous pouvez toujours l’append à d’autres choses et créer de nouvelles variables.

var crée une variable. (un peu comme NSMutableSsortingng ) pour pouvoir en changer la valeur. Mais cela a été répondu à plusieurs resockets.

le

La section Déclarer les constantes et les variables de la documentation de Swift Programming Language spécifie ce qui suit:

Vous déclarez des constantes avec le mot-clé let et des variables avec le mot-clé var.

Assurez-vous de comprendre comment cela fonctionne pour les types de référence. Contrairement aux types de valeur, les propriétés sous-jacentes de l’object peuvent changer malgré une instance d’un type de référence déclarée comme constante. Reportez-vous à la section Classes sont des types de référence de la documentation et examinez l’exemple où ils modifient la propriété frameRate.

Il est peut-être préférable d’énoncer cette différence par la notion de mutabilité / indisponibilité, qui est le paradigme correct de la perméabilité aux valeurs et aux instances dans l’espace des objects, plus grand que les seules notions habituelles “constantes / variables”. Et de plus, cela est plus proche de l’approche de l’objective C.

2 types de données: type de valeur et type de référence.

Dans le contexte des types de valeur:

‘let’ définit une valeur constante (indomptable). ‘var’ définit une valeur modifiable (mutable).

 let aInt = 1 //< aInt is not changeable var aInt = 1 //< aInt can be changed 

Dans le contexte des types de référence:

L'étiquette d'une donnée n'est pas la valeur mais la référence à une valeur.

si aPerson = Personne (nom: Foo, premier: Barre)

aPerson ne contient pas les données de cette personne mais la référence aux données de cette personne.

 let aPerson = Person(name:Foo, first:Bar) //< data of aPerson are changeable, not the reference var aPerson = Person(name:Foo, first:Bar) //< both reference and data are changeable. eg: var aPersonA = Person(name:A, first: a) var aPersonB = Person(name:B, first: b) aPersonA = aPersonB aPersonA now refers to Person(name:B, first: b) 

let définit une “constante”. Sa valeur est définie une fois et une seule fois, mais pas nécessairement lorsque vous la déclarez. Par exemple, vous utilisez let pour définir une propriété dans une classe qui doit être définie lors de l’initialisation:

 class Person { let firstName: Ssortingng let lastName: Ssortingng init(first: Ssortingng, last: Ssortingng) { firstName = first lastName = last super.init() } } 

Avec cette configuration, il est invalide d’affecter à firstName ou lastName après avoir appelé (par exemple) Person(first:"Malcolm", last:"Reynolds") pour créer une instance de Person .

Vous devez définir un type pour toutes les variables ( let ou var ) au moment de la compilation, et tout code qui tente de définir une variable ne peut utiliser que ce type (ou un sous-type). Vous pouvez affecter une valeur à l’exécution, mais son type doit être connu à la compilation.

Une autre différence que j’ai rencontrée dans d’autres langages pour les constantes est la suivante: impossible d’initialiser la constante (let) pour plus tard , devrait initialiser à mesure que vous déclarez la constante.

Par exemple :

 let constantValue : Int // Comstack error - let declarations require an initialiser expression 

Variable

 var variableValue : Int // No issues 

let est utilisé pour déclarer une valeur constante qui signifie que vous ne le changerez pas après lui avoir donné une valeur initiale.
var permet de décaler une valeur de variable, ce qui signifie que vous pouvez modifier sa valeur à votre guise.

let est utilisé pour définir des constantes et var pour définir des variables. Vous définissez la chaîne en utilisant var, alors que Ssortingng peut être modifié (ou muté) en l’affectant à une variable (auquel cas il peut être modifié), et si vous définissez la chaîne en utilisant so sa constante (auquel cas elle ne peut pas être modifiée). modifié):

 var variableSsortingng = "Apple" variableSsortingng += " and Banana" // variableSsortingng is now "Apple and Banana" let constantSsortingng = "Apple" constantSsortingng += " and another Banana" // this reports a comstack-time error - a constant ssortingng cannot be modified 

Comme Luc-Oliver, NullData, et quelques autres ont dit ici, let définir des données immuables alors que var définit des données mutables. Toute func pouvant être appelée sur la variable marquée mutating ne peut être appelée que s’il s’agit d’une variable var (le compilateur produira une erreur). Cela s’applique également aux func qui inout une variable inout .

Cependant, let et var signifient également que la variable ne peut pas être réaffectée. Il a deux sens, tous deux ayant des buts très similaires

La valeur de la variable peut être modifiée après l’initialisation. Mais que la valeur ne soit pas changée, quand elle est intiliée une fois.

En cas de var

  function variable() { var number = 5, number = 6; console.log(number); // return console value is 6 } variable(); 

En cas de let

  function abc() { let number = 5, number = 6; console.log(number); // TypeError: redeclaration of let number } abc(); 

Le mot-clé var permet de définir une variable dont vous pouvez facilement modifier la valeur:

 var no1 = 1 // declaring the variable no1 = 2 // changing the value since it is defined as a variable not a constant 

Cependant, le mot-clé let sert uniquement à créer une constante utilisée lorsque vous ne souhaitez plus modifier la valeur de la constante. Si vous deviez essayer de changer la valeur de la constante, vous obtiendrez une erreur:

 let no2 = 5 // declaring no2 as a constant no2 = 8 // this will give an error as you cannot change the value of a constant 

Let est une variable immuable, ce qui signifie qu’il ne peut pas être changé, d’autres langages l’appellent une constante. En C ++, vous pouvez le définir comme const.

Var est une variable mutable, ce qui signifie qu’elle peut être modifiée. En C ++ (mise à jour de la version 2011), l’utilisation d’Auto est la même, bien que swift permette une plus grande flexibilité d’utilisation. C’est le type de variable le plus connu des débutants.

“Utilisez let pour faire une constante et var pour faire une variable”

Extrait de: Apple Inc. «Le langage de programmation rapide». IBooks. https://itun.es/us/jEUH0.l

let mot clé définit une constante

 let myNum = 7 

donc myNum ne peut pas être changé après coup;

Mais var définit une variable ordinaire.

La valeur d’une constante n’a pas besoin d’être connue au moment de la compilation, mais vous devez lui atsortingbuer une valeur exactement une fois.

Vous pouvez utiliser presque tous les caractères que vous aimez pour les noms constants et variables, y compris les caractères Unicode;

par exemple

 var x = 7 // here x is instantiated with 7 x = 99 // now x is 99 it means it has been changed. 

Mais si on prend laisse alors …

 let x = 7 // here also x is instantiated with 7 x = 99 // this will a comstack time error 

Tout le monde a à peu près répondu à cette question, mais voici un moyen de vous souvenir de quoi

Laissons toujours dire la même chose de “let” que de laisser ce travail pour une fois et toujours comme pour “var” variable peut toujours changer d’où ils sont appelés variables

let est une valeur constante, donc il ne peut jamais être changé.

 let number = 5 number = 6 //This will not comstack. 

Var est une variable et peut changer (mais une fois défini, il ne s’agit pas d’un type de données différent).

 var number = 5 number = 6 //This will comstack. 

Si vous essayez de changer la variable à un dataType différent, cela ne fonctionnera pas

 var number = 5 number = "Hello World" //This will not comstack. 

var est le seul moyen de créer des variables dans swift. var ne signifie pas variable dynamic comme dans le cas des langages interprétés comme javascript. Par exemple,

 var name = "Bob" 

Dans ce cas, le type de variable dont on suppose que name est de type Ssortingng , nous pouvons également créer des variables en définissant explicitement le type, par exemple

 var age:Int = 20 

Maintenant, si vous assignez une chaîne à l’âge, le compilateur donne l’erreur.

let est utilisé pour déclarer des constantes. Par exemple

 let city = "Kathmandu" 

Ou nous pouvons aussi faire,

 let city:Ssortingng = "Kathmandu" 

Si vous essayez de changer la valeur de city, cela donne une erreur au moment de la compilation.

La principale différence est que la valeur de la variable var peut changer et let ne pas. Si vous souhaitez avoir des données d’entrée utilisateur, vous utiliserez var pour que la valeur puisse être modifiée et let utilisiez la variable de type de données let afin que la valeur ne puisse pas être modifiée.

 var str = "dog" // str value is "dog" str = "cat" // str value is now "cat" let strAnimal = "dog" // strAnimal value is "dog" strAnimal = "cat" // Error ! 

Une valeur peut être réaffectée en cas de var

  //Variables var age = 42 println(age) //Will print 42 age = 90 println(age) //Will Print 90 

** La constante newAge ne peut pas être réaffectée à une nouvelle valeur. Essayer de le faire donnera une erreur de compilation **

 //Constants let newAge = 92 //Declaring a constant using let println(newAge) //Will print 92. 

En swift nous avons deux types de variables

  1. var
  2. laisser

Ces deux tâches sont identiques, contiennent des objects (valeur de copie, valeur de référence, etc.).

Dans la variable var , je peux changer un object contenant un autre pendant l’exécution du programme

 var x = 12 x = 13 // it is Ok 

Dans let variable, je ne peux pas changer d’object contenant un autre pendant l’exécution du programme, mais je dois d’abord l’initialiser. C’est comme constant ou final dans d’autres langages comme Java, C ++.

 let x = 12 x = 13 // it is not OK , it will generate error 

let est utilisé pour les constantes qui ne peuvent pas être modifiées alors que var est une variable ordinaire

Exemple:

let name = “Bob” Quelque chose comme name = “Jim” lancera une erreur car une constante ne peut pas être modifiée.

Bien que je lis actuellement le manuel, je pense que c’est très proche du pointeur C / C ++ const . En d’autres termes, quelque chose comme différence entre char const* et char* . Le compilateur refuse également de mettre à jour le contenu, pas seulement la réaffectation de référence (pointeur).

Par exemple, disons que vous avez cette structure. Veillez à ce que ce soit une structure, pas une classe. AFAIK, les classes n’ont pas de concept d’état immuable.

 import Foundation struct AAA { var inner_value1 = 111 mutating func mutatingMethod1() { inner_value1 = 222 } } let aaa1 = AAA() aaa1.mutatingMethod1() // comstack error aaa1.inner_value1 = 444 // comstack error var aaa2 = AAA() aaa2.mutatingMethod1() // OK aaa2.inner_value1 = 444 // OK 

Les structures étant immuables par défaut, vous devez marquer une méthode de mutating avec une mutating . Et parce que le nom aaa1 est constant, vous ne pouvez appeler aucune méthode de mutateur. C’est exactement ce que nous attendions sur les pointeurs C / C ++.

Je crois que c’est un mécanisme pour supporter une sorte de const-correct .

Déclarez les constantes avec le mot-clé let et les variables avec le mot-clé var.

 let maximumNumberOfLoginAttempts = 10 var currentLoginAttempt = 0 let maximumNumberOfLoginAttempts = 10 var currentLoginAttempt = 0 

Déclarez plusieurs constantes ou plusieurs variables sur une seule ligne, séparées par des virgules:

 var x = 0.0, y = 0.0, z = 0.0 

Impression de constantes et de variables

Vous pouvez imprimer la valeur actuelle d’une constante ou d’une variable avec la fonction println:

 println(friendlyWelcome) 

Swift utilise l’interpolation de chaîne pour inclure le nom d’une constante ou d’une variable en tant qu’espace réservé dans une chaîne plus longue

Enveloppez le nom entre parenthèses et échappez-le avec une barre oblique inverse avant la parenthèse d’ouverture:

 println("The current value of friendlyWelcome is \(friendlyWelcome)") 

Référence: http://iosswift.com.au/?p=17

Trouvé une bonne réponse espère que cela peut aider 🙂 entrer la description de l'image ici