Other Trending Courses

Apart from basic, intermediate and advanced courses we also provided on demand training on below hottest topics:

  • React Native (Basics)
  • iOS – Bluetooth Low Energy
  • iOS – IoT – Arduino and BLE communication
  • iOS – Instruments
  • GIT (Source Control)

These topics will add weightage on your knowledge and employability.

Python

This course consists of basic python language fundamental and user interface creation.

  • Basics of command line
  • Introduction to Python
  • Uses of Python
  • How to Install Python
  • Python First Program
  • Code Test
  • Basic Data Types
  • Numbers
  • Dynamic Typing
  • Python Tuple
  • Variables in Python
  • Code Test
  • Learning Python Strings
  • Python Dictionary
  • Python Operators
  • Functions in Python
  • If Statement
  • Python Loops
  • Python Class & Objects
  • Date and time
  • Calendar
  • Nested Functions
  • Generators
  • Error Handling
  • Code Test
  • Modules
  • Packages
  • type()
  • Milestone projects as and when required

User Interface – Basic UI creation like buttons, text fields, labels, frame etc. Using these classes to draw user interface.

  • Label
  • Button
  • Entry/Text Fields
  • Fame
  • Frame Containment
  • Grid

Basics

Swift-Basics – Very important part as swift language is the backbone of iOS app development.

  • Why Swift
  • Swift vs other languages
  • The Basics
  • Basic Operators
  • Strings and Characters
  • Tuple
  • Collection Types
  • Strings
  • Arrays
  • Set
  • Dictionary
  • Array vs Dictionary vs Set
  • Control Flow
  • Functions
  • Closures
  • Enumerations
  • Traditional Enums (c way)
  • Raw Enums
  • Associated Enums
  • Classes and Structures
  • Class vs Structure vs Enums
  • Stored Properties
  • Computed Properties
  • Lazy Properties
  • Property Observers
  • Methods
  • Subscripts
  • Inheritance
  • Initialization
  • Deinitialization
  • Optional Chaining
  • Error Handling
  • Extensions
  • Protocols
  • Automatic Reference Counting
  • Strong
  • Weak
  • Strong reference cycle
  • Memory Safety
  • Deep Copy Swallow Copy
  • If let guard let guard else
  • High Order Functions in Swift
  • Map
  • Flatmap
  • Reduce
  • Filter
  • Sorted
  • High Order Function Chaining
  • Class function Vs
  • Static Function

Intermediate

This course contains swift language fundamentals and user interface. Below are the course content:

Swift-Basics – Very important part as swift language is the backbone of iOS app development.

  • Why Swift
  • Swift vs other languages
  • The Basics
  • Basic Operators
  • Strings and Characters
  • Tuple
  • Collection Types
  • Strings
  • Arrays
  • Set
  • Dictionary
  • Array vs Dictionary vs Set
  • Control Flow
  • Functions
  • Closures
  • Enumerations
  • Traditional Enums (c way)
  • Raw Enums
  • Associated Enums
  • Classes and Structures
  • Class vs Structure vs Enums
  • Stored Properties
  • Computed Properties
  • Lazy Properties
  • Property Observers
  • Methods
  • Subscripts
  • Inheritance
  • Initialization
  • Deinitialization
  • Optional Chaining
  • Error Handling
  • Extensions
  • Protocols
  • Automatic Reference Counting
  • Strong
  • Weak
  • Strong reference cycle
  • Memory Safety
  • Deep Copy Swallow Copy
  • If let guard let guard else
  • High Order Functions in Swift
  • Map
  • Flatmap
  • Reduce
  • Filter
  • Sorted
  • High Order Function Chaining
  • Class function Vs
  • Static Function

User Interface – Designing user interface like buttons, labels, custom/complex views etc.

  • Autolayout
  • UIViewController
  • UIView
  • UIButton
  • UILabel
  • UITextField
  • UITextView
  • UITableView
  • UICollectionView
  • Storyboard
  • UINavigation Controller

Advance

Advance course contains language basics, user interface creation, network calling and database integration. Below are details of course:

Swift-Basics – Very important part as swift language is the backbone of iOS app development.

  • Why Swift
  • Swift vs other languages
  • The Basics
  • Basic Operators
  • Strings and Characters
  • Tuple
  • Collection Types
  • Strings
  • Arrays
  • Set
  • Dictionary
  • Array vs Dictionary vs Set
  • Control Flow
  • Functions
  • Closures
  • Enumerations
  • Traditional Enums (c way)
  • Raw Enums
  • Associated Enums
  • Classes and Structures
  • Class vs Structure vs Enums
  • Stored Properties
  • Computed Properties
  • Lazy Properties
  • Property Observers
  • Methods
  • Subscripts
  • Inheritance
  • Initialization
  • Deinitialization
  • Optional Chaining
  • Error Handling
  • Extensions
  • Protocols
  • Automatic Reference Counting
  • Strong
  • Weak
  • Strong reference cycle
  • Memory Safety
  • Deep Copy Swallow Copy
  • If let guard let guard else
  • High Order Functions in Swift
  • Map
  • Flatmap
  • Reduce
  • Filter
  • Sorted
  • High Order Function Chaining
  • Class function Vs
  • Static Function

User Interface – Designing user interface like buttons, labels, custom/complex views etc.

  • Autolayout
  • UIViewController
  • UIView
  • UIButton
  • UILabel
  • UITextField
  • UITextView
  • UITableView
  • UICollectionView
  • Storyboard
  • UINavigation Controller

 Data Management – Saving/persisting data in iOS apps

  • Core Data

API – Getting data from external servers in iOS apps

  • NSUrlSession
  • Alamofire

