อะไรคือความแตกต่างระหว่าง `let` และ` var` อย่างรวดเร็ว?

อะไรคือความแตกต่างระหว่างletและvarในภาษา Swift ของ Apple?

ในความเข้าใจของฉันมันเป็นภาษาที่รวบรวม แต่ไม่ได้ตรวจสอบประเภทที่รวบรวมเวลา มันทำให้ฉันสับสน คอมไพเลอร์ทราบได้อย่างไรเกี่ยวกับข้อผิดพลาดประเภท? หากคอมไพเลอร์ไม่ตรวจสอบประเภทแสดงว่าเป็นปัญหากับสภาพแวดล้อมการผลิตหรือไม่

letคำหลักที่กำหนดคงที่:

let theAnswer = 42

theAnswerไม่สามารถเปลี่ยนแปลงได้ในภายหลัง นี่คือเหตุผลอะไรที่ไม่สามารถเขียนโดยใช้weak letจำเป็นต้องเปลี่ยนระหว่างรันไทม์และคุณต้องใช้varแทน

การvarกำหนดตัวแปรสามัญ

สิ่งที่น่าสนใจ:

ค่าของค่าคงที่ไม่จำเป็นต้องรู้ ณ เวลารวบรวมแต่คุณต้องกำหนดค่าให้แน่นอนหนึ่งครั้ง

อีกคุณสมบัติที่แปลก:

คุณสามารถใช้อักขระใดก็ได้ที่คุณต้องการสำหรับชื่อค่าคงที่และตัวแปรรวมถึงอักขระ Unicode:

let 🐶🐮 = "dogcow"

ข้อความที่ตัดตอนมาจาก: Apple Inc. “ ภาษาการเขียนโปรแกรม Swift” iBooks https://itunes.apple.com/WebObjects/MZStore.woa/wa/viewBook?id=881256329

แก้ไข

เพราะการแสดงความคิดเห็นขอเพิ่มข้อเท็จจริงอื่น ๆ เพื่อคำตอบที่แปลงนี้เพื่อคำตอบที่วิกิพีเดียชุมชน รู้สึกอิสระที่จะแก้ไขคำตอบเพื่อให้ดีขึ้น

อ้างอิงจากหนังสือภาษาโปรแกรม The Swift

เช่นเดียวกับ C Swift ใช้ตัวแปรในการจัดเก็บและอ้างอิงค่าด้วยชื่อที่ระบุ Swift ยังใช้ประโยชน์อย่างกว้างขวางของตัวแปรที่ค่าไม่สามารถเปลี่ยนแปลงได้ สิ่งเหล่านี้เรียกว่าค่าคงที่และมีประสิทธิภาพมากกว่าค่าคงที่ใน C

ทั้งสองvarและletมีการอ้างอิงจึงletเป็นอ้างอิง const การใช้ประเภทพื้นฐานไม่ได้แสดงให้เห็นว่าletแตกต่างconstอย่างไร ความแตกต่างเกิดขึ้นเมื่อใช้กับคลาสอินสแตนซ์ (ชนิดอ้างอิง):

class CTest
{
    var str : String = ""
}

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ใช้ในการกำหนดค่าคงที่และvarเพื่อกำหนดตัวแปร

มันอาจจะดีกว่าที่จะระบุความแตกต่างนี้โดยแนวคิดความไม่แน่นอน / ความไม่เปลี่ยนแปลงที่เป็นกระบวนทัศน์ที่ถูกต้องของค่านิยมและการเปลี่ยนแปลงอินสแตนซ์ในพื้นที่วัตถุซึ่งมีขนาดใหญ่กว่าความคิดปกติ "คงที่ / ตัวแปร" เท่านั้น และยิ่งไปกว่านั้นใกล้กับ Objective C

2 ชนิดข้อมูล: ประเภทค่าและประเภทอ้างอิง

ในบริบทของประเภทมูลค่า:

'let' กำหนดค่าคงที่ (untamable) 'var' กำหนดค่าที่เปลี่ยนแปลงได้ (ไม่แน่นอน)

let aInt = 1   //< aInt is not changeable

var aInt = 1   //< aInt can be changed

ในบริบทของประเภทการอ้างอิง:

