Category: Computer Programming

Swift – Quick Guide ”; Previous Next Swift – Overview Swift 4 is a new programming language developed by Apple Inc for iOS and OS X development. Swift 4 adopts the best of C and Objective-C, without the constraints of C compatibility. Swift 4 makes use of safe programming patterns. Swift 4 provides modern programming features. Swift 4 provides Objective-C like syntax. Swift 4 is a fantastic way to write iOS and OS X apps. Swift 4 provides seamless access to existing Cocoa frameworks. Swift 4 unifies the procedural and object-oriented portions of the language. Swift 4 does not need a separate library import to support functionalities like input/output or string handling. Swift 4 uses the same runtime as the existing Obj-C system on Mac OS and iOS, which enables Swift 4 programs to run on many existing iOS 6 and OS X 10.8 platforms. Swift 4 comes with playground feature where Swift 4 programmers can write their code and execute it to see the results immediately. The first public release of Swift was released in 2010. It took Chris Lattner almost 14 years to come up with the first official version, and later, it was supported by many other contributors. Swift 4 has been included in Xcode 6 beta. Swift designers took ideas from various other popular languages such as Objective-C, Rust, Haskell, Ruby, Python, C#, and CLU. Swift – Environment Local Environment Setup Swift 4 provides a Playground platform for learning purpose and we are going to setup the same. You need xCode software to start your Swift 4 coding in Playground. Once you are comfortable with the concepts of Swift 4, you can use xCode IDE for iOS/OS x application development. To start with, we consider you already have an account at Apple Developer website. Once you are logged in, go to the following link − Download for Apple Developers This will list down a number of software available as follows − Now select xCode and download it by clicking on the given link near to disc image. After downloading the dmg file, you can install it by simply double-clicking on it and following the given instructions. Finally, follow the given instructions and drop xCode icon into the Application folder. Now you have xCode installed on your machine. Next, open Xcode from the Application folder and proceed after accepting the terms and conditions. If everything is fine, you will get the following screen − Select Get started with a playground option and enter a name for playground and select iOS as platform. Finally, you will get the Playground window as follows − Following is the code taken from the default Swift 4 Playground Window. import UIKit var str = “Hello, playground” If you create the same program for OS X program, then it will include import Cocoa and the program will look like as follows − import Cocoa var str = “Hello, playground” When the above program gets loaded, it should display the following result in Playground result area (Right Hand Side). Hello, playground Congratulations, you have your Swift 4 programming environment ready and you can proceed with your learning vehicle “Tutorials Point”. Swift – Basic Syntax We have already seen a piece of Swift 4 program while setting up the environment. Let”s start once again with the following Hello, World! program created for OS X playground, which includes import Cocoa as shown below − /* My first program in Swift 4 */ var myString = “Hello, World!” print(myString) If you create the same program for iOS playground, then it will include import UIKit and the program will look as follows − import UIKit var myString = “Hello, World!” print(myString) When we run the above program using an appropriate playground, we will get the following result − Hello, World! Let us now see the basic structure of a Swift 4 program, so that it will be easy for you to understand the basic building blocks of the Swift 4 programming language. Import in Swift 4 You can use the import statement to import any Objective-C framework (or C library) directly into your Swift 4 program. For example, the above import cocoa statement makes all Cocoa libraries, APIs, and runtimes that form the development layer for all of OS X, available in Swift 4. Cocoa is implemented in Objective-C, which is a superset of C, so it is easy to mix C and even C++ into your Swift 4 applications. Tokens in Swift 4 A Swift 4 program consists of various tokens and a token is either a keyword, an identifier, a constant, a string literal, or a symbol. For example, the following Swift 4 statement consists of three tokens − print(“test!”) The individual tokens are: print(“test!”) Comments Comments are like helping texts in your Swift 4 program. They are ignored by the compiler. Multi-line comments start with /* and terminate with the characters */ as shown below − /* My first program in Swift 4 */ Multi-line comments can be nested in Swift 4. Following is a valid comment in Swift 4 − /* My first program in Swift 4 is Hello, World! /* Where as second program is Hello, Swift 4! */ */ Single-line comments are written using // at the beginning of the comment. // My first program in Swift 4 Semicolons Swift 4 does not require you to type a semicolon (;) after each statement in your code, though it’s optional; and if you use a semicolon, then the compiler does not complain about it. However, if you are using multiple statements in the same line, then it is required to use a semicolon as a delimiter, otherwise the compiler will raise a syntax error. You can write the above Hello, World! program as follows − /* My first program in Swift 4 */ var myString = “Hello, World!”; print(myString) Identifiers A Swift 4 identifier is a name used to identify a variable, function, or any other userdefined item. An