React Native, Day 4, Breaking down code structure

Hello guys, hope you are doing good. It is suggested to have a look at previous tutorials:

React Native Day 1, Understanding Technology, Fundamentals and React

React Native Day 2, Creating first React Native App

React Native, Day 3, Running app on iOS simulator and exploring some cool stuffs

Please support us by comment, like and share our facebook page.

In this tutorial, we will learn below concepts:

Folder structure and modules.

Imports like importing React, { Component }, { View, Text} etc.

Subclassing/extending.

Styling using StyleSheet.create

Exporting –  export default, to make our component importable.

Creating a component which contains basic text.

We will understand that JSX is mixing xml/html with javascript.

We learn about render() function.

Module Structure

In react native we have different classes in different files. These files then can be put into different folders. Basically we follow a module structure by grouping related javascript files in folder. We can then use app.js file to import them and reuse them.

Note : I will use this code for reference.

 

 

If you look at above folders structures node_modules contains sub modules. “react” module contains javascript files related to React library.

If you guys are coming from swift background you must have heard about swift high order functions like map, flatmap, filter etc. You want similar functionalities in javascript? Yes javascript have these functionalities in form of modules. Go to node_modules > array-filter. Similarly go to node_modules > array-flatten. Similarly we have array-maparray-filter etc.

I am not a javascript programmer & I have understood it my way, hope you guys also get some idea about modules. Now if i have to use these modules some where in my code, i have to import them as simple as it is.

app.json


press “i” on command line to run my app and yeah there is the app name. In case you are not able to see it try pressing command+d.

Note : If you are not aware of how to launch and run app on iOS simulator, please read it here.

Here is the complete details of what you can do with app.json file.

 Let’s write some basic code:

Importing

Here we are creating a variable named React of ‘react’ library. By using this variable i will be able to use methods, properties of ‘react’ library.

Remind : React is a JavaScript library to create user interface. Let’s say you want to create some user interface with labels, text fields, alerts, buttons, square, circle, rectangle etc., then you can use this React library. React have components which can be rendered by calling render() method.

Subclassing or creating a Component Class

In javascript we can use component to create new components. We have the React variable and we can call React.Component to create new components. We subclass React.Component to create new components.

Here we are creating a new component named “App” by subclassing React.Component.

Rendering

We have subclassed React.Component but still we have not written any code related to user interface like label, text, button etc. So where to write code for it?

Here is the answer:

React components implement a render() method that takes input data (generally JSX) and return what to display.

It was the basic building block to understand the structure of component in javascript.

Please support us by comment, like and share our facebook page.

Let’s explore it more with some more code in place:

What?

This is called a member import in javascript. In depth and detailed articles are here and here.

This time we have provided proper code for creating some user interface using View and Text.

We are rendering a View which contains text.  Let’s run it and see output:

 

So do not worry about the layout as we have not used any styles, so our text is overlapping with status bar.

Styling

Create style using StyleSheet.create() method. For example below code creates a style named “style1” which centers the content and provide background color to be white.:

The complete App.js file looks like this:

Again gotcha,  😳  😳 !!!!

Now

What it have to do with our code?  😳  😳

If you see till now we have only created a component, we need to make it exportable so that it can be imported and run by npm.

The same code above can also be written as:

Final output of app:

 

 

 

Conclusion:

We learned about folder structure and modules.

We need imports like importing React, { Component }, { View, Text} etc.

We learned about subclassing.

We learn about styling using StyleSheet.create

We learn about export default, to make our component importable.

We learn about creating a component which contains basic text.

We also understand that JSX is mixing xml/html with javascript.

We learn about render() function.

Happy coding!!! 🙂

Please support us by comment, like and share our facebook page.

Swift – Optional | Implicit Optional | Optional Binding | Optional Unwrapping

We will learn about Optionals?, their unwrapping, implicitly unwrapped optional!, optional binding and automatic unwrapping.

Normal Optionals :

What : Optionals (normal) are data types, which have value or nothing. ? mark is used to denote optional. Optional means , it may have or may not have any value. think optional(?) as as box (which can contain some thing or nothing) and ! exclamation mark as key of the box. To fetch value from optional var we need operator exclamation mark !

When : when you want to declare a variable, which may or may not have value in future. Suppose you get API response which “may” have person’s first name, middle name and last name. you can simply use optional data type(?) for all three variables.

Declaration : var nameOfYourVariable : Type?

Implicitly Unwrapped Optional :

What : “implicitly unwrapped” optional, meaning that you do not have to unwrap it to access the value.

When : To make sure it must not be nil, and you do not need to deal with unwrapping.

Declaration : var nameOfYourVariable : Type!

/**************example************************************/


/**************example************************************/


Optional Binding : 

What : To find out whether an optional contains a value, and if so, to make that value available as a temporary constant or variable.

When : Most recommended way to unwrap optionals.

Syntax : 

if let someValue = someOptional{

//…………use this someValue variable

}else{

//……it means someOptional is nil, it has no value.

}

/**************example************************************/


/**************example************************************/


Implicitly Unwrapped Optional : 

What : Sometimes it is clear from a program’s structure that an optional will always have a value, after that value is first set. In these cases, it is useful to remove the need to check and unwrap the optional’s value every time it is accessed, because it can be safely assumed to have a value all of the time.

These kinds of optionals are defined as implicitly unwrapped optionals. You write an implicitly unwrapped optional by placing an exclamation mark (String!) rather than a question mark (String?) after the type that you want to make optional.

When : Implicitly unwrapped optionals are useful when an optional’s value is confirmed to exist immediately after the optional is first defined and can definitely be assumed to exist at every point thereafter.

/**************example************************************/