Practice by Category & Subject

Result builders (formerly function builders) using @resultBuilder enable creating DSLs with declarative syntax. Define types with buildBlock and other builder methods. Used in SwiftUI for view hierarchies. Result builders transform sequences of statements into compound values. Understanding result builders helps use and create DSLs.

Question 2 Easy Mcq

✓ Correct ✗ Incorrect

What is this code an example of? let val = (Double)6

A syntax issue

Typecasting

Assignment

Initialization

Explanation:

Unowned references are like weak but crash if accessed after deallocation rather than becoming nil. Not optional, should only be used when certain the reference will never outlive the object. Use when objects have dependent lifetimes. Cleaner than weak for guaranteed-lifetime scenarios but less safe.

Question 3 Easy Mcq

✓ Correct ✗ Incorrect

What is the result of the following code?func potteryBarn (name: String, score: Int) -> String { return "Hello (name)!Your score is (score)." }potteryBarn ("Tom" , 2)

Hello Tom! Your score is 2.

name: Tom, score: 2

Hello Tom!

potteryBarn = "Hello Tom! Your score is 2."

Explanation:

The guard statement requires an else clause that must exit the current scope using return, throw, break, or continue. This mandatory exit ensures invalid conditions are handled before continuing with the main code path. Guard improves readability by handling preconditions upfront and reducing nested if statements. Unlike if statements, guard unwraps optionals into constants available throughout the remaining scope, not just within a block.

Question 4 Easy Mcq

✓ Correct ✗ Incorrect

What is the base class in this code? class LSN : MMM {}

MMM

LSN

There is no base class.

This code is invalid.

Explanation:

Numeric literals can include underscores for readability without affecting value. For example, 1_000_000 equals 1000000. Use underscores to group digits logically, making large numbers easier to read. This feature improves code readability for financial values, large counts, or any numbers where digit grouping helps comprehension.

Question 5 Easy Mcq

✓ Correct ✗ Incorrect

What is wrong with this code? var x = 5; x = 10.0

You cannot assign a Double to a variable of type Int

X is undefined

X is a constant

X has no type

Explanation:

Availability attributes (@available) specify minimum platform versions required for APIs. Use to mark APIs requiring specific OS versions or deprecate old APIs. Compiler warns when using unavailable APIs. Availability checking with if #available enables runtime version checks. Understanding availability helps maintain backward compatibility while using newer features.

Question 6 Easy Mcq

✓ Correct ✗ Incorrect

What is true about Memory management in Swift?

Swift uses Non-ARC so we need to handle the references manually.

Swift uses ARC but we still need to avoid reference cycles using weak and strong references etc.

Swift uses ARC so we don’t need to care about memory management at all.

Explanation:

The associated type keyword in protocols declares a placeholder type that conforming types must specify. Associated types enable generic protocols where specific types are determined by conforming types. For example, a Collection protocol might have associatedtype Element. Conforming types specify the actual type through implementation. Associated types enable powerful generic programming patterns and are fundamental to Swift's standard library protocols like Sequence and Collection.

Question 7 Easy Mcq

✓ Correct ✗ Incorrect

In the below text, what is the name of the class’s only method?Class Square: NamedShape {var sideLength: Doublefunc area() -> Double {return sideLength*sideLength}}

sideLength

area

Square

NamedShape

Explanation:

The class's only method is named 'area', which likely calculates and returns the square's area based on its side length. Methods define the behaviors and operations that instances of the class can perform. In Swift, methods are functions associated with a particular type. The method name follows 'func' keyword and describes the operation it performs. Understanding method names and signatures is essential for using class APIs effectively.

Question 8 Easy Mcq

✓ Correct ✗ Incorrect

What is the return value of the type check operator - is ?

true, false

0, 1

yes, no

1, -1

Explanation:

The type check operator 'is' returns a Boolean value (true or false) indicating whether an instance is of a specified type. It checks type membership at runtime, returning true if the instance is that type or a subclass thereof. The 'is' operator is commonly used in conditional statements before performing type-specific operations. Understanding type checking enables safe runtime type inspection before downcasting.

Question 9 Easy Mcq

✓ Correct ✗ Incorrect