Compile Swift Online ”; Previous Next You really do not need to set up your own environment to start learning Swift programming. Reason is very simple, we already have set up Swift environment online, so that you can execute all the available examples online at the same time when you are doing your theory work. This gives you confidence in what you are reading and to check the result with different options. Feel free to modify any example and execute it online. Try following example using Live Demo option available at the top right corner of the below sample code box: Live Demo let constA = 42 print(constA) let constB:Float = 3.14159 print(constB) For most of the examples given in this tutorial, you will find Live Demo option, so just make use of it and enjoy your learning. Print Page Previous Next Advertisements ”;

Swift – Access Control ”; Previous Next Access controls are used to restrict access to the specified part of the code or module. It prevents unauthorized access and implements encapsulation. The access control mechanism controls the access of the methods and properties of classes, structures and enumerations. Constants, variables and functions in a protocol are restricted and allowed access as global and local through access control. Access control applied to properties, types and functions can be referred to as ”entities”. The access control model is based on modules and source files. The module is defined as a single code distribution unit and can be imported using the keyword ”import”. A source file is defined as a single source code file within a module to access multiple types and functions. Access Levels in Swift Swift supports the following access levels and they are: Access Levels Definition Open It is the least restrictive access level. It is applicable only to classes and class memebers. It allows class and class members to be subclassed or overrridden in another module. Public It allows entities to be access from any source file within the same or different module. Internal It allows entities to be used within any source file from their defining module, but not outside of that module. Private It restricts the use of an entity to its own defining source file. It hides the implementation details of a specific code functionality. It is the most restrctive access level. File-Private It also restricts the use of an entity to its own defining source file. It hides the implementation details of a specific code functionality when those details are used inside the entire file. Rules of using Access levels Following are some rules that must be known by the developers while using access level − The public variable can not be defined as internal, file-private or private. The function does not have a higher access level than its parameter and return type. The default access level for all the entities is internal. The default access level for single-target apps is internal. The default access level for frameworks is either open or public. Syntax public class SomePublicClass {} internal class SomeInternalClass {} private class SomePrivateClass {} public var somePublicVariable = 0 internal let someInternalConstant = 0 private func somePrivateFunction() {} Access Control for Function types Some functions may have arguments declared inside the function without any return values. The following program declares a and b as arguments to the sum() function. Inside the function itself, the values for arguments a and b are passed by invoking the function call sum() and its values are printed thereby eliminating return values. To make the function”s return type as private, declare the function”s overall access level with the private modifier. Example Swift program to demonstrate access control for function types. // Private function private func sum(a: Int, b: Int) { let a = a + b let b = a – b print(a, b) } // Calling the function sum(a: 20, b: 10) sum(a: 40, b: 10) sum(a: 24, b: 6) Output It will produce the following output − 30 20 50 40 30 24 Access Control for Enumeration types The enumeration in Swift automatically receives the same access level for individual cases of an enumeration. Consider for example accessing the student name and marks secured in three subjects enumeration name is declared as a student and the members present in the enum class are a name that belongs to string datatype, marks are represented as mark1, mark2 and mark3 of datatype Integer. To access either the student name or marks they have scored. Now, the switch case will print the student”s name if that case block is executed otherwise it will print the marks secured by the student. Example Swift program to demonstrate access control for enumeration types. // Enumeration public enum Student { case Name(String) case Mark(Int, Int, Int) } var studDetails = Student.Name(“Swift”) var studMarks = Student.Mark(98, 97, 95) switch studDetails { case .Name(let studName): print(“Student name is: (studName).”) case .Mark(let Mark1, let Mark2, let Mark3): print(“Student Marks are: (Mark1), (Mark2), (Mark3).”) } Output It will produce the following output − Student name is: Swift. Access Control for SubClasses Swift allows the user to subclass any class that can be accessed in the current access context. A subclass cannot have a higher access level than its superclass. The user is restricted from writing a public subclass of an internal superclass. Example Swift program to demonstrate access control for subclasses. // Class public class Cricket { internal func display() { print(“Welcome to Swift Super Class”) } } // Subclass internal class Tennis: Cricket { override internal func display() { print(“Welcome to Swift Sub Class”) } } let cricketInstance = Cricket() cricketInstance.display() let tennisInstance = Tennis() tennisInstance.display() Output It will produce the following output − Welcome to Swift Super Class Welcome to Swift Sub Class Access Control for Constants, variables, properties and subscripts We are allowed to control the visibility of the constants, variables, properties and subscripts with the help of access controls. When a constant, variable, property or subscript uses private type, then that constant, variable, property, or subscript must be marked as private. And we are not valid to write a public property with a private type. Similarly, a subscript cannot be more public than its return type. Example private var privateInstance = SomePrivateClass() Access Control for Getters and

