Val et Var à Kotlin

Question

Quelle est la difference entre var et val en Kotlin?

Je suis passé par ce lien:

https://kotlinlang.org/docs/reference/properties.html

Comme indiqué sur ce lien:

La syntaxe complète d'une déclaration de propriété en lecture seule diffère de celle d'un mutable une de deux manières: il commence par val au lieu de var et fait pas autoriser un passeur.

Mais juste avant il y a un exemple qui utilise un setter.

fun copyAddress(address: Address): Address {
    val result = Address() // there's no 'new' keyword in Kotlin
    result.name = address.name // accessors are called
    result.street = address.street
    // ...
    return result
}

Quelle est la différence exacte entre var et val?

Pourquoi avons-nous besoin des deux?

Ceci est pas une copie} de Variables dans Kotlin, différences avec Java. var vs val? car je m'interroge sur le doute lié à l'exemple donné dans la documentation et pas seulement en général.

Answer 1

Dans votre code result ne change pas, ses propriétés var changent. Reportez-vous aux commentaires ci-dessous:

fun copyAddress(address: Address): Address {
    val result = Address() // result is read only
    result.name = address.name // but not their properties.
    result.street = address.street
    // ...
    return result
}

val est identique au modificateur final en Java. Comme vous devriez probablement savoir que nous ne pouvons pas affecter à une variable final mais que nous pouvons modifier ses propriétés.

Answer 2

val et var sont utilisés pour déclarer une variable.

var est semblable à la variable general et est connue sous le nom de variable mutable dans kotlin et peut être affectée plusieurs fois. 

val ressemble à la variable constant et est appelée immuable dans kotlin et ne peut être initialisée qu'une seule fois.

Pour plus d'informations sur les variables val et var, veuillez consulter le lien ci-dessous.

http://blog.danlew.net/2017/05/30/mutable-vals-in-kotlin/

Answer 3

les variables définies avec var sont mutables (Read and Write)

les variables définies avec val sont immuables (lecture seule)

Kotlin peut supprimer findViewById et réduire le code pour setOnClickListener dans le studio Android. Pour une référence complète: Les fonctions impressionnantes de Kotlin

la valeur des variables mutables peut être modifiée à tout moment, tandis que vous ne pouvez pas modifier la valeur des variables immuables.

où devrais-je utiliser var et où val?

utilisez var où la valeur change fréquemment. Par exemple, lors de la localisation de l'appareil Android

var integerVariable : Int? = null

utilisez val lorsqu'il n'y a pas de changement de valeur dans la classe entière. Par exemple, vous souhaitez définir textview ou le texte du bouton par programme.

val stringVariables : String = "Button's Constant or final Text"

Answer 4

val utiliser pour déclarer la variable finale. Caractéristiques des variables val

1. Doit être initialisé
2. la valeur ne peut pas être modifiée ou réaffectée  

var est une variable générale 