In the below text, what is the property name?class Square: NamedShape {var sideLength: Double func area() -> Double { return sideLength * sideLength }}

sideLength

Square

NamedShape

area

Explanation:

Initialization is the process of preparing instances for use by setting initial values for stored properties. Initializers are defined with init keyword. All stored properties must have values before initialization completes. Swift provides automatic memberwise initializers for structs. Classes have designated and convenience initializers forming initialization chains. Failable initializers return optionals, allowing initialization to fail gracefully.

Question 10 Easy Mcq

✓ Correct ✗ Incorrect

What is the name of the Objective-C Bridging Header given a product module namedExample?

Example-Bridging-Swift.h

Example-Swift.h

Example-Bridging-ObjectiveC.h

Example-Bridging-Header.h

Explanation:

The Objective-C bridging header follows the naming convention ProductModuleName-Bridging-Header.h in Swift projects. This header file allows Swift code to access Objective-C classes and methods by importing Objective-C headers. It serves as the bridge between Swift and Objective-C code in mixed-language projects, enabling seamless interoperability between both languages.

Question 11 Easy Mcq

✓ Correct ✗ Incorrect

Which is the wrong definition of a protocol in Swift?

protocol SomeProtocol { var first: Int{ get } }

protocol SomeProtocol { var first: Int{ set } }

protocol SomeProtocol { var first: Int { get set } }

protocol SomeProtocol { var first: Int { get set } var second: Int { get } }

Explanation:

This question addresses a key concept in software engineering that's important for understanding system development. The correct response reflects industry best practices and fundamental principles in modern development methodologies. Understanding this concept helps software professionals design more maintainable, efficient, and reliable systems. This knowledge is particularly relevant when working with complex projects requiring careful planning and coordination. The concept builds upon core software engineering foundations and applies across various development contexts and domains.

Question 12 Easy Mcq

✓ Correct ✗ Incorrect

Which one is correct function definition?

funcsayHello(personName: String) -> String {}

funcsayHello(personName-> String) -> String {}

funcsayHello(personName-> String) : String {}

funcsayHello(personName: String) : String

Explanation:

Operator overloading allows defining custom behavior for existing operators with custom types. Implement operator functions as global functions or type methods. For example, func +(lhs: Vector, rhs: Vector) -> Vector enables vector addition. Swift supports overloading arithmetic, comparison, and logical operators. Overloading creates intuitive APIs where standard operators work naturally with custom types, improving expressiveness.

Question 13 Easy Mcq

✓ Correct ✗ Incorrect

What is a trailing closure?

A closure expression that is called directly after another closure expression

A closure expression that is written outside of (and after) the parentheses of the function call it supports.

A closure expression that is declared within the scope of another closure expression.

A closure expression that is declared at the property of an object.

Explanation:

A trailing closure is written after the function call's parentheses when the closure is the function's final argument. If it's the only argument, parentheses can be omitted entirely. This syntax improves readability for functions accepting closures, especially with longer closure bodies. It's a key Swift feature that makes functional programming patterns more accessible and code more expressive and natural to read.

Question 14 Easy Mcq

✓ Correct ✗ Incorrect

What is Swift ?

Swift is Apple's latest programming language for iOS and OS X apps that builds on the best of C and Objective-C, without the constraints of C compatibility. Swift adopts safe programming patterns and adds modern features to make programming easier, and flexible.

Swift is Google latest programming language for iOS and OS X apps that builds on the best of C and Objective-C, without the constraints of C compatibility. Swift adopts safe programming patterns and adds modern features to make programming easier, and flexible.

Swift is Google latest programming language for Android and OS X apps that builds on the best of C and Objective-C, without the constraints of C compatibility. Swift adopts safe programming patterns and adds modern features to make programming easier, and flexible.

All of them

Explanation:

Swift is a modern, type-safe, compiled programming language developed by Apple for iOS, macOS, watchOS, and tvOS development. It combines the best of C and Objective-C without C compatibility constraints, offering clean syntax, memory safety through ARC, and powerful features like optionals, generics, and protocol-oriented programming. Swift is open-source, fast, and designed for safety and performance while maintaining expressiveness.

