What’s the difference between var and let? Which one would you choose for properties in a struct and Class why?


Let is an immutable variable, meaning that it cannot be changed, other languages call this a constant.

Var is a mutable variable, meaning that it can be changed. 

“Use let to make a constant and var to make a variable”


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.
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)
Value and Reference Type

Reference Type(Class)
Swift's classes are mutable a-priory
var + class
It can be reassigned or changed
let + class = constant of address
It can not be reassigned and can be changed

Value(Struct, Enum)
Swift's struct can change their mutability status:
var + struct = mutable
It can be reassigned or changed
let + struct = *immutable = constant of value
It can not be reassigned or changed
*immutable - check testStructMutability test
Value type is a type whose value is copied when it’s assigned to a variable or constant, when it’s passed to a function or when it's returned from function. (Also as and is checks make a copy of struct)
Struct, Enum, Tuple
struct String, struct Array(Set, Dictionary)
  • When you assign or pass value type a new copy of data is created. Actually the copy on write - COW mechanism is used with some optimisations, for example the copy is created when object is modified
  • When you modify an instance it has only local effect.
  • The Stack Memory is used.
Reference types are not copied when they are assigned to a variable or constant, or when they are passed to a function
Class, Function
  • When you assign or pass reference type a new reference to original instance will be created(the address of instance is copied).
  • When you modify an instance it has a global effect because the instance is shared and accessible by any reference that points on it.
  • The Heap Memory is used.

Value type is recommended to use by default. The biggest advantage of Value type is that usually they are thread safe

Reference type Pros:
  • they can be inherited,
  • deinit() can be used,
  • compare instances by reference ===,
  • Objective-C interoperability because Value Type was introduced in Swift.


When and where to use them?
  • Structs are much safer and bug-free, especially in a multithreaded environment. Swift value types are kept in the stack. In a process, each thread has its own stack space, so no other thread will be able to access your value type directly. Hence no race conditions, locks, deadlocks or any related thread synchronization complexity.
  • Class does support Inheritance. Class is a reference type and is stored in the heap part of memory which makes a class comparatively slower than a struct in terms of performance. Unlike a class, a struct is created on the stack. So, it is faster to instantiate (and destroy) a struct than a class. Unless struct is a class member in which case it is allocated in heap, along with everything else.
  • Value types do not need dynamic memory allocation or reference counting, both of which are expensive operations. At the same time methods on value types are dispatched statically. These create a huge advantage in favor of value types in terms of performance.

 Mutating Struct's Functions

Comments

Post a Comment

Popular posts from this blog

iOS Questions (Swift Programming Language)

Image
  1. What’s the difference between  var  and  let ?  Both var and let are references, therefore let is a const reference. let is used to declare a constant value - you won't change it after giving it an initial value. Its a immutable variable. let theAnswer = 42 The theAnswer cannot be changed afterwards. This is why anything weak can't be written using let. They need to change during runtime and you must be using var instead. The var defines an ordinary variable. What is interesting: The value of a constant doesn’t need to be known at compile time, but you must assign the value exactly once. Another strange feature: You can use almost any character you like for constant and variable names, including Unicode characters: let 🐶🐮 = "dogcow" let defines a "constant". Its value is set once and only once, though not necessarily when you declare it. For example, you use let to define a property in a class that must be set during initialization: var is used to dec...
Read more

Dispatch techniques: Dynamic dispatch and Static Dispatch

4 types of dispatch techniques — Inline  (Fastest) Static Dispatch Virtual Dispatch Dynamic Dispatch  (Slowest) Dynamic dispatch Swift  allows a class to override methods and properties declared in its superclasses. ... This technique, called  dynamic dispatch , increases language expressivity at the cost of a constant amount of runtime overhead for each indirect usage. Method Dispatch is the mechanism that helps to decide which operation should be executed, or more specifically, which method implementation should be used. Dynamic Dispatch  is supported only by  reference types ( i.e.  Class). The reason for this is that, for  dynamism , or  dynamic dispatch,  in short, we need  inheritance  and our  value types  do not support inheritance. To achieve  Dynamic Dispatch , we use inheritance, subclass a base class and then override an existing method of the base class. Also, we can make use of  dynamic  k...
Read more