Understanding Variable Scope in Swift

Consider the following Swift code snippet: ```swift func exampleFunction() { let localVariable = 10 print(localVariable) } ``` What is the scope of `localVariable` in the above code?

• The entire program.

• The function `exampleFunction`.

• The file in which it is declared.

• The class in which it is declared.

Consider the following Swift code snippet: ```swift var globalVariable = 5 func anotherFunction() { print(globalVariable) } ``` What is the scope of `globalVariable` in the above code?

• The function `anotherFunction`.

• The block in which it is declared.

• The entire program.

• The class in which it is declared.

What happens if a local variable in Swift has the same name as a global variable? ```swift var number = 20 func calculate() { let number = 10 print(number) } ```

• The global variable is overridden by the local variable within the local scope.

• The program will not compile.

• The local variable is ignored.

• The global variable is deleted.

Which of the following is true about the lifecycle of a local variable in Swift? ```swift func temporaryFunction() { let tempVar = 100 // some code } ```

• It persists for the lifetime of the program.

• It is destroyed once the function or block in which it is declared is exited.

• It is automatically initialized to zero.

• It can be accessed from any part of the program.

Which of the following is true about global variables in Swift? ```swift var globalCount = 0 func increment() { globalCount += 1 } ```

• They are only accessible within the function they are declared in.

• They are initialized to zero by default.

• They persist for the lifetime of the program.

• They cannot be changed once declared.

In Swift, where can you declare a global variable? ```swift var globalValue = 50 ```

• Inside a function.

• Inside a class method.

• Outside of any function or class.

• Inside a loop.

Which of the following is a benefit of using local variables? ```swift func compute() { let localValue = 25 // some operations } ```

• They can be accessed from anywhere in the program.

• They help in reducing memory usage by being temporary.

• They are automatically synchronized across threads.

• They are easier to debug than global variables.

Which of the following is a potential drawback of using global variables? ```swift var sharedResource = "Resource" ```

• They are more secure than local variables.

• They can lead to code that is difficult to understand and maintain.

• They are automatically synchronized across threads.

• They are faster to access than local variables.

Consider the following Swift code snippet: ```swift func outerFunction() { let outerVariable = 30 func innerFunction() { print(outerVariable) } innerFunction() } ``` What is the scope of `outerVariable` in the above code?

• The entire program.

• The file in which it is declared.

• The function `outerFunction`.

• The class in which it is declared.

What is a local variable in Swift? ```swift func sampleFunction() { let localVar = 15 } ```

• A variable that is accessible throughout the entire program.

• A variable that is declared within a function or block and is accessible only within that function or block.

• A variable that is declared outside of any function or block.

• A variable that is declared in a different programming language.