เลเบลของข้อมูลไม่ใช่ค่า แต่เป็นการอ้างอิงถึงค่า

ถ้า aPerson = Person (ชื่อ: Foo, ก่อน: Bar)

aPerson ไม่มีข้อมูลของบุคคลนี้ แต่เป็นการอ้างอิงถึงข้อมูลของบุคคลนี้

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)

The

การประกาศค่าคงที่และตัวแปรในเอกสารภาษา Swift Programming ระบุสิ่งต่อไปนี้:

คุณประกาศค่าคงที่พร้อมกับคีย์เวิร์ด let และตัวแปรที่มีคีย์เวิร์ด var

ตรวจสอบให้แน่ใจว่าเข้าใจวิธีการทำงานของประเภทการอ้างอิง ซึ่งแตกต่างจากประเภทมูลค่าคุณสมบัติพื้นฐานของวัตถุสามารถเปลี่ยนแปลงได้แม้จะมีอินสแตนซ์ของประเภทอ้างอิงที่มีการประกาศเป็นค่าคงที่ ดูส่วนClasses Reference Referenceของเอกสารและดูตัวอย่างการเปลี่ยนคุณสมบัติ frameRate

ง่ายมาก:

• let มีค่าคงที่
• var เป็นแบบไดนามิก

บิตของคำอธิบาย:

letสร้างค่าคงที่ (เรียงลำดับของเหมือนNSString) คุณไม่สามารถเปลี่ยนค่าได้เมื่อคุณตั้งค่าแล้ว คุณยังสามารถเพิ่มไปยังสิ่งอื่น ๆ และสร้างตัวแปรใหม่ได้

varสร้างตัวแปร (เรียงลำดับเหมือนNSMutableString) เพื่อให้คุณสามารถเปลี่ยนค่าของมัน แต่นี่เป็นคำตอบหลายครั้ง

letกำหนด "คงที่" ค่าจะถูกตั้งค่าเพียงครั้งเดียว แต่ไม่จำเป็นว่าจะต้องประกาศเมื่อใด ตัวอย่างเช่นคุณใช้letเพื่อกำหนดคุณสมบัติในคลาสที่ต้องตั้งค่าในระหว่างการเริ่มต้น:

class Person {

    let firstName: String
    let lastName: String

    init(first: String, last: String) {
         firstName = first
         lastName = last
         super.init()
    }
}

ด้วยการตั้งค่านี้มันไม่ถูกต้องในการกำหนดให้firstNameหรือlastNameหลังการโทร (เช่น) Person(first:"Malcolm", last:"Reynolds")เพื่อสร้างPersonอินสแตนซ์

คุณต้องกำหนดประเภทสำหรับตัวแปรทั้งหมด ( letหรือvar) ในเวลารวบรวมและรหัสใด ๆ ที่พยายามตั้งค่าตัวแปรอาจใช้เฉพาะประเภทนั้น (หรือชนิดย่อย) คุณสามารถกำหนดค่าณ รันไทม์ แต่ต้องรู้จักชนิดของมันในเวลารวบรวม

let- constant
var-variable

[ค่าคงที่เทียบกับตัวแปร]
[โครงสร้างกับคลาส]

doc doc อย่างเป็นทางการdocs.swift.orgพูดว่า

ค่าของ a constantไม่สามารถเปลี่ยนแปลงได้เมื่อตั้งค่าในขณะที่ a variableสามารถตั้งค่าเป็นค่าอื่นในอนาคต

คำศัพท์นี้อธิบายกลไกการมอบหมายใหม่

ความไม่แน่นอน - เปลี่ยนแปลงได้ - สถานะของวัตถุสามารถเปลี่ยนแปลงได้หลังจากการสร้าง

ประเภทค่าและการอ้างอิง^{[เกี่ยวกับ]}

ค่า (โครงสร้าง Enum)

Swift's structสามารถเปลี่ยนสถานะความผันแปรได้:

let+ struct= immutable= ค่าคงที่
มันไม่สามารถกำหนดใหม่หรือเปลี่ยนแปลงได้

var+ struct= mutable
สามารถกำหนดใหม่หรือเปลี่ยนแปลงได้

ประเภทอ้างอิง (ชั้น)