Swift – Error Handling ”; Previous Next Error handling is a process of managing and responding to unexpected situations that occur during the execution of the program. Errors may occur due to various reasons like hardware issues, logical mistakes, unexpected user input, etc. Swift provides good support for catching, throwing, and manipulating recoverable errors during runtime. The main goals of error handling are: Detect Errors − Identify where and what type of error occurs in the program. Reporting Errors − Report the details of the error to the developer or end-user. Handling Errors − Take proper action against the occurred error which may include providing an error message, logging information for debugging or implementing strategies for recovery. Now in this article, we will discuss how errors are represented, propogated, and handled by the Swift. How an error is represented in Swift? In Swift, an error is represented by using the type that conforms to the Error protocol. The Error protocol is empty, which means it does not have any specific methods and properties to implement instead it allows us to create our own custom error types by defining a new type that conforms to the Error protocol. The best way to represent errors is enumeration. It grouped all the related error conditions with associated values and information about the error’s behaviour. Example The following Swift example will show how to represent an error. enum MyNewError: Error { case invalidInput case fileNotFound case networkError // Add more cases if you require } Throwing Error in Swift In Swift, throwing an error means when a function or a method detects something unexpected that prevents it from executing in the normal way, then it throws an error that tells that something unexpected has occurred. It is further helpful in handling the error. We can throw errors with the help of a throw statement. Syntax Following is the syntax for throwing an error − throw enumerationName.error Example Following Swift”s example we show how to throw an error. throw MyNewError.fileNotFound Propagating Errors Using Throwing Functions We can propagate errors from the throwing function. The throwing function is a function marked with the throw keyword. In Swift, functions, methods, or initializers can throw errors. When a function, method, or initializer encounters an error, then they can use the throws keyword in their declaration part after the parameter and before the return arrow(->). Only the throwing function is allowed to propagate errors. If an error occurs inside the non-throwing function, then that error must be handled inside that function. Syntax Following is the syntax for the throwing function − func functionName(parameterList) throws -> ReturnType Example The following Swift program will show how to throw an error using the throwing function. enum MyNewError: Error { case invalidInput case fileNotFound case networkError } // Throwing Function func processData(_ enterValue: String) throws { guard !enterValue.isEmpty else { throw MyNewError.invalidInput } } // Handling errors do { // Calling throwing function try processData(“”) print(“Successful”) } catch MyNewError.invalidInput { print(“Invalid input”) } catch { print(“Unexpected error occurred: (error)”) } Output It will produce the following output − Invalid input Disabling Error Propagation We can disable error propagation with the help of try! Keyword. It is helpful when we are confident the error does not occur at runtime and can simplify the error handling code. However, be careful while using try! Keyword if an error occurs, then our program will crash at runtime. Example Swift program to demonstrate how to disable error propagation. // Set of errors enum myNewError: Error { case divisionByZero case invalidInput } // Throwing function func divideNum(_ dividend: Int, by divisor: Int) throws -> Int { guard divisor != 0 else { throw myNewError.divisionByZero } return dividend / divisor } // Here we”re sure that the divisor is not zero, // so we use try! to disable error propagation. let output = try! divideNum(10, by: 2) print(output) Output It will produce the following output − 5 Handling Errors Using Do-Catch In Swift, we can handle errors with the help of a do-catch statement. It makes our code more robust and allows us to provide specific error-handling logic for various errors. In the do-catch statement, the do block contains the code that might throw an error and the catch block handles the specific error that occurs in the do block. Not all the errors thrown by the do clause are handled by the catch clause. If none of the catch clauses handle the occurred error, then that error will propagate to the surrounding scope and the surrounding scope will handle the propagated error. If the error propagated to the top-level scope without handling then we will get a runtime error. In the non-throwing functions, the errors are handled by the enclosed do-catch statement whereas in throwing functions the errors are handled by the enclosed do-catch statement or the caller. Syntax Following is the syntax of the do-catch statement − do { try<expression> } catch <pattern1>{ // statement } catch <pattern2>{ // statement } catch <pattern3>, <pattern4> where <condition>{ // statement } catch { //statement // catch clause without pattern can match any error } Example Swift program to demonstrate how to handle errors using do-catch blocks. // Set of errors enum myNewError: Error { case divisionByZero case invalidInput } // Throwing function func divideNum(_ dividend: Int, by divisor: Int) throws -> Int { guard divisor != 0 else { throw myNewError.divisionByZero } return dividend / divisor } // Handling error using do-catch statement do { let result = try divideNum(10, by:

Swift – Singleton Class ”; Previous Next A Singleton Class is a special class which have only one object and will make sure that your application or program uses that object. If you try to create another variable of singleton class you will get an error. Singleton class is easy to use but it has a major drawback which is global access, which means you can access singleton class globally by sharing the instance of the class. Which makes it hard to maintain, can lead to concurrency issues, etc. So to avoid excess use of singleton object we use dependency injection. Dependency injection passes the singleton object to the object where it is required. If a class depends upon the singleton and they are present in different contexts, then you have to import a singleton into that context without importing the class cannot access the singleton. Syntax Following is the syntax of the Singleton Class − class Name{ // body } Creating and Accessing Singleton Class We can create a singleton class just like the normal class using the “class” keyword but with some different rules and they are − A singleton class should have a private initializer. A singleton class should have a static-type object. Private Initializer This private initializer prevents the object creation from outside the class. If you try to create an object outside the class you will get an error. To create a private initializer we will use a “private” keyword. Syntax Following is the syntax for private initializer − private init(){} Example Swift program to create a singleton class with a private initializer. import Foundation // Outer class class SingletonClass{ // Creating a private initializer private init(){} func show(){ print(“Hello”) } } // Creating object outside the class // We will get an error let myObject = SingletonClass() myObject.show() Output It will produce the following output − main.swift:16:16: error: ”SingletonClass” initializer is inaccessible due to ”private” protection level let myObject = SingletonClass() Here the private protection level prevents us from creating an object outside the class. So to overcome this error we have to create an object inside the class. Static Object If we have a static object inside the single class we can easily access the object by using the class name. To create a static object we use the “Static” keyword. Syntax Following is the syntax for static objects − static let objectName = className() Following is the syntax for accessing static objects − let variableName = className.objectName Example Swift program to create a singleton class with an object. import Foundation // Singleton class class SingletonClass{ // Creating object outside the class static let myObject = SingletonClass() // Creating a private initializer private init(){} // Method func show(){ print(“Hello I am Singleton Class”) } } // Accessing the object let ob = SingletonClass.myObject // Accessing the method ob.show() Output It will produce the following output − Hello I am Singleton Class Singleton Class Normal Class It have only one instance throughout the lifetime of the program. It can have multiple instances. It does not allows you to create instances of the class. It allows you to directly create instances of the class using its initializer. You can access the instance with the help of shared properties and methods that provide global access to the object. You can directly access the instances. It is less flexible in terms of creating objects and can use tight coupling between different parts of the code. It is more flexible in terms of creating objects and can allow loose coupling between different parts of the code. Testing singleton class is difficult because of global state and dependencies. Testing normal classes is much more easier. Print Page Previous Next Advertisements ”;