Question 15 Easy Mcq

✓ Correct ✗ Incorrect

What is the value of y? let x = ["1", "2"].dropFirst() let y = x[0]

This code contains an error

Nil

Explanation:

String interpolation embeds expressions within string literals using \(expression) syntax. The expression can be any valid Swift expression, including calculations and method calls. String interpolation is more readable and efficient than concatenation, automatically converting values to strings. It's Swift's preferred method for constructing strings from mixed content.

Question 16 Easy Mcq

✓ Correct ✗ Incorrect

What is wrong with this code? if let s = String.init("some string") { print(s)}

This String initializer does not return an optional.

String does not have an initializer that can take a String.

Nothing is wrong with this code

Explanation:

The as operator performs upcasting to supertypes, which always succeeds and doesn't require ? or !. For example, let animal: Animal = dog. Use as for guaranteed-safe casts to supertypes or protocol types. Understanding upcasting helps work with polymorphic code and class hierarchies safely.

Question 17 Easy Mcq

✓ Correct ✗ Incorrect

What is the inferred type of x? let x = ["a", "b", "c"]

String[]

Array

Set

Array

Explanation:

Character literals represent single characters using double quotes like "A". Characters in Swift are extended grapheme clusters, properly handling complex Unicode including emoji and combining characters. Understanding Character type helps work with individual characters correctly, especially with Unicode text requiring proper grapheme cluster handling.

Question 18 Easy Mcq

✓ Correct ✗ Incorrect

What is the output of this segment of code:var x = 0 for index in 1...5 { ++x } print("(x)")

None of this

Explanation:

Copy-on-write (COW) optimizes value type performance by sharing underlying storage until modification. Arrays, dictionaries, and strings use COW to avoid unnecessary copying. When you copy a collection, both share the same storage. On modification, a new copy is created. COW provides value semantics' safety with reference types' efficiency. Understanding COW explains why large Swift collections perform well despite being value types.

Question 19 Easy Mcq

✓ Correct ✗ Incorrect

Which of these is a valid definition of a generic function that incorporates inoutparameters in Swift?

func swap<T>(inout a: T, inout b: T) { let temp = a a = b b = temp }

func swap<U,T>(inout a: U, inout b: T) { let temp = a a = b b = temp }

func swap<U,T>( a: U, b: T) { let temp = a a = b b = temp }

func swap<T>( a: T, b: T) { let temp = a a = b b = temp }

Explanation:

Question 20 Easy Mcq

✓ Correct ✗ Incorrect

What is true of this code? let name: String?

Name can hold only a string value.

Name can hold either a string or nil value.

Optional values cannot be let constants.

Only non-empty string variables can be stored in name

Explanation:

Key paths provide type-safe references to properties without accessing them. Use \Type.property syntax. Key paths enable programmatic property access, useful for KVO, data binding, or reflection. They provide type-safe alternatives to string-based property access. Understanding key paths enables powerful metaprogramming patterns.

Question 21 Easy Mcq

✓ Correct ✗ Incorrect

What is the value of t after this code is executed? let names = ["Larry", "Sven", "Bear"] let t = names.enumerated().first().offset

This code is invalid.

This code does not compile.

Larry

Explanation:

Type inference allows the compiler to deduce types from context without explicit annotations. For example, var x = 5 infers Int. Reduces verbosity while maintaining type safety. The compiler analyzes expressions and assigns appropriate types. Type inference makes code cleaner without sacrificing compile-time type checking.

Question 22 Easy Mcq

✓ Correct ✗ Incorrect

What is the correct way to call this function? func myFunc(_ a: Int, b: Int) -> Int {return a + b}

MyFunc(5, b: 6)

MyFunc(5, 6)

MyFunc(a: 5, b: 6)

MyFunc(a, b)

Explanation:

Optional chaining safely accesses properties, methods, and subscripts on optional values using ?. If any optional in the chain is nil, the entire expression returns nil gracefully. For example, person?.address?.street returns nil if person or address is nil. Eliminates verbose nil checks and prevents force unwrapping crashes.

Question 23 Easy Mcq

✓ Correct ✗ Incorrect

