Xcode Tip- Show Blame for line

If you are working on the project with multiple developer and found some bug in a line then you can check who was responsible for committing it using the Xcode feature.

You just need to right click on the line and tap “Show blame for line”, it will show the popup with the Developer name who committed the line along with Commit message.

How to check API availability in Swift?

If you are working with Swift then you need to be very careful to use the iOS specific API. As before Swift 2.0, there were no standard way to check the availability of any API or method.

Swift 2.0 introduced the “#available“ to check the API availability or run version specific code in blocks . If you are developing the application with deployment target 8.0 with base sdk 9.0. You need to use the API which is available in iOS 9 only then you could do this by checking the API availability. 

If you will not check the API availability then it will give you a compiler error. To prevent this error, you need to check the API availability.

if #available(iOS 9, *) {

            let stackView = UIStackView()

            // do iOS 9 stuff

        }

Using the availability syntax we will check whether we are running iOS 9 or later and if so will execute the code.

You can also add the availability check for the instance method and classes by inserting the given line above the method definition or at the top of the class.

@available(iOS 8.0, *)

    func iOS8Method() {

        // do stuff

        

    }

You can’t use this method without availability check if your deployment target is below 8.0. This method will run above iOS8.0 target. 

The * at the end is used to refer all the Future platforms that Apple introduces, and it's required.

Lazy Loading in Swift

Lazy loading is a technique to initialize the property only if they are called. In this way, memory is not allocated  to the property until it’s not initialized and if this property is not used then memory will never be allocated to this property. Lazy loading is also known as Dynamic loading.

In Swift, we have the keyword lazy to initialize the property with lazy loading. Lazy keyword makes sure that the property will be initialized only when its gets called and it would be initialized only once.

Also, whenever we want to declare the lazy property, always use the var keyword not let keyword as constant must always have a value before the initialization.

Here, we have define the Person Class with two properties name and message with lazy attribute means this variable will be initialized only when it is used. 

class Person {

    

    var name : String?

    lazy var message: String = {

        return "Hello \(self.name!)"

        }()

    

    init(name: String) {

        self.name = name

    }

}

Now, initialize the Person class. This will also initiate the name property but message is not initialized means person.mesage is nil.

var person = Person(name: "John") 

And when you tries to use the message properties then it will initialized.

println("\(person.message)") //  Hello John

      

As the message property closure will be called only once so even if you update the name property, it will not make any changes to your message property.

  

person.name = "Jimmy"

println("\(person.message)") //  Hello John

Lazy loading technique is used to improve the performance and to perform expensive operation. Swift has provided the direct support for lazy initialization with lazy attribute.

How to create custom operators in Swift?

In Swift, you can create your own custom operators in additions to the Swift operators. 

Swift has Unary, Binary and Ternary Operators. You can create the custom operators for Unary and Binary operators. For Unary operators, you can use Prefix and Postfix modifier and for Binary Operator, you can use Infix modifier.

Currently, we cannot write the Custom Ternary operators. Swift has only one Ternary Operator that is Condition operator.

eg- a ? b: c

Following are the modifier which you can use to create the custom operators. 

Prefix- A Unary Operator that is placed before the operand.

eg- b = ++a (++ is operator and a is operand)

Postfix- A Unary Operator that is placed after the operand.

eg- b = a++

Infix- A Binary operator that is placed in between the two operands.

eg- c = a + b

You can create the custom operators that starts with one of the ASCII characters /, =, -, +, !, *, %, <, >, &, |, ^, or ~, or any of the Unicode characters in the "Math Symbols" character set.

Note-  As mentioned in the Apple documentation, there are some operators which can’t be overloaded nor can be used as Custom Operators. 

The tokens =, ->, //, /*, */, ., the prefix operators <, &, and ?, the infix operator ?, and the postfix operators >, !, and ? are reserved. These tokens can’t be overloaded, nor can they be used as custom operators.

Implementing a Prefix and postfix operator-

As you know that Unary operator operates on single operand. It can be Prefix (++a) if they precede the operand or Postfix (a++) if they follows the operand.

You can implement your own custom unary operators by preceding the operators function with the prefix and postfix modifier.

Let’s declare the +++  prefix operator which can doubles the operand’s value.

prefix operator +++ {}

Now, define the operator functions.

prefix func +++ (number: Double) -> Double {

    return (number + number)

}

let value = +++10 // 20

In the same way, you can create the unary operator with  the postfix modifier.

Implementing an Infix Operator- 