Swift's classesเป็นmutablea-priory

let+ class= คงที่ของอยู่
มันสามารถไม่ได้รับพระราชเสาวนีย์และสามารถเปลี่ยนแปลงได้

var+ class
สามารถกำหนดใหม่หรือเปลี่ยนแปลงได้

//STRUCT
  //let + struct
let letStructA = StructA()

    //change FAIL
letStructA.a = 5 //Compile ERROR: Cannot assign to property: 'structALet' is a 'let' constant

    //reassign FAIL
letStructA = StructA() // Compile ERROR: Cannot assign to value: 'structALet' is a 'let' constant

  //var + struct
var varStructA = StructA()

    //change OK
varStructA.a = 5

    //reassign OK
varStructA = StructA()

//CLASS
  //let + class
let letClassA = ClassA()

    //change OK
letClassA.a = 5

    //reassign FAIL
letClassA = ClassA() // Compile ERROR: Cannot assign to value: 'classALet' is a 'let' constant

  //var + class
var varClassA = ClassA()

    //change OK
varClassA.a = 5

    //reassign OK
varClassA = ClassA()

mutating - ฟังก์ชั่นการกลายพันธุ์ของโครงสร้าง

คุณสามารถทำเครื่องหมายเมธอดstruct ได้mutating

1. บ่งชี้ว่าฟังก์ชันนี้เปลี่ยนค่าคุณสมบัติภายใน
2. สามารถใช้ได้กับvar+ เท่านั้นstruct

public struct StructA {
    public var a = 0

    public init() {}

    //func foo() { //Compile ERROR: Cannot assign to property: 'self' is immutable
    mutating func foo() {
        a = 5
    }
}

inout การปรับเปลี่ยน struct ภายในฟังก์ชั่น

คุณสามารถทำเครื่องหมายพารามิเตอร์ของฟังก์ชัน (ซึ่งคือ struct) เป็น inout

เนื่องจากstructชนิดของค่าจะถูกส่งผ่านโดยค่าเนื่องจากฟังก์ชันผลลัพธ์จะดึงข้อมูลสำเนา หากคุณทำเครื่องหมายstructเป็นinoutพารามิเตอร์ก็หมายความว่าพารามิเตอร์นี้จะกลายเป็นvarและคุณสามารถที่จะเปลี่ยนสถานะของstructและการเปลี่ยนแปลงเหล่านี้จะออกไปข้างนอกมองเห็นขอบเขตของฟังก์ชั่น

//func foo(myStruct: StructA) { //Compile ERROR: line - myStruct.a = 10: Cannot assign to property: 's' is a 'let' constant
func foo(myStruct: inout StructA) {
    myStruct.a = 10
}

//using
//foo(myStruct: &letStructA) // Compile EROOR: Cannot pass immutable value as inout argument: 'letStructA' is a 'let' constant
foo(myStruct: &varStructA)

ใช้letเมื่อใดก็ตามที่คุณสามารถ ใช้varเมื่อคุณต้อง

ความแตกต่างอีกอย่างหนึ่งที่ฉันได้พบในภาษาอื่นสำหรับค่าคงที่คือ: ไม่สามารถกำหนดค่าเริ่มต้น (คงที่) ในภายหลังได้ควรกำหนดค่าเริ่มต้นตามที่คุณกำลังจะประกาศค่าคงที่

ตัวอย่างเช่น

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

ตัวแปร

var variableValue : Int // No issues 

letใช้เพื่อประกาศค่าคงที่ - คุณจะไม่เปลี่ยนหลังจากให้ค่าเริ่มต้น
varใช้เพื่อประกาศค่าตัวแปร - คุณสามารถเปลี่ยนค่าได้ตามที่คุณต้องการ

ปล่อยให้มีการใช้ในการกำหนดค่าคงที่และ varกำหนดตัวแปร คุณกำหนดสตริงโดยใช้ varดังนั้นสตริงเฉพาะสามารถแก้ไขได้ (หรือกลายพันธุ์) โดยกำหนดให้กับตัวแปร (ในกรณีที่สามารถแก้ไขได้) และถ้าคุณกำหนดสตริงโดยใช้ให้ค่าคงที่ (ในกรณีที่มันไม่สามารถ แก้ไข):