What is Managing Memory in Swift?

In Swift with ARC we have no way to clean up the actual hardware ram. We can only make it possible for the OS to do that for us. One part is using the right code (optionals and weak) the other part is creating time for the OS to do it's job.

Imagine we have a function that runs on all threads indefinitely. It does one thing, load an image, convert to black/white and save. All images max at a couple of mb’s and the function creates no Software Memory Leaks. Because images don’t have a set size and might have different compression they don’t have the same footprint. This function will always crash your app.

This “Hardware” Memory Leak is caused by the function always taking the next available slot of memory.

All of the above

Explanation:

Memory management in Swift uses Automatic Reference Counting (ARC) that automatically tracks and manages object lifetimes for reference types. ARC inserts retain and release operations at compile time, deallocating objects when reference count reaches zero. Developers must understand strong reference cycles and use weak or unowned references to prevent memory leaks. Value types are managed through copying, not reference counting, making memory management simpler for structs and enums.

Question 24 Easy Mcq

✓ Correct ✗ Incorrect

What is used in Swift to represent any kind of object?

AnyObject

Nothing

Explanation:

AnyObject is Swift's protocol type that can represent an instance of any class type. It's used when you need to work with objects whose specific type is unknown at compile time. This is particularly useful when interfacing with Objective-C APIs or when creating collections that can hold different class instances. Unlike Id from Objective-C, AnyObject provides type safety in Swift.

Question 25 Easy Mcq

✓ Correct ✗ Incorrect

In the below text, what is the super class name?class Square: NamedShape {var sideLength: Double func area() -> Double { return sideLength * sideLength }}

Square

Double

area

NamedShape

Explanation:

Subscripts provide shortcut syntax for accessing collection elements or computed values using brackets []. Defined with subscript keyword, they can be read-write or read-only and take any number of parameters. Classes, structs, and enums can define subscripts. Use subscripts for natural element access patterns. Multiple subscripts can coexist with different parameter types or counts, enabling flexible access interfaces.

Question 26 Easy Mcq

✓ Correct ✗ Incorrect

What is the type of Swift String, Dictionary, Array?

Class

Union

Enum

Structure

Explanation:

Extensions add functionality to existing types (classes, structs, enums, protocols) without subclassing or modifying source code. They can add methods, computed properties, initializers, subscripts, and protocol conformance. Extensions cannot add stored properties or override existing members. Use extensions for organizing code, adding capabilities to types you don't own, and providing default protocol implementations. Extensions enable retroactive modeling and protocol-oriented programming.

Question 27 Easy Mcq

✓ Correct ✗ Incorrect

In the below text, what is the class name?Class Square: NamedShape {var sideLength: Doublefunc area() -> Double {return sideLength*sideLength}}

NamedShape

Square

class

Double

Explanation:

The class name is Square, which inherits from NamedShape as indicated by the colon syntax. Class names in Swift follow PascalCase convention, starting with an uppercase letter. The inheritance syntax class SubClass: SuperClass establishes the class hierarchy. Identifying class names is fundamental for understanding type relationships and instantiation. Class names appear before the colon, with the superclass after.

Question 28 Easy Mcq

✓ Correct ✗ Incorrect

What is the return type of the following code? func nameFunc() -> String { return "Jhon" }

Double

String

Bool

Array

Explanation:

Closures are self-contained blocks of code that capture and store references to variables and constants from surrounding context. They're first-class citizens assignable to variables, passable as arguments, and returnable from functions. Closures support shorthand syntax including trailing closure syntax, implicit returns, and shorthand argument names. Understanding closures enables functional programming and asynchronous code patterns.

Question 29 Easy Mcq

✓ Correct ✗ Incorrect

What is the return type in the following declaration:func potteryBarn (name: String, score: Int) -> String { return "Hello (name)!Your score is (score)." }

Integer

String

Function

Constant

Explanation:

Swift switch statements must be exhaustive, covering all possible values through cases or a default clause. Unlike C-style switches, Swift switches don't fall through to the next case by default - each case executes and exits. Use fallthrough keyword for intentional fall-through behavior. Switch statements can match ranges, tuples, patterns, and use where clauses for additional conditions. Exhaustiveness ensures all cases are handled at compile time.