Infix operator is operates on two operators and placed in between the two operands. When you declare the custom Infix operators you can specify the Associativity and Precedence. 

If there are two or more infix operators in the expressions then on the basis of Associativity and Precedence, it can be define which infix operator executes first.

Here, we have define the new custom infix operator +- with left associativity and 140 precedence.

Associativity value can be left, Right and None. By default it is None and the precedence value is 100 if it is not specified. 

infix operator +- { associativity left precedence 140 }

Now, implements the +- operator which returns the tuple value of sum and difference of two operands.

func +- (left: Double, right: Double) -> (Double, Double) {

    return (left + right, left - right)

}

let value = 3 +- 2 // (5, 1)

Subscript in Swift

Subscript are the shortcut to access the elements from collection, sequence and list. You can define the subscript in Class, Struct and enumeration to set and get the value by index. By using Subscript, you don’t need to write the separate methods for getting and setting the values.

Subscript can  read- write or read only. You define subscript by using the subscript keyword and specify one or more input parameters and return type.

subscript(parameters) -> ReturnType {

    get {

        //return someValue

    }

    set (newValue) {

        //setSomeValue()

    }

}

For read only Subscript, you can drop the get keyword.

subscript(parameters) -> ReturnType {

        //return someValue

}

Here, we have created the subscript in String Extension to check the substring is found in String or not. This Subscript will return a true value if substring is found in the String. This is the Read Only subscript.

extension String {

    

    subscript(pattern: String) -> Bool {

            let range = self.rangeOfString(pattern)

            return (range != nil)

    }

}

   var str = "Hello Swift"

   println(str["Swift"]) // true

Let’s create another Subscript of Read-Write type. In this Subscript, we can replace the Substring with another substring. Also, you can check that String contains substring or not. If the String contains the Substring, it will return the substring otherwise nil.

extension String {

    

    subscript(pattern: String) -> String? {

        get {

            let range = self.rangeOfString(pattern)

            

            if range != nil {

                return pattern

            } else {

                return nil

            }

        }

        set(replacement) {

            let range = self.rangeOfString(pattern)

            

            if range != nil {

                self = self.stringByReplacingCharactersInRange(range!, withString: replacement!)

            }

        }

    }

}

var str = "Hello Swift"

println(str["Swift"]) // Swift

println(str["Java"]) // nil

// Replace Hello with Hi

str["Hello"] = "Hi"

println(str)

In the setter, you can use the newValue keyword in place of replacement and code look like this.

subscript(pattern: String) -> String? {

        get {

            let range = self.rangeOfString(pattern)

            

            if range != nil {

                return pattern

            } else {

                return nil

            }

        }

        set {

            let range = self.rangeOfString(pattern)

            

            if range != nil {

                self = self.stringByReplacingCharactersInRange(range!, withString: newValue!)

            }

        }

    }

Alternative of #pragma mark for Swift

In Objective C, you might have used the #pragma mark directive for code organization in Jump bar.

But with Xcode 6 there is no pragma directive. Instead of this, you can use MARK, TODO and FIXME for managing the code which is supported by Xcode 6.

1) MARK:- It is an alternative of #pragma mark directive. It can be used for organizing code in a logical way so that it can be navigated by jump bar.

2) TO DO:- You can use this tag to make reminder to work on this later. You can use this tag within the function or outside the function.

3) FIX ME:- You can use this tag to make a reminder to fix some piece of code or methods. It can be placed inside or outside of the methods.

Note- “-” is optional in all the directives. If you use this dash then it will show a separator line in the Jump bar above the text.

Generic Functions in Swift.

Generic is one of the powerful feature of Swift. Most of the Swift Standard library uses this feature.

For instance, Swift Array and Dictionary are Generics Collection which can hold the value of any Type. You can create the array which holds Int values or String values.

With Generics code, developer can write flexible and reusable function which can work with any Type.

Suppose you have to write a function to swap two Int values. 

In Swift, parameters are passed by value so you can’t change the parameters value within the Function. If you want to modify the parameters value then you have to define the parameters as inout.

When you call a  function with an inout parameters, you use ampersand (&). This is something like passing the address of values as we have in C language.

If you want to write a function which can swap String or Doubles values then your function will look like this.

You may have noticed that all these functions bodies are same. Only difference is the type of the value passed to this functions.

So, you can write Generics functions which can work with any Type.

Generics function uses a placeholder type in angular bracket instead of actual Type name (Int, String). Both parameter a and b must be of same T type whatever T represents.