var variableString = "Apple"
variableString += " and Banana"
// variableString is now "Apple and Banana"

let constantString = "Apple"
constantString += " and another Banana"
// this reports a compile-time error - a constant string cannot be modified

ให้คำหลักกำหนดค่าคงที่

let myNum = 7

ดังนั้น myNum ไม่สามารถเปลี่ยนแปลงได้ในภายหลัง

แต่ var กำหนดตัวแปรสามัญ

ค่าของค่าคงที่ไม่จำเป็นต้องทราบ ณ เวลารวบรวม แต่คุณต้องกำหนดค่าให้แน่นอนหนึ่งครั้ง

คุณสามารถใช้อักขระใดก็ได้ที่คุณต้องการสำหรับชื่อค่าคงที่และตัวแปรรวมถึงอักขระ Unicode

เช่น

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

แต่ถ้าเราปล่อยให้ ...

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

เช่นเดียวกับ Luc-Oliver, NullData และอีกสองสามคนพูดที่นี่letกำหนดข้อมูลที่ไม่เปลี่ยนรูปแบบในขณะที่varกำหนดข้อมูลที่ไม่แน่นอน สิ่งใดก็ตามfuncที่สามารถเรียกใช้บนตัวแปรที่ถูกทำเครื่องหมายmutatingสามารถเรียกใช้ได้ถ้ามันเป็นvarตัวแปรเท่านั้น (คอมไพเลอร์จะส่งข้อผิดพลาด) นอกจากนี้ยังนำไปใช้กับfuncของที่ใช้ในinoutตัวแปร

อย่างไรก็ตามletและvarยังหมายถึงว่าตัวแปรนั้นไม่สามารถกำหนดใหม่ได้ มันมีสองความหมายทั้งสองมีวัตถุประสงค์ที่คล้ายกันมาก

ค่าvarสามารถเปลี่ยนแปลงได้หลังจากเริ่มต้น แต่ให้ค่าไม่เปลี่ยนแปลงเมื่อมัน intilize ครั้งเดียว

ในกรณีของ var

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

ในกรณีที่ปล่อย

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

คำหลัก var ใช้เพื่อกำหนดตัวแปรที่มีค่าที่คุณสามารถเปลี่ยนได้อย่างง่ายดาย:

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

อย่างไรก็ตามคำหลัก let เป็นเพียงการสร้างค่าคงที่ที่ใช้เมื่อคุณไม่ต้องการเปลี่ยนค่าของค่าคงที่อีกครั้ง หากคุณลองเปลี่ยนค่าของค่าคงที่คุณจะได้รับข้อผิดพลาด:

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

อนุญาตเป็นตัวแปรที่ไม่เปลี่ยนรูปซึ่งหมายความว่ามันไม่สามารถเปลี่ยนแปลงได้ภาษาอื่นเรียกสิ่งนี้ว่าค่าคงที่ ใน C ++ คุณสามารถกำหนดเป็น const

Var เป็นตัวแปรที่ไม่แน่นอนซึ่งหมายความว่าสามารถเปลี่ยนแปลงได้ ใน C ++ (อัปเดตเวอร์ชัน 2011) มันเหมือนกับการใช้ auto แม้ว่า swift จะช่วยให้การใช้งานมีความยืดหยุ่นมากขึ้น นี่เป็นประเภทตัวแปรที่เป็นที่รู้จักมากขึ้นสำหรับผู้เริ่มต้น

ให้เป็นค่าคงที่ดังนั้นจึงไม่สามารถเปลี่ยนแปลงได้

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

Varเป็นตัวแปรและสามารถเปลี่ยนแปลงได้ (แต่หลังจากกำหนดไว้จะไม่เป็นชนิดข้อมูลอื่น)

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

หากคุณลองเปลี่ยนตัวแปรเป็น dataType อื่นมันจะไม่ทำงาน

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

ความแตกต่างหลักคือvarค่าตัวแปรสามารถเปลี่ยนแปลงได้และletไม่สามารถทำได้ หากคุณต้องการให้มีการป้อนข้อมูลผู้ใช้คุณจะใช้varเพื่อให้สามารถเปลี่ยนแปลงค่าและใช้letตัวแปรประเภทข้อมูลเพื่อให้ค่าไม่สามารถเปลี่ยนแปลงได้