1. Nous pouvons initialiser plus tard en utilisant le modificateur lateinit 

   [lateinit utilise également pour la variable globale on ne peut pas l'utiliser pour la variable locale]

2. la valeur peut être modifiée ou réaffectée mais pas dans la portée globale

 

val dans kotlin est comme final mot-clé dans Java

Answer 5

Il suffit de penser Val comme dernière variable en Java

Answer 6

val estimmutableet var estmutableen Kotlin.

Answer 7

Simplement, Var (mutable) et val (valeurs immuables comme en Java (modificateur final))

var x:Int=3
x *= x

//gives compilation error (val cannot be re-assigned)
val y: Int = 6
y*=y

Answer 8

+----------------+-----------------------------+---------------------------+
|                |             val             |            var            |
+----------------+-----------------------------+---------------------------+
| Reference type | Immutable(once initialized  | Mutable(can able to change|
|                | can't be reassigned)        | value)                    |
+----------------+-----------------------------+---------------------------+
| Example        | val n = 20                  | var n = 20                |
+----------------+-----------------------------+---------------------------+
| In Java        | final int n = 20;           | int n = 20;               |
+----------------+-----------------------------+---------------------------+

Référence

Answer 9

Vous pouvez facilement le penser comme:

var est utilisé pour le setter (la valeur changera).

val est utilisé pour getter (en lecture seule, la valeur ne changera pas).

Answer 10

Fondamentalement 

• var = variable , cela peut donc changer
• val = value , donc cela ne peut pas changer.

Answer 11

val property est similaire à la propriété finale en Java. Vous n'êtes autorisé à lui attribuer une valeur qu'une seule fois. Lorsque vous essayez de le réaffecter avec une valeur pour la deuxième fois, vous obtenez une erreur de compilation. Considérant que la propriété var est modifiable et que vous êtes libre de la réaffecter à tout moment et à tout moment. 

Answer 12

Dans Kotlinvalest une propriété en lecture seule et est accessible uniquement par un getter.valest immuable.

val exemple:

val piNumber: Double = 3.1415926
    get() = field

Cependant,varest une propriété read-and-write , de sorte que vous pouvez y accéder non seulement par un getter mais également par un setter.varest mutable.

var exemple:

var gravity: Double = 9.8
    get() = field
    set(value) { 
        field = value 
    }    

Si vous essayez de changer une val immuable, IDE vous montrera une erreur:

fun main() {    
    piNumber = 3.14          // ERROR
    println(piNumber)
}

// RESULT:   Val cannot be reassigned 

Mais une variable var peut être modifiée:

fun main() {    
    gravity = 0.0
    println(gravity)
}

// RESULT:   0.0

J'espère que cela t'aides.

Answer 13

Avez-vous besoin de changer une variable ou de la définir de manière permanente? 

• Un bon exemple si c'est quelque chose comme val pi5places = 3.14159 vous le définiriez comme val. Existe-t-il une possibilité que vous deviez changer cette variable maintenant ou plus tard, alors vous la définiriez comme var. 

• Par exemple: La couleur d'une voiture, peut être var colorCar = green. Plus tard, vous pourrez modifier ce colorCar = blue, où vous ne pourrez pas utiliser une val.

• Les réponses ici concernant mutable et immutable sont acceptables, mais peuvent être effrayantes si ces termes ne sont pas bien connus ou ne font que commencer à apprendre à programmer. 

Answer 14

Si nous déclarons une variable en utilisant val, il s'agira de en lecture seule variable. Nous ne pouvons pas changer sa valeur. C'est comme final variable de Java . C'est immutable.

Mais si nous déclarons une variable en utilisant var, ce sera une variable que nous pouvons lire ou écrire . Nous pouvons changer sa valeur. C'est mutable.

data class Name(val firstName: String, var lastName: String)

fun printName(name: Name): Name {
    val myName = Name("Avijit", "Karmakar") // myName variable is read only
    // firstName variable is read-only. 
    //You will get a compile time error. Val cannot be reassigned.
    myName.firstName = myName.firstName
    // lastName variable can be read and write as it's a var.
    myName.lastName = myName.lastName
    return myName
}

val ne peut pas être initialisé récemment avec le mot clé lateinit mais les non-primitives var peuvent être initialisées récemment avec le mot clé lateinit.

Answer 15

La valeur de la variable val ne peut être affectée qu'une seule fois.

val address = Address("Bangalore","India")
address = Address("Delhi","India") // Error, Reassigning is not possible with val

Bien que vous ne puissiez pas réaffecter la valeur, vous pouvez certainement modifier les propriétés de l'objet.

//Given that city and country are not val
address.setCity("Delhi") 
address.setCountry("India")

Cela signifie que vous ne pouvez pas changer la référence d'objet sur laquelle la variable pointe, mais les propriétés sous-jacentes de cette variable peuvent être modifiées.

La valeur de la variable var peut être réaffectée autant de fois que vous le souhaitez.

var address = Address("Bangalore","India")
address = Address("Delhi","India") // No Error , Reassigning possible.

Évidemment, ses propriétés sous-jacentes peuvent être modifiées tant qu'elles ne sont pas déclarées val.

//Given that city and country are not val
address.setCity("Delhi")
address.setCountry("India")

Answer 16

En bref, la variable val est finale (non modifiable) ou une valeur constante qui ne sera pas modifiée à l'avenir. La variable et var (modifiable) peut être modifiée à l'avenir. 

class DeliveryOrderEvent(val d : Delivery)
// Only getter

Voir le code ci-dessus. C'est une classe de modèle, sera utilisé pour la transmission de données. J'ai mis val avant la variable parce que cette variable a été utilisée pour obtenir les données.

class DeliveryOrderEvent(var d : Delivery)

// setter and getter is fine here. No error

De plus, si vous devez définir des données ultérieurement, vous devez utiliser le mot clé var avant une variable. S'il vous suffit d'obtenir la valeur une seule fois, utilisez le mot clé val.

Answer 17

Var - Variable - L'objet stocké dans la variable peut changer (varier) dans le temps.

Val - Valeur - L'objet stocké dans val ne peut pas varier dans le temps. Une fois affecté, le val devient en lecture seule, comme une constante du langage de programmation Java.

Par exemple:

  fun main(args:Array<String>){
        var numberOfHoursPassed=3
        print("Number of hours passed: $numberOfHoursPassed")

        //After 10 hours
        numberOfHoursPassed=13 //value of var can be changed
        print("Number of hours passed: $numberOfHoursPassed")
    }

Sortie:

Number of hours passed: 3
Number of hours passed: 13

Tandis que si nous réaffectons une valeur à val, une erreur de compilation se produit,

Erreur: - Val ne peut pas être réaffecté.

Donc, pour conclure, var peut être changé à n'importe quel niveau. Considérant que val une fois attribué, ne pouvait pas être changé, mais ses propriétés pouvaient être changées.

Référence: https://www.tutorialkart.com/kotlin/val-vs-var-in-kotlin/

Answer 18

Deux façons de créer des variables dans KOTLIN VAL et VAR

1. VAL stocke des valeurs constantes. Aussi appelée Variable finale

2. VAR stocke les valeurs modifiables

Cliquez ici par exemple

Answer 19

val est immuable, final, la première valeur attribuée ne peut pas être modifiée.

val name:String = "andy"

name = "thomas" //Error: Val cannot be reassigned

var est modifiable, réaffectable, vous pouvez modifier la valeur à plusieurs reprises.

val a:Int = 1
var b:Int = 1
println("${a + b}") // output 2

b = 4
println("${a + b}") // output 5

Je pense que la meilleure façon de s'en souvenir:

val = variable final

var = variable réaffectable, ou l'opposé de val.

Answer 20

Ordinaire

• Val utilise pour le champ static comme en Java en tant que Static Keyword

• Comme Static en Java/Identique à kotlin

• Et Var indique que le champ variable dans Kotlin signifie que vous pouvez le changer.

• La plupart du temps Static est utilisé lorsque vous souhaitez enregistrer une valeur en mémoire statique en même temps

Exemple:

 if you assign

 val a=1
 a=3  You can not change it 

• Vous ne pouvez pas changer, c'est la valeur finale et statique

  var b=2

  b=4 U peut le changer

Answer 21

val et var peuvent être utilisés pour déclarer des variables (propriétés locales et de classe).

Variables locales:

1. val déclare en lecture seule variables qui ne peuvent être affectées qu'une seule fois, mais ne peut pas être réaffecté.

Exemple:

val readonlyString = “hello”
readonlyString = “c u” // Not allowed for `val`

2. var déclare réaffectable variables telles que vous les connaissez en Java (le mot clé sera introduit dans Java 10, “inférence de type de variable locale” ).

Exemple:

var reasignableString = “hello”
reasignableString = “c u” // OK

_ {Il est toujours préférable d'utiliser val. Essayez d'éviter var aussi souvent que possible!

Propriétés de la classe:

Les deux mots-clés sont également utilisés afin de définir les propriétés dans les classes . À titre d'exemple, jetez un coup d'œil au data class suivant:

data class Person (val name: String, var age: Int)

Person contient deux champs, dont l'un est en lecture seule (name). La age, en revanche, peut être réaffectée après l'instanciation de classe, via la setter fournie. Notez que name n'aura pas de méthode de définition correspondante.

Answer 22

val comme la variable constant, elle-même ne peut pas être modifiée, elle peut uniquement être lue, mais les propriétés d'une variable val peuvent être modifiées; var tout comme la variable mutante dans d'autres langages de programmation.

Answer 23

Les deux variables sont utilisées comme initialisation 

• val comme une variable constante, il peut être lisible et les propriétés d'un val peuvent être modifiées.

• var comme une variable mutable. vous pouvez modifier la valeur à tout moment.

Answer 24

val: doit ajouter ou valeur initialisée mais ne peut pas changer. var: sa variable peut être modifiée dans n'importe quelle ligne du code.

Answer 25

val et var sont utilisés lorsque nous voulons déclarer une variable . mais la différence entre val et var est

1.Quand vous déclarez une variable val que son immuable, ce qui signifie que vous ne pouvez pas changer sa valeur (sa final maintenant comme en Java)

Exemple:-

val value=100

value=200 //compile time error

2. lorsque vous déclarez une variable en tant que val, vous devez initialiser la variable au moment de la déclaration 

Exemple

val value=100 //you have to initialize it here only 

Mais en cas de var

1. vous pouvez initialiser la variable après la déclaration, mais vous devez définir le type de données au moment de la déclaration. 

exemple:-

var value:Int //you can initialize it anytime

value=100    //initialized here

2. vous pouvez changer sa valeur à tout moment si nécessaire 

Exemple:-

var value=100

value= 200 //changed its value and code will compile happily 

Answer 26

Les deux sont variables, la seule différence est que variable mutable et variable immuable et il n'y a plus de différence. var est une variable mutable et val est immuable.En langage simple var peut changer sa valeur après l'initialisation, valeur est constante et il ne peut pas la modifier après l'initialisation de la valeur.

Answer 27

En Kotlin, nous utilisons var pour déclarer une variable . C'est mutable . Nous pouvons changer, réaffecter variables. Exemple,

fun main(args : Array<String>){
    var x = 10
    println(x)

    x = 100 // vars can reassign.
    println(x)
}

Nous utilisons val pour déclarer constantes . Ils sont immuables . Impossible à modifier, réaffecter vals. val est quelque chose de similaire aux variables final en Java. Exemple,

fun main(args : Array<String>){
    val y = 10
    println(y)

    y = 100 // vals can't reassign (COMPILE ERROR!).
    println(y)
}

Answer 28

Essayons de cette façon.

Val is a Immutable constant 
    val change="Unchange" println(change)
    //It will throw error because val is constant variable
    // change="Change" 
    // println(change)
Var is a Mutable constant
    var name: String="Dummy"
    println(name)
    name="Funny"
    println(name)

Answer 29

VAR est utilisé pour créer les variables dont la valeur changera au fil du temps dans votre application. C'est la même chose que VAR de Swift, alors que VAL est utilisé pour créer les variables dont la valeur ne changera pas dans le temps dans votre application.

Answer 30

var est une variable mutable et peut être affecté plusieurs fois et val est une variable immuable et ne peut être initialisée qu'une seule fois.

Answer 31

Je reçois la réponse exacte de décompiler Kotlin en Java .

Si vous faites cela à Kotlin:

data class UsingVarAndNoInit(var name: String)
data class UsingValAndNoInit(val name: String)

Vous obtiendrez UsingVarAndNoInit:

package classesiiiandiiiobjects.dataiiiclasses.p04variiiandiiival;

import kotlin.jvm.internal.Intrinsics;
import org.jetbrains.annotations.NotNull;

public final class UsingVarAndNoInit {
  @NotNull private String name;

  @NotNull
  public final String getName() {
    return this.name;
  }

  public final void setName(@NotNull String string) {
    Intrinsics.checkParameterIsNotNull((Object) string, (String) "<set-?>");
    this.name = string;
  }

  public UsingVarAndNoInit(@NotNull String name) {
    Intrinsics.checkParameterIsNotNull((Object) name, (String) "name");
    this.name = name;
  }

  @NotNull
  public final String component1() {
    return this.name;
  }

  @NotNull
  public final UsingVarAndNoInit copy(@NotNull String name) {
    Intrinsics.checkParameterIsNotNull((Object) name, (String) "name");
    return new UsingVarAndNoInit(name);
  }

  @NotNull
  public static /* bridge */ /* synthetic */ UsingVarAndNoInit copy$default(
      UsingVarAndNoInit usingVarAndNoInit, String string, int n, Object object) {
    if ((n & 1) != 0) {
      string = usingVarAndNoInit.name;
    }
    return usingVarAndNoInit.copy(string);
  }

  public String toString() {
    return "UsingVarAndNoInit(name=" + this.name + ")";
  }

  public int hashCode() {
    String string = this.name;
    return string != null ? string.hashCode() : 0;
  }

  public boolean equals(Object object) {
    block3:
    {
      block2:
      {
        if (this == object) break block2;
        if (!(object instanceof UsingVarAndNoInit)) break block3;
        UsingVarAndNoInit usingVarAndNoInit = (UsingVarAndNoInit) object;
        if (!Intrinsics.areEqual((Object) this.name, (Object) usingVarAndNoInit.name)) break block3;
      }
      return true;
    }
    return false;
  }
}

Vous obtiendrez également UsingValAndNoInit:

package classesiiiandiiiobjects.dataiiiclasses.p04variiiandiiival;

import kotlin.jvm.internal.Intrinsics;
import org.jetbrains.annotations.NotNull;

public final class UsingValAndNoInit {
  @NotNull private final String name;

  @NotNull
  public final String getName() {
    return this.name;
  }

  public UsingValAndNoInit(@NotNull String name) {
    Intrinsics.checkParameterIsNotNull((Object) name, (String) "name");
    this.name = name;
  }

  @NotNull
  public final String component1() {
    return this.name;
  }

  @NotNull
  public final UsingValAndNoInit copy(@NotNull String name) {
    Intrinsics.checkParameterIsNotNull((Object) name, (String) "name");
    return new UsingValAndNoInit(name);
  }

  @NotNull
  public static /* bridge */ /* synthetic */ UsingValAndNoInit copy$default(
      UsingValAndNoInit usingValAndNoInit, String string, int n, Object object) {
    if ((n & 1) != 0) {
      string = usingValAndNoInit.name;
    }
    return usingValAndNoInit.copy(string);
  }

  public String toString() {
    return "UsingValAndNoInit(name=" + this.name + ")";
  }

  public int hashCode() {
    String string = this.name;
    return string != null ? string.hashCode() : 0;
  }

  public boolean equals(Object object) {
    block3:
    {
      block2:
      {
        if (this == object) break block2;
        if (!(object instanceof UsingValAndNoInit)) break block3;
        UsingValAndNoInit usingValAndNoInit = (UsingValAndNoInit) object;
        if (!Intrinsics.areEqual((Object) this.name, (Object) usingValAndNoInit.name)) break block3;
      }
      return true;
    }
    return false;
  }
}

Il existe d'autres exemples ici: https://github.com/tomasbjerre/yet-another-kotlin-vs-Java-comparison

Answer 32

val (à partir de la valeur): Référence immuable. Une variable déclarée avec val ne peut pas être Réaffectée après son initialisation. Cela correspond à une variable final en Java.

var (de variable): Référence modifiable. La valeur d'une telle variable peut être changée ..__ Cette déclaration correspond à une variable Java régulière (non finale).

Answer 33

Val est immuable et ses propriétés sont définies sur à l'exécution , mais vous pouvez utiliser un const modificateur pour en faire une constante de temps de compilation . Val en kotlin est identique à final en Java.

Var est modifiable et son type est identifié au moment de la compilation .

Answer 34

val - Immuable (une fois initialisé, ne peut être réaffecté)

var - Mutable (peut changer de valeur) 

Exemple 

en Kotlin - val n = 20 & var n = 20 

En Java - final int n = 20; & int n = 20; 

Answer 35

Var signifie Variable - Si vous avez stocké un objet avec 'var' , il pourrait changer dans le temps.

Par exemple: 

fun main(args: Array<String>) {
    var a=12
    var b=13
    var c=12
    a=c+b **//new object 25**
    print(a)
}

Val signifie valeur - C'est comme un 'constant' en Java. Si vous stockiez un objet avec 'val', il ne pourrait pas changer dans le temps.

Par exemple: 

fun main(args: Array<String>) {
    val a=12
    var b=13
    var c=12
    a=c+b **//You can't assign like that.it's an error.**
    print(a)
}