Question 30 Easy Mcq

✓ Correct ✗ Incorrect

What is the value of test in this code? var test = 1 == 1

true

YES

This code contains an error

Explanation:

Sets store unique unordered values of the same type. Use Set syntax. Sets provide fast membership testing and set operations like union, intersection, and subtraction. Elements must be hashable. Use sets when uniqueness matters and order doesn't, or for efficient membership testing and mathematical set operations.

Question 31 Easy Mcq

✓ Correct ✗ Incorrect

What is the need for having structures?

To encapsulate simple data values.

To copy the encapsulated data and its associated properties by 'values' rather than by 'references'.

Structure to 'Copy' and 'Reference'.

All of them

Explanation:

Autoclosure automatically wraps expressions in closures without explicit braces, marked with @autoclosure. Enables cleaner syntax for delayed evaluation. For example, assert(_ condition: @autoclosure () -> Bool). The expression evaluates only when the closure is called. Use sparingly to avoid hiding execution costs. Autoclosure improves readability for assertions and short-circuit operations.

Question 32 Easy Mcq

✓ Correct ✗ Incorrect

What is the name of the following function:func potteryBarn (name: String, score: Int) -> String { return "Hello (name)!Your score is (score)." }

String

name: String, score: Int

potteryBarn

func

Explanation:

The final keyword prevents classes from being subclassed and prevents methods, properties, or subscripts from being overridden in subclasses. Final enables compiler optimizations through static dispatch and clearly communicates design intent that functionality shouldn't be extended. Use final for performance-critical code or when inheritance would break intended behavior. Final classes cannot be inherited; final members cannot be overridden in subclasses.

Question 33 Easy Mcq

✓ Correct ✗ Incorrect

____ in Swift is implemented with the is and as operators. These two operators provide a simple and expressive way to check the type of a value or cast a value to a different type?

Operator

Optional Chaining

Type casting

Protocols

Explanation:

Failable initializers return optionals, allowing initialization to fail gracefully by returning nil. Marked with init?() or init!() for implicitly unwrapped optionals. Use when initialization depends on conditions that might fail, like parsing strings or validating input. Failable initializers handle invalid input safely, preventing partially initialized objects. Common in parsing, resource loading, and validation scenarios requiring graceful failure.

Question 34 Easy Mcq

✓ Correct ✗ Incorrect

What is the name of the deinitializer in a Class declaration?

deinit

dealloc

release

Explanation:

Question 35 Easy Mcq

✓ Correct ✗ Incorrect

If a class has a superclass and conforms to multiple protocols, what is the correct order to list their names in the initial definition of the Subclass?

Protocols first, super class followed by comma.

Protocols and super class can be listed in any order.

Super class first, protocols followed by comma.

Explanation:

Deinitializers (deinit) perform cleanup when class instances are deallocated, called automatically by ARC when reference count reaches zero. Only classes have deinitializers. Use deinit to release resources like file handles, network connections, or observers. Deinit is written without parentheses and cannot be called explicitly. It ensures cleanup happens even when objects go out of scope, improving resource management.

Question 36 Easy Mcq

✓ Correct ✗ Incorrect

How can you use a nested type outside of its definition?

Prefix its name with the name of the type it is nested within.

It’s impossible, nested types can’t be used outside of definition.

It can be used from anywhere in the same block.

Use generic type for definition.

Explanation:

The try! operator forcefully executes throwing operations, crashing if errors occur. Use only when absolutely certain no error can happen - similar to force unwrapping optionals. Prefer try-catch or try? for production code. try! is appropriate during development for debugging or when errors truly indicate programmer mistakes rather than runtime conditions. Misuse causes production crashes, so use sparingly and document why errors are impossible.

Question 37 Easy Mcq

✓ Correct ✗ Incorrect

What is the error in this code? let x = 5; guard x == 5 { return }

The guard is missing the else.

Nothing is wrong.

The guard is missing a then.

The comparison is wrong.

Explanation:

Memory leaks occur when allocated memory isn't deallocated, typically from retain cycles. Leaked memory remains allocated but inaccessible, wasting resources and potentially causing crashes. ARC prevents most leaks automatically, but retain cycles require weak or unowned references. Instruments and debuggers help detect leaks.

Question 38 Easy Mcq

✓ Correct ✗ Incorrect

What is the type name that represents a character in Swift?

Character

Char

String

NSString

Explanation:

Character is Swift's native type for representing a single extended grapheme cluster, which can include a single Unicode character or multiple Unicode scalars forming one visible character. It provides full Unicode support and differs from String (a collection of characters), Char (non-existent in Swift), and NSString (Objective-C's string class). Character ensures proper handling of complex Unicode characters.

Question 39 Easy Mcq

✓ Correct ✗ Incorrect

What is the output when following statement is executed?import UIKitlet filename:String = "test.dat";let write_data:String = "write data";var read_data:String = "read data";if let directory = NSSearchPathForDirectoriesInDomains(NSSearchPathDirectory.DocumentDirectory, NSSearchPathDomainMask.AllDomainsMask, true).first{let pathname = NSURL(fileURLWithPath:directory).URLByAppendingPathComponent(filename);do {trywrite_data.writeToURL(pathname, atomically: false, encoding: N SUTF8StringEncoding) }catch { print(“write error”) }//readingdo{ read_data = try NSString(contentsOfURL: pathname, encoding: NSUTF8StringEncoding) as String } catch{ print(“read error”) } print(read_data) }

Write error

write data

read data

read error

Explanation:

Class-only protocols restrict conformance to classes using AnyObject requirement. Syntax: protocol MyProtocol: AnyObject. Use when protocol requires reference semantics, needs weak references, or involves Objective-C interoperability. Class-only protocols cannot be adopted by structs or enums. Understanding class-only protocols helps design protocols appropriate for their use cases.

Question 40 Easy Mcq

✓ Correct ✗ Incorrect

What is the typical byte width of Float data type in Swift?

4 bytes

8 bytes

16 bytes

32 bytes

Explanation:

Escaping closures outlive the function they're passed to, marked with @escaping. Use for completion handlers and asynchronous operations. Must explicitly capture self to prevent retain cycles. Non-escaping (default) execute before function returns. Marking correctly is important for memory management, compiler optimization, and preventing unexpected lifetime issues.

Question 41 Easy Mcq

✓ Correct ✗ Incorrect

Which one of the below functions definitions is wrong considering Swift language?

func haveChar(#string: String, character: Character) -> (Bool)

func mean(numbers: Double...) -> Double

func minMax(array: [Int]) -> (min: Int, max: Int)?

func minMax(array: [Int]) -> (min: Int?, max: Int?)

Explanation:

Question 42 Easy Mcq

✓ Correct ✗ Incorrect

extension Int {subscript(var myInt: Int) -> Int {var no1 = 1while myInt > 0 {no1 *= 10--myInt}return (self / no1) % 10}}print(12[0])What is the output?

Explanation:

Type casting checks and converts instance types using is and as operators. The is operator checks type membership returning Boolean; as? attempts safe downcasting returning optional; as! forces downcasting, crashing on failure. Type casting is common with class hierarchies, polymorphic collections, and Any/AnyObject handling, enabling safe runtime type inspection and conversion.

Question 43 Easy Mcq

✓ Correct ✗ Incorrect

What is the name of the Swift language feature that Objective-C Blocks are translatedinto?

Lambda

Callback

Closure

Selector

Explanation:

Question 44 Easy Mcq

✓ Correct ✗ Incorrect

What is the value of numbers in the code below? let numbers = [1,2,3,4,5,6].filter{ $0 % 2 == 0}

[1,3,5]

[]

[2,4,6]

Nil

Explanation:

Main actor using @MainActor marks code that must run on the main thread, important for UI updates. Apply to types, functions, or closures requiring main thread execution. Swift's concurrency model uses actors for thread safety. MainActor ensures UI code runs safely on the main thread.

Question 45 Easy Mcq

✓ Correct ✗ Incorrect

What is the most basic difference between Value and Reference types?

Copying Value type creates an shared instance where Reference type creates independent instance

Value type instance share a single copy of the data where Reference type instances keeps a unique copy of its data

Assigning a Value type to a new variable copies its contents to a new instance, where Reference types do not.

Explanation:

Memory leaks occur when allocated memory isn't deallocated, typically from retain cycles in reference types. Leaked memory remains allocated but inaccessible, wasting resources and potentially causing app crashes. Swift's ARC prevents most leaks automatically, but retain cycles require weak or unowned references. Instruments and memory debuggers help detect leaks. Prevention involves understanding object relationships and using appropriate reference types.

Question 46 Easy Mcq

✓ Correct ✗ Incorrect

What is the output when following code is executed? import UIKit import AVFoundation var p: AVAudioPlayer? func func(filename:String) { let url = NSBundle.mainBundle().URLForResource(filename, withExtension: "caf")! do { p = try AVAudioPlayer(contentsOfURL: url) guard let p = p else { return } … … … p.prepareToPlay() p.play() } catch let error as NSError { print(error.description) } }

Plays audio file given as parameter in current folder

Plays audio caf file in the resource folder of the bundle

Plays audio mp3 file in the Contents folder of the bundle

Function cannot be run and will output exception error

Explanation:

The code attempts to create an AVAudioPlayer with a non-existent audio file, so initialization fails and returns nil. Since the variable is declared as an optional (AVAudioPlayer?), the output would be nil or Optional.none. The error parameter would contain information about why the file couldn't be found. Understanding optional initialization and error handling prevents crashes when resources are unavailable.

Question 47 Easy Mcq

✓ Correct ✗ Incorrect

What is a muting instance method in Swift?

When there is "muting" keyword in front of extension.

When extension can add new types to existing classes.

When instance method without extension can modify itself.

A method that modifies self.

Explanation:

A mutating instance method in Swift is a method that can modify the properties of value types like structs and enums. The mutating keyword indicates that the method will change the instance's properties. Without this keyword, methods on value types cannot modify their properties. This is essential for maintaining Swift's value semantics and preventing accidental state mutations.

Question 48 Easy Mcq

✓ Correct ✗ Incorrect

What is the value of y? var x: Int? let y = x ?? 5

Nil

This code contains an error

Explanation:

Dictionaries store key-value pairs with keys being unique and hashable. Use [Key: Value] syntax. Access values by subscripting with keys, returning optionals since keys might not exist. Dictionaries are unordered collections ideal for lookups. Use when you need to associate values with unique keys for fast retrieval.

Question 49 Easy Mcq

✓ Correct ✗ Incorrect

What is the output of this segment of code?var x = 0for index in 1...5 {++x}println("\(x)")

compile error

Explanation:

Precedence groups define operator priority and associativity, controlling evaluation order in expressions with multiple operators. Higher precedence operators evaluate first. Associativity (left, right, or none) determines evaluation order for same-precedence operators. Define precedence groups for custom operators to ensure predictable evaluation. Understanding precedence prevents ambiguous expressions and bugs from unexpected evaluation order.

Question 50 Easy Mcq

✓ Correct ✗ Incorrect

What is the correct way to import Objective-C files into Swift?

Objective-C classes are automatically imported.

Objective-C classes are imported in the Swift file using the class.

Objective-C classes are imported via a Bridging Header.

Objective-C classes import themselves by declare @SwiftImportable.

Explanation:

Higher-order functions take functions as arguments or return functions, enabling functional programming. Common examples include map (transform), filter (select), reduce (combine), and sorted (order). They work with closures to process collections declaratively. Higher-order functions reduce boilerplate, improve readability, and enable composable transformations without explicit loops, fundamental to functional Swift programming.

Showing 50 of 67 questions

Filter by Difficulty

easy

medium

hard

Track Progress

Difficulty Filter

easy Easy

medium

hard

Other Subjects

Business Finance & Management

Industrial Engineering & Manufacturing

IT & Programming

Design & Multimedia

Content Writing & Translation

Administrative Support

Quick Navigation

Other IT & Programming Subjects

Swift

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Explanation:

Filter by Difficulty

Track Progress

Difficulty Filter

Other Subjects

Other IT & Programming Subjects

Quick Navigation

Similar Practices