var str      = "dog"  // str value is "dog"
str          = "cat"  // str value is now "cat"

let strAnimal = "dog" // strAnimal value is "dog"
strAnimal     = "cat" // Error !

ค่าสามารถกำหนดใหม่ได้ในกรณีที่ var

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

** ค่าคงที่ newAge ไม่สามารถกำหนดใหม่เป็นค่าใหม่ได้ การพยายามทำเช่นนั้นจะทำให้เกิดข้อผิดพลาดในการรวบรวมเวลา **

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

“ ใช้การอนุญาตเพื่อทำให้ค่าคงที่และ var เพื่อสร้างตัวแปร”

Excerpt From: Apple Inc. “The Swift Programming Language.” iBooks. https://itun.es/us/jEUH0.l

varคือตัวแปรที่สามารถเปลี่ยนแปลงได้บ่อยเท่าที่คุณต้องการและเมื่อใดก็ตาม

ตัวอย่างเช่น

var changeit:Int=1
changeit=2
 //changeit has changed to 2 

ให้เป็นค่าคงที่ซึ่งไม่สามารถเปลี่ยนแปลงได้

ตัวอย่างเช่น

let changeit:Int=1
changeit=2
 //Error becuase constant cannot be changed

แม้ว่าคุณจะมีความแตกต่างมากมายระหว่าง let และ var แต่ความแตกต่างที่สำคัญอย่างหนึ่งคือ:

let is compiled fast in comparison to var.

ทุกคนมีคำตอบที่ค่อนข้างสวย แต่นี่คือวิธีที่คุณสามารถจดจำสิ่งที่เป็น

อนุญาตมักจะคิดเหมือนกันว่า "ปล่อย" ตามที่ปล่อยให้งานนี้หนึ่งครั้งและเสมอสำหรับตัวแปร "var" สามารถเปลี่ยนแปลงได้ตลอดเวลาดังนั้นพวกเขาจึงถูกเรียกว่าตัวแปร

varเป็นวิธีเดียวในการสร้างตัวแปรอย่างรวดเร็ว varไม่ได้หมายถึงตัวแปรแบบไดนามิกเช่นเดียวกับในกรณีของภาษาที่ตีความเช่น javascript ตัวอย่างเช่น,

var name = "Bob"

ในกรณีนี้ประเภทของตัวแปรnameถูกอนุมานว่าชื่อเป็นประเภทStringเรายังสามารถสร้างตัวแปรโดยการกำหนดประเภทอย่างชัดเจนตัวอย่างเช่น

var age:Int = 20

ตอนนี้ถ้าคุณกำหนดสตริงให้แก่อายุคอมไพเลอร์ให้ข้อผิดพลาด

letใช้ในการประกาศค่าคงที่ ตัวอย่างเช่น

let city = "Kathmandu"

หรือเราสามารถทำได้

let city:String = "Kathmandu"

หากคุณพยายามเปลี่ยนมูลค่าของเมืองมันจะทำให้เกิดข้อผิดพลาดในเวลารวบรวม

ให้ใช้สำหรับค่าคงที่ที่ไม่สามารถแก้ไขได้ในขณะที่ var เป็นตัวแปรธรรมดา

ตัวอย่าง:

ให้ชื่อ = "บ๊อบ" บางอย่างเช่นชื่อ = "จิม" จะโยนข้อผิดพลาดเนื่องจากค่าคงที่ไม่สามารถแก้ไข

ความแตกต่างอย่างง่าย

ให้ = (ไม่สามารถเปลี่ยนแปลงได้)

var = (อัปเดตตลอดเวลา)

ที่มา: https://thenucleargeeks.com/2019/04/10/swift-let-vs-var/

เมื่อคุณประกาศตัวแปรที่มี var หมายความว่าสามารถอัปเดตตัวแปรเป็นค่าสามารถแก้ไขได้

เมื่อคุณประกาศตัวแปรด้วยอนุญาตหมายความว่าไม่สามารถอัปเดตได้มันเป็นตัวแปรที่ไม่สามารถแก้ไขค่าได้

var a = 1 
print (a) // output 1
a = 2
print (a) // output 2

let b = 4
print (b) // output 4
b = 5 // error "Cannot assign to value: 'b' is a 'let' constant"

ให้เราเข้าใจตัวอย่างข้างต้น: เราได้สร้างตัวแปรใหม่“ a” กับ“ คำหลัก var” และกำหนดค่า“ 1” เมื่อฉันพิมพ์“ a” ฉันได้รับผลลัพธ์เป็น 1 จากนั้นฉันกำหนด 2 ถึง“ var a” นั่นคือฉันกำลังแก้ไขค่าของตัวแปร“ a” ฉันสามารถทำได้โดยไม่ได้รับข้อผิดพลาดของคอมไพเลอร์เพราะฉันประกาศว่ามันเป็น var

ในสถานการณ์ที่สองฉันสร้างตัวแปรใหม่“ b” ด้วย“ let keyword” และกำหนดค่า“ 4” เมื่อฉันพิมพ์“ b” ฉันได้ 4 เป็นผลลัพธ์ จากนั้นฉันพยายามกำหนด 5 ให้เป็น“ let b” นั่นคือฉันกำลังพยายามปรับเปลี่ยนตัวแปร“ let” และฉันได้รับข้อผิดพลาดในการคอมไพล์เวลา“ ไม่สามารถกำหนดให้กับค่า: 'b' เป็นค่าคงที่ 'ให้'

แม้ว่าตอนนี้ฉันยังอ่านคู่มืออยู่ แต่ฉันคิดว่ามันใกล้กับconstตัวชี้C / C ++ มาก ในคำอื่น ๆ สิ่งที่ต้องการความแตกต่างระหว่างและchar const* char*คอมไพเลอร์ปฏิเสธที่จะอัปเดตเนื้อหาไม่เพียงอ้างอิงการกำหนดใหม่ (ตัวชี้)

ตัวอย่างเช่นสมมติว่าคุณมีโครงสร้างนี้ ระวังว่านี่คือ struct ไม่ใช่คลาส AFAIK คลาสไม่ได้มีแนวคิดของรัฐที่ไม่เปลี่ยนแปลง

import Foundation


struct
AAA
{
    var inner_value1    =   111

    mutating func
    mutatingMethod1()
    {
        inner_value1    =   222
    }
}


let aaa1    =   AAA()
aaa1.mutatingMethod1()      // compile error
aaa1.inner_value1 = 444     // compile error

var aaa2    =   AAA()
aaa2.mutatingMethod1()      // OK
aaa2.inner_value1 = 444     // OK

เพราะ structs จะไม่เปลี่ยนรูปโดยเริ่มต้นที่คุณต้องทำเครื่องหมายวิธี Mutator mutatingกับ และเนื่องจากชื่อaaa1นั้นเป็นค่าคงที่คุณจึงไม่สามารถเรียกใช้วิธีการตัวแปลงใด ๆ ได้ นี่คือสิ่งที่เราคาดหวังในพอยน์เตอร์ C / C ++

ฉันเชื่อว่านี่เป็นกลไกในการสนับสนุนสิ่งที่ถูกต้องแบบกลุ่ม

ประกาศค่าคงที่ด้วยคำหลัก let และตัวแปรด้วยคำสำคัญ var

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

ประกาศหลายค่าคงที่หรือหลายตัวแปรในบรรทัดเดียวคั่นด้วยเครื่องหมายจุลภาค:

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

ค่าคงที่การพิมพ์และตัวแปร

คุณสามารถพิมพ์ค่าปัจจุบันของค่าคงที่หรือตัวแปรด้วยฟังก์ชัน println:

println(friendlyWelcome)

Swift ใช้การแก้ไขสตริงเพื่อรวมชื่อของค่าคงที่หรือตัวแปรเป็นตัวยึดตำแหน่งในสตริงที่ยาวกว่า

ล้อมรอบชื่อในวงเล็บและหลบหนีด้วยแบ็กสแลชก่อนเปิดวงเล็บ:

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

การอ้างอิง: http://iosswift.com.au/?p=17

พบคำตอบที่ดีหวังว่ามันจะช่วยได้ :)