DEV Community: Agoi Abel Adeyemi

Array and Map in Solidity

Agoi Abel Adeyemi — Wed, 01 Apr 2020 04:34:43 +0000

An array allows us to represent a collection of data, but it is often more useful to think of an array as a collection of variables of the same type with keys having sequential order based on the order they were added.

Instead of declaring individual variables, such as number1, number2, number3, ….., and number99, you can declare one array variable such as numbers and use numbers[0], numbers[1], …, numbers[99] to represent individual variables.

Having understood how the array works in JAVASCRIPT and PHP, I was going to rush through it in solidity but to my greatest surprise, it is quite different here in the solidity blockchain world :). I decided to write about the array and map since both of them seem similar to me and can be used together.

Unlike in javascript where we could have an array of integer together with strings or any other data type, our array must have the variable of the same data type and this can be enforced when declaring it like below:

uint[] myArray; //declaring an array of integer variables

Before I dive fully into the array in solidity, I want to clarify that there are two types of arrays in solidity, which are the storage array and the memory array.

Storage Array:

These are arrays that are stored inside the blockchain after you execute your function, you can declare them like normal variables without our contract like below:

where unit/bool/address is the variable type, followed by [] and then the name of the array which can be any name.

Manipulation of the storage array:

To add a new element to the array, we need to reference the array and use the .push(value), we can also update an array position by referencing the element key like myArray[0] = ‘new value’;, we also can also get a particular array element position by simple using myArray[0] where 0 is the index or key of the array element

We can also use the for loop to access the element of the array as we would array in javascript (also in the snippet above). To delete an element in the array, we will use delete myArray[1] where 1 is the array key, please note that this will not affect the array length but will only reset the array value at the index of one or second element in the array to the default value of the data type. i.e 0 if it’s a uint type and false if bool. When we try to access an array key that does not exist, we will have an error.

Memory Array:

These arrays are not stored into the blockchain after calling the function, you can only declare them within a function like below:

where unit[] is the type of the variables, memory keyword declares it has a memory array followed by the name which can be an acceptable name, it must be equated to new unit type where the unit[] must be the variable type again and the number of elements that will be in the array in the bracket ().

Manipulation of the memory array:

To add value to the memory array, we cannot use the .push() method, as we need to use the index notation instead like newArray[0] = 1 , newArray[1] = 1 etc. We can read a value, update a value, delete a value from the memory array just like the storage array.

Passing an array as a function argument:

We can pass an array as a function argument in solidity, the function visibility determines if the keyword before the array name should be calldata or memory. We use calldata if the function visibility is external and memory if the function visibility is public and internal. See example below:

Seems we have covered all we need to do in an array, how about mapping.

A Map is something like an array with a collection of similar variables that uses key look-ups meaning you’re referencing values with an object instead of an integer in short.

Basically, mapping is equivalent to a dictionary or a map in other programming languages. It’s key-to-value storage. A standard array is an index look-up e.g. if there are 10 elements in the array the indexes are 0–9 and it would look like below as an array of integers:

[0] 555
[1] 123
...
[8] 22
[9] 5

The map works slightly different and the easiest way to describe it is that it uses key lookups. So if this was a map of addresses to integers then it would look something like:

[0x000000000000000A] 555
[0x0000000000000004] 123
....
[0x0000000000000006] 22
[0x0000000000000003] 6

So basically, you’re referencing values with an object instead of an integer. The keys also don’t have to be in sequence. It consists of two main parts: a _KeyType and a _ValueType; they appear in the following syntax below:

mapping (_KeyType => _ValueType) mapName.

Think of the _KeyType as the key you'll pass through a function to return the desired value, or _ValueType. By default, a mapping is initially empty, so a new _KeyType will first need to be mapped to a _ValueType.

It could be

mapping(string => string) mapName;

mapping(int => bool) mapName;

Manipulation of a map:

We can manipulate a map within a function like below:

We assigned a value to the map here balances[msg.sender] = 100 by equating it to a value. We read the value also by balances[msg.sender] without assigning any value. When we use a non-existence key to read a value from a map, it will return the default data value used to initialize the value type when declaring it unlike undefined in javascript.

Assign an array as a map value:

We can assign an array as a value type to a map and can access them as we would an array like below:

Assign another map as a map value:

We can also assign another map as a map value and can access them as we would access a map like below:

We can assign a Struct as a map value type too, there are occasions when you want to iterate over a map and do other things on a map, I would advise you check out the resources below when the need arises:

Guide

The complete guide to Forms in React

Agoi Abel Adeyemi — Fri, 07 Sep 2018 11:34:04 +0000

a letter about react forms to me in the future

Forms are very useful in any web application. Unlike angular and angularjs, that gives form validation out of the box. You have to handle forms yourself in React. This brought about many complications like how to get form values, how do I manage form state, how do I validate my form on the fly and show validation messages. There are different methods and libraries out there to help with this but if you are like me that hates dependent on too many libraries, welcome on board, We are going to bootstrap our own form from the ground up.

There are two types of form input in react. We have the uncontrolled input and the controlled input. The uncontrolled input are like traditional HTML form inputs, they remember what you typed. We will use ref to get the form values.

We added the ref="name" to the input tag so that we can access the value with this.refs.name.value when the form is submitted. The downside to this is that you have to “pull” the value from the field when you need it and this can happen when the form is submitted.

The controlled input is when the react component that renders a form also controls what happens in that form on subsequent user input. Meaning, as form value changes, the component that renders the form saves the value in its state.

Of course, another component can handle the form state. The goal is that each time the input changes, the method changeHandler is called and will store the input state. Hence the component always has the current value of the input without needing to ask for it. This means that the form component can respond to input changes immediately; for example

in-place feedback, like validation
disabling the button unless all fields have valid data
enforcing a specific input format

Handling multiple forms inputs

In most situations, we are going to have more than one form input. We need a way to capture the input with a method instead of declaring multiple methods to do this. Hence we are going to modify the changeHandler to below:

Because of the way the changeHandler has been modified above, our form input can reference it to update it states dynamically.

Create a TextInput Component

There are different input elements e.g text, email, password, select option, checkbox, date, radio button, etc. I love to create a separate custom component for the input elements, let us start with the text input type.

Notice the {…props}, we use this to distribute the props to the input element. We can use the custom text input element like below:

Validating our Custom TextInput

Since we are using the controlled input, we can add more keys to our formControls state to help validate the input. We need the valid property to denote if the input is valid or not, the validationRules contains the list of the rules to be checked before the input is valid.

Our aim is that each time the input changes. We make sure the validationRules for that input is checked for true or false, then update the valid key with the result of the check. We also added the touched property to denote that the user has touched the form input, this will help with displaying validation feedback when the input has been touched. The check will be done in the changeHandler method like below:

The valid is equated to the methodvalidate(value, prevState.formControls[name]).validationRules) which we will use to check if the valid status for a particular control is true or false.

I move the validate method to a separate class then import it. The validate method accepts two parameters, the value and the rules. We loop through the rules and check if each rule is valid, then return true when valid and false when invalid.

Let assume we want to add another validation on name e.g we wantname to be required. All we need do is update the formControl for name validationRules, and write the logic for it in the validator class like below

Then we need to update the validator class to accommodate for the required validator.

We created a custom TextInput, we created a formControl that has a property named name with a validation rules of isRequired and minLength of 3. Below is the component that handles this:

If we click the submit button after filling the TextInput, the formSubmitHandler will console the formControls value like below

valid = true or false

The good thing is that we do not have to wait till the user click submit before we can know if the form input is valid or not. Since it is actually stored in the component state, so, therefore, we can use this to display error message or feedback when the user is typing. We can even disable the submit button until the validation passes.

Displaying error feedback

For us to be able to display error feedback on the input, we need to pass the touched and valid property for that particular input as a prop to it component. We will add the error style based on the valid status and we want to do this only when the input has been touched.

We also need to modify our TextInput component to display the style based on the value props.valid and props.touched.

Please note that you should have added the form-control and control-error style into the App.css.

You should see a screenshot like below if you TextInput is invalid and had been touched.

Disable Submit Button if the form is Invalid

Html 5 has a disabled property on button input, we can equate our formControls property valid status to the disabled property. As long as the formControls is not valid.

The disabled={!this.state.formControls.name.valid} will work fine if we have only one form control but if we need to handle more than one form control, we can set a new property to the state which will keep track of when the validity status of the whole formControl object. So we need to update our state to accommodate for this

We need to update the changeHandler method so we can loop through all form controls valid status, and when valid, update the formIsValid status to true.

With this setup, it will be easier for us to set the disabled property to formIsValid status, and this will handle one or more form object.

Considering other form input type

TEXTAREA: The textarea, email and password will work similar to a text input. We can create a TextArea component.

EMAIL: We can also create an Email component just like the TextInput

PASSWORD: We can also create a Password component just like the TextInput

The email, textarea and password form control will look similar to the text input form input

SELECT OPTION: The Select Option form control is slightly different to the other form control because we have to accommodate for the select options. It will look like to below

then the Select Option component will look like below

RADIO: The radio input is similar to the select option since it’s only one option that can be selected out of the available options, The form control will be similar to the select option form control. Below is how the radio button component looks like.

Putting it all together, Assuming we want to have an email input, name (TextInput), gender (Select Input), radio input all in a form control. Below is an example of what your component will look like

Thanks for reading.

Introducing ReactJs Terminologies With Next Generation Javascript

Agoi Abel Adeyemi — Sun, 15 Apr 2018 07:48:45 +0000

Let & Const

Use let for variable values, something you will assign and can always change at any point in time.

Use const if you want to create a constant value, something you will assign once and will never change.

Exports & Imports (Modules)

We can write our JavaScript files in “modules” and then reference them as dependencies in other scripts. This allow us to split our code into different concern based on functionalities. Each file can be called a module.

We need to use the export keyword if we are going to use a particular module within another module. The default keyword in the Person.js class below means that whenever we import Person from another class, the Person will just be the default export hence no need for {} in the import statement.

To use the above module within another module, we need to import it like below:

We can always export more than one module from a file, that was the reason why I didn’t use the default keyword, this will affect the way we will import the module and use within another class.

To use the above module within another modules, we need to import it like below and use the {} to the extract the particular export we need from the module since there is no default export.

Functions

There are two main ways to declare functions in javascript which are the function expression and the function declaration like below:

From the Let & Const lesson above, we can change the functionTwo variable declaration to const since I am sure my there will never be a reason for me to change the value of the function. Hence functionTwo can be declared like below:

Again, there is something called Arrow Function in javascript and the function above can be represented with arrow function like below:

If our function is going to receive parameters, we can represent it with the arrow function like below:

There are situations whereby all our function does is to return something without doing some computation or whatsoever. This can allow us use a shorter syntax like below:

An example of this within reactjs is with the use of a functional component to return just a JSX like below:

Classes

We can represent classes in javascript like below:

this.name is the class property and printMyName() is a class method. A class can also have inherit from another class like below:

An example of this within reactjs is with the use of a stateful component like below:

Introducing Component

A sample react component look similar to what we have below:

Remember, We imported React, {Component} and ‘./App.css’ because we need to use them inside the component, we also export the App because we are going to use it within another component. The App inherit from Component, this is common way of writing a stateful react component, unlike the functional component below. We won’t need to import {Component}.

A stateful component must have the render() method but a functional component does not have to.

A react component (stateful or functional) must always return an HTML like syntax to the dom called JSX.

That html been return within a react component is actually a JSX which is not just an HTML but an HTML with Javascript.

Introducing JSX

A sample JSX below:

The React.createElement() can take at least three parameters. The first been the parent element(i.e <div>), the second can represent an object which can contain styling(Note, we use classNameinstead of class within JSX). The third is the element or content that is going to be within the parent element. This can also be another React.createElement(). The above JSX will translate to:

<div class="App">
  <h1>I am a React App</h1>
</div>

Thanks to create-react-app. We can easily just write the above code like below

And It will be translated for us. That is the more reason why we have to import React from ‘react’, because there is going to be a translation to the previous way of writing it behind the scene.

Meanwhile, if we use create-react-app, The above will be translated for use hence we simple have to do below:

I feel Setting up webpack and scaffolding our own react setup is really something you should learn later after getting to understand reactjs better. Someone just getting into it should just use the create-react-app.

This is just my way of introducing ReactJs, thanks you for taking the time to read this article.

View Properties use by Auto Layout

Agoi Abel Adeyemi — Sun, 11 Feb 2018 07:26:54 +0000

Intrinsic content size, Compression Resistance Priority, Content Hugging Priority

There are some views that automatically size themselves base on the content they hold, This is referred to as their intrinsic content size. E.G A button’s intrinsic content size is the size of its title plus a small margin. Not all views have an intrinsic content size. For views that do, the intrinsic content size can define the view’s height, it’s width or both.

Let say we have a button with the text “Click Me”.

We definitely don’t want the button to be smaller than the text inside it, Otherwise the text would be clipped. This is know as Compression Resistance Priority.

The higher a view’s Compression Resistance Priority, the more the view resists growing larger than its intrinsic content size.

Still on the “Click Me” button, If we don’t want the button to be really bigger than the content inside it like the image below:

If we want the button to hug its content without too much padding, we have to increase the Content Hugging Priority.

The higher a view’s Content Hugging Priority is, the more the view resists growing larger than its intrinsic content size.

We can set the content hugging and compression resistance priority programmatically like below:

The two methods take two parameters which are the UILayoutPriority and the UILayoutConstraintAxis. The priority level can be required, defaultHigh, defaultLow, fittingSizeLevel where required is the highest and fittingSizeLevel is the lowest. The UILayoutConstraintAxis can either be a vertical or horizontal axis.

I will write another article on UIStackview, after which I will show ways to programmatically code different views. Thanks for reading.

Programmatically approach Auto Layout

Agoi Abel Adeyemi — Sun, 11 Feb 2018 07:21:06 +0000

Layout is the way in which the parts of something are arranged or laid out. When designing user interfaces in swift, we have to consider how the elements are arranged, and how it will be rearranged on different screen sizes. To layout user interfaces such that they can adapt to changes based on different screen sizes in swift, we have to use autolayout.

Auto layout simple means we describe the position where our interfaces should be, then the system will automatically position the interfaces for us.
Auto layout is a constraint base descriptive system whereby the relationship between two views can be represented as a linear equation

A1 = (M * A2) + C
where the A1 and A2 refer to views' attribute, 
M refer to multiplier and 
C refer to as a constant

A constraint allows us to establish a relationship between the attributes of a single view or to the attribute of another view.

What is an attribute?

An attribute is a position on a view’s alignment rectangle. In the equation above, A1 will be an attribute on view 1, and A2 will be an attribute on view 2. A view’s attribute(s) is use to establishes relationship with another view’s attributes. The first set of attributes correspond to the edges of the view’s alignment rectangle which are the top, bottom, right and left attributes.

The second set of attributes are the leading, trailing, left and right attributes.

The next set of attributes are the height and width, the height and width attributes allow us to create relationship with the height and width of our view or another view.

The next set are the CenterX and CenterY attributes which are use to align a view horizontal and vertical axis.

We also have the baseline attribute, first baseline and last baseline. The baseline is like an imaginary line where text sits on, if there are multiple baselines, the first one is the first baseline and the last is the last baseline.

Every view contain margins that allow you to modify how much space exists between the edges of the view and any subview added, the attributes that govern this relationship are mostly the top, right, bottom and left margin. In addition to the margin attributes, we also have the leading margin, trailing margin, centerX with margin, centerY with margin. We also have NotAnAttribute that allow us to not use constrain on other view named . This attributes are the options we can use when establishing relationship between views.

Type of relationship

Since we already know we have to use attributes to create relationship between two views, the next decision is the type of relationship that should exist between these views. There are three possible relationship that can exist between the views, but we can only use one at a time: Equal, Less than or equal and Greater than or equal.

Equal means the viewA’s particular attribute should be equal to viewB’s particular attribute.

Less than or equalmeans the viewA’s particular attribute should only be less than or equal to viewB’s particular attribute.

Greater than or equal means the viewA’s particular attribute should only be greater than or equal to viewB’s particular attribute.

Multiplier

The multiplier which is represented as M in the equation is use to multiply (adjust) the relation by a certain of floating point value. We can say viewA.height should be *2 (two times) of viewB.height.

Constant

The constant is use to offset a view away from another, it is basically use to create space between two views.

Adding Auto Layout in Code

We have three choices when it comes to programmatically creating constraints, you can use NSLayoutConstraint class, layout anchors, or you can use the Visual Format Language. We are going to use NSLayoutConstraint class and layout anchors.

The let horizontalConstraint = NSLayoutConstraint() is use to initialise a new constraint, where item: newValue is the element we want to add the constraint on, attribute: NSLayoutAttribute.centerX on line 4 tells us which attribute on the item in line 1 we wish to add the constraint on. The relatedBy: NSLayoutRelation.equal is use to tell the type of relationship, toItem: view is use to tell the other view’s attribute we want to establish the constraint with. In our case, it is the window view. attribute: NSLayoutAttribute.centerX on line 7 is use to tell the attribute on the other view we want to create the relationship with. Then the multiplier and the constant. Immediately after creating the constraints, we need to add the constraint(s) to the parent view which was done on line 12. We can use Layout anchor to repeat the same like below:

where newView.centerXAnchor is the view we want to add a centerXAnchor constraint that is equal to window view centerXAnchor.

If you do not understand some of the concept explained here yet, please be patient. I am writing another article on some view properties used by auto layout, then UIStackview, after which I will show ways to programmatically code different views.

Protocol in Swift with Practical Examples

Agoi Abel Adeyemi — Fri, 19 Jan 2018 12:20:29 +0000

A protocol defines a blueprint of methods, properties, and other requirements that suit a particular task or piece of functionality. The protocol can then be adopted by a class, structure, or enumeration to provide an actual implementation of those requirements. Any type that satisfies the requirements of a protocol is said to conform to that protocol.

So, keeping it simple, a protocol says a struct , class or enum that if you want to be THAT, do THIS, this and This. Example: if you want to be a developer, you have to READ, and WRITE CODE.

Protocol Creation and Adoption

We can create a Protocol like below:

protocol SomeProtocol { //protocol definition goes here}

Classes, structs, and enums can adopt these protocol by placing protocol’s name after the type’s name, separated by a colon, as part of their definition. Multiple protocols can be listed, and are separated by commas.

struct SomeStruct: FirstProtocol, SecondProtocol { //struct definition goes here}

If a class has a superclass, list the superclass name before any protocols it adopts, followed by a comma.

class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol { //class definition goes here}

Example one: Property Requirement

The above protocol simply says any class/struct/enum that want to adopt me must have a property called fullName which must be a type of String and the property must be a gettable property which was represented with { get }.

The First Implementation and Second Implementation both have a property called fullName, hence they both conform to the FullNameable protocol though they have different implementation of it. What our FullNameable protocol says is that we need to have a fullName property, it does not say how we should get this property. Wait, what then makes a property gettable?

A gettable property is a property we can only read from after we have given it an initial value.

When we try to assign a new value to the fullName property, it will fail simply because of the let keyword we used when initializing the Lecturer struct.

The reason for this example is to:

show how to use a protocol and conform to it
let us understand that classes that conform to a property does not have to have the same implementation.
Understand what { get } stands for

Example Two: Connecting Loose End Class

Let us assume we want to make a smoothie and the requirements needed to make the smoothie are Milk and Dairy products. The make a smoothie, we have to blend some fruits, as well as some Dairy. So we are going to need a blend method that all the classes that will make a smoothie must have, hence we have to enforce this by using protocol like below

To make the smoothie, we need to call the blend method on each classes that conform to the Blendable protocol and we can achieve

The makeSmoothie method will accept an array of classes that conform to the Blendable protocol, then use the for loop to access the blend method in each class. The application will throw an error if a class that does not conform to the Blendable protocol is passed in as an array.

The reason for this example is to:

show how to use method as protocol requirement
Understand how to access loose end class that conform to a protocol

Example Three: When to use a protocol

A problem is to decide when to use a protocol to class inheritance. The best cheat to determine when to use a protocol compare to class inheritance is to know when the type of relationship that determine between your classes. Is it an IS-A relationship or a HAS-A.

IS-A relationship is a type of relationship where a child will have every thing the parent has as well as have additional properties. A good example is an Airplane and a JetPlane. A JetPlane is basically an Airplane with additional properties / methods

HAS-A relationship is a type of relationship where two classes are not the same but share similar properties / method. A good example is a Bird and an Airplane. A Bird can fly as well as an Airplane. This is the best time to use a protocol.

The reason for this example is to:

show when to use protocol over class inheritance

Example Four: Protocol Inheritance

A protocol can inherit one or more other protocols and can add further requirements on top of the requirements it inherits. The syntax for protocol inheritance is similar to the syntax for class inheritance, but with the option to list multiple inherited protocols, separated by commas:

Any class/struct /enum that inherit the Pet protocol must conform to the Animal protocol as well because the Pet protocol inherit from the Animal protocol.

I am happy to share this article with you. If you’ve enjoyed this article, do show support by loving it . Thanks for your time and make sure to follow me or drop your comment below. You can read more about Protocol here👇
here

Enums in Swift with Real Life Examples

Agoi Abel Adeyemi — Tue, 16 Jan 2018 02:12:03 +0000

Introduction

Enumeration (Enum) defines a common type for a group of related values and enables you to work with those values in a type-safe way within your code.

Assuming we have a method named dayType that accept any day of the week then return Weekend for Saturday and Sunday, Weekday for Monday, Tuesday, Wednessday, Thursday and Friday and return This is not a valid date when it fails to recognised what was been passed into it. The function will work as aspected but what happens when you actually want to pass let say a friday but you mistakingly type fridaysy even though what we actually wanted to type was friday. The switch above goes to the default This is not a valid date. That is the type-safty enum brings into the table. It help us to avoid such risk by providing common type for group of related values like below:

We have been able to eliminate the use of String by defining an enum to hold the days. We don’t need to use the append the Day before every declaration of the day enum within the switch statement because we already assigned day to be a type of Day. Hence the dayType function can be reduce to below:

We have to understand enum is best suited for declaring types with finite sets of possible states, like Direction (north, south, west, east), Movement (Up, down, left, right) etc.

Enum Values

We can assign value to each enum case. This is useful if the enum itself indeed relates to something

We can access the value assigned to an enum with the rawValue keyword. To access the Week enum above, we can use Week.Monday.rawValue which will return Weekday.

Enum Associate Values

Associate values are a fantastic way of attaching additional information to an enum case. Say you’re writing a trade engine, there are two different possible trade types, Buy and Sell that will have a specific stock and amount. We can represent this using associate enum values like below

Enum Methods

We can also define methods on an enum like below

Notice the code snippet above, the func description will return "This is an apple device" for every case in the enum. To avoid this, we can make use of switch statement within the description method like below

I am happy to share this article with you. If you’ve enjoyed this article, do show support loving it 👏 . Thanks for your time and make sure to follow me or drop your comment below 👇

Optionals in Swift

Agoi Abel Adeyemi — Mon, 15 Jan 2018 18:45:44 +0000

Absent of Data

There are situations where we wish to accept data from users and also provide an opportunity for some of the data to be optionals, meaning they are not required but should be provided if available.

The constant me instance of a person provided all the data but the constant anotherPerson cannot provide all the data because he probably does not have a middlename. Hence he passed nil as the value of the middlename. Sounds cool right but the nil passed will cause an error, Why?, because we have not told swift to make the middlename optional.

What is an Optional in Swift?

An optional in Swift is a type that can hold either a value or no value. Optionals are written by appending a ?to any type:

var middlename: String?

The above means that middlename can either be a string or does not contain anything which is represented by the ?. An optional is a kind of container. An optional String is a container which might contain a string. An optional Int is a container which might contain an Int. Think of an optional as a kind of parcel. Before you open it (or “unwrap” in the language of optionals) you won’t know if it contains something or nothing. Its only an Optional value that can be set to nil, and that was the reason for the error when we passed the middlename a value of nil without specifying its a type of Optional.

var red: String = "Red"
red = nil // error: nil cannot be assigned to type 'String'

How to create an Optional?

The simplest way to create an optional in swift is to add ? in front of the type like below

var middlename: String?

Another way is using the Optional keyword like below

var middlename: Optional<String>

Using (unwraping) an optional

The simplest way to unwrap an optional is to add a !after the optional name.

Notice the \(middlename!), the ! there is use to unwrap the middlename so we can get the value “abel”. The problem is that when we passed a nil value to the middlename, we will get a runtime crash which says nil is Unexpected.

Before unwrapping, we need to be sure that there’s a value. So therefore we are going to continue the rest of the article with how to check before using (unwrapping) optionals.

Use If to Check for nil before force unwrapping:

Since it was nil that was passed to the variable when we initialized the Person struct, we can use an if statement to check for nil before unwrapping the Person struct like below

Whenever we use the ! symbol, it is denoted as force unwrapping the optional value, but it a common practice to avoid force unwrapping it, because we can write our code in such a way that swift will automatically unwrap it for us

Using Optional binding:

With optional binding, though we are still using if, swift provide a way for us to use the if let statement then automatically unwrap it for us like below

Using Guard for early exit:

Guard provide a way to quickly exit when checking for the optional string and make our code much more cleaner hence there wont be need for if else statement.

We have covered how to use optionals in swift, let us look at some cool secondary use cases of optionals which include using multiply optionals, method chaining and Nil Coalescing.

The streetName in the Street class is an optional string, the House class has a street variable which is also a Optional Street. The Person class too has a variable house which is an Optional house. When we have to access the person street. To access the person street (myStreet), we ain’t sure if the person gave us the house information (myHouse). That was the reason why we use the if let myHouse = Person.house. If the Person.houseis empty, the if statement will fail to execute, else the variable will be assigned to the myHouse property. Next, we have to access the myHouse.street and if its available, the variable will be assigned to the myStreet.

The pattern used to access the myStreet can be improved with the use of optional chaining like below:

I am happy to share this article with you. If you’ve enjoyed this article, do show support by loving it . Thanks for your time and make sure to follow me or drop your comment below 👇

Inheritance in Swift

Agoi Abel Adeyemi — Fri, 12 Jan 2018 08:24:29 +0000

A class can inherit methods, properties, and other characteristics from another class. When one class inherits from another, the inheriting class is known as a subclass, and the class it inherits from is known as its superclass. A class that does not inherit from another class is known as a base class.

The above code snippet shows how the someSubclass inherited from the someClass class. Classes in Swift can call and access methods and properties belonging to their superclass and can provide their own overriding versions of those methods and properties to refine or modify their behavior. Classes can also add property observers to inherited properties in order to be notified when the value of a property changes.

Accessing Superclass Properties and Methods

Assuming we have a base class named Person and a Youtuber class that inherit from the Person class

The first thing I want us to notice is the class Youtuber: Person{}. We simply said the Youtuber be a type of Person which make it inherit all the properties and method of the Person class.

Secondly, when we initialize the Subclass, we use the super.init() method to pass the parameters needed by the superclass constructor since a Youtuber is actually still a Person.

We can access the celebrateBirthday() method of the Person class from the Youtuber subclass like below

Overriding Methods

At times, the subclass might wish to override a method contained in a superclass. We will make use of the override keyword within the subclass like below:

I initialized the Person class as well as the Youtuber class, the celebrateBirthday method in the Person class will return a different value to the Youtuber class because of the override function that print a different content in the Youtuber class.

Overriding Properties

we have seen how to override methods in swift, but there are cases where we actually need to override properties.

Immediately after the super.init() in the inside init method, we set the country variable. Note that, we can only do this after we have initialize the superclass.

Preventing Override

We can prevent a method or property from been overridden by a subclass by using the keyword final func or final var.

There is more to inheritance like observers. Didn’t cover that here because am not pretty sure how to use it now. Will update this article when I fully understand the concept. Lemme go read up enum and optionals. Yes, will write about it when done.

_I am happy to share this article with you.

Structs and Classes in Swift — What, When and How

Agoi Abel Adeyemi — Thu, 11 Jan 2018 16:32:38 +0000

Structs and Classes are object oriented programming concept in swift, the main reason for using them is so you can more closely associate behaviours together. Assuming I have a dog, it must have a name, belongs to a breed and has an age. I can group this property of a dog using either a class or a structure like below:

The name, breed and age are the properties of a dog represented by the Struct above can also be represented using a class like below:

Struct and Class has a lot of similarities which include defining properties to store value, define methods to provide functionalities, define initializers to set up their initial state, can be extended to expand their functionality beyond a default implementation etc.

Instance of a Struct and Class

To access a struct, we have to call it and pass the default properties they need like below:

Struct automatically bind the properties which are the name, breed and age in our Dog Struct when we create a new instance of the Dog but we have to manually do that in classes by defining the init method.

Once we add properties to a class, we are require to define the init() method which in other languages represent the constructor() method but struct does that automatically for us.

Methods in Structs and Classes

We can declare functions within our class/struct. Functions within class/struct are called methods. In our dog object, we can define a method to get the dog’s details like below

Once we have declared our method, we can access them by creating an instance of them then we use the . notation to access the method name. We can access the Dog Struct or Class like below

Differences btw Structs and Classes

Though we have used the Struct and Class almost the same way but I need us to know that they are different to each other and there are use cases when we have to use one over the other. Lets outline the differences:

Struct is a value type while Classes are reference type.

A Value type is a type whose value is copied when it is assigned to a variable or constant, or when it is passed to a function.

A Reference type is not copied when assigned to a variable or constant, or when they are passed to a function. Rather than a copy, a reference to the same existing instance is used instead.

I will show some code snippet below to make you understand better

We created a new instance of Dog and called it dog1, and assign the dog1 instance to dog2 which means dog1 should be equal to dog2. We then changed the value of dog1 name to JaneDony. This automatically changes the name of dog2 too, since they are equals to each other and are reference type.

The struct example above act differently to the class in that after we made dog1 equal dog2. Whenever we change any value of either of dog1 or dog2, it will not cause a change on the other one. Hence dog1.name in the above code will not change when dog2 name changes.

Another major difference is that we can not use inheritance when we use struct but we can with class.

I am happy to share this article with you. If you’ve enjoyed this article, do show support by giving a few claps 👏 . Thanks for your time and make sure to follow me or drop your comment below 👇

Functions in Swift

Agoi Abel Adeyemi — Tue, 09 Jan 2018 10:40:46 +0000

Introduction

Functions are self-contained chunks of code that perform specific tasks.

Defining and Calling a Function

Right below is a simple function, that actually does nothing at the moment.

func emptyFunction() { //your code should go inside here}

The func keyword is use to define a function while the emptyFunction is the name given to the function. You must use the func anytime you create a function, and the function name can vary base on what the function will do.

The above function can be called within my code like below

emptyFunction()

Function Parameters

There are times when we need to pass parameters
to a function, we can pass parameters to a function like below

func functionWithParameter(parameterOne: Int) { 
    print("This is my parameter: \(parameter)") 
}

The paramterOne is the parameter passed into the function while the Int denote the data type of the parameter. The data type (Int)serves as a kind of contract that must be adhere to when we call the function meaning, the parameter must be a type of Int.We need to include the parameter we passed when calling the function like below

functionWithParameter(parameterOne: 32)

We can use more than one parameter in a function by separating the parameters with a comma

//declaring the function
functionWithParameters(parameterOne: Int, parameterTwo: String) {
}

//calling the function
functionWithParameters(parameterOne: 32, parameterTwo: "Hello")

Function Return Types

The return type is use to denote the data type of the value our function should return. Just like the parameter type, Xcode will enforce us to make sure that the function returns the type it specified.

func functionWithReturnType() -> String { 
    return "I must return a string"
}

There are many data types in swift which include Integer, Boolean, String, Float, Double. The -> String denotes that the function must return a type of String. Any function that does not return a value has a special return type named Void. When we do not specify a function return type, we have simply told swift that the return type is a void hence our function must not return anything.

//Different ways to declare Void

func noReturnType() { 
    //swift will automatically take this function as void 
    //hence we must not return anything
}

function returnWithReturnType() -> Void { 
    //same as above, but we declare the void ourselves
}

function returnWithReturnType() -> () { 
    //this is another way to declare void
}

Function With More Than One Return Value & Type

There are times when we need our function to return more than one value, We can do this in swift with the help of a tuple like below

//declaring the function
myFunction () -> (value1: Int, value2: String) {
    return (value1, value2)
}

//calling the function
let result = myFunction(value1: 12, value2: "Hello from me")

//we can access the return value like below
result.value1
result.value2

Function Parameter With Default Value

We can define a default value for any function parameter should in case we do not want to pass the value at all time

func someFunction(parameterWithDefault: Int = 32) {}

If we call the someFunction(parameterWithDefault: 50) and pass in a parameter of 50, it will override 32 which is the default value assigned to the function, we can also call the function without a parameter.

Function Parameter External And Local Name

There are times when we need to give our function an external and local name, mostly basically for readability. The external name is use to pass the parameter into the function while the internal name is use to access the parameter inside of the function.

func myFunction(havingValue value: Int) { 
    //we can access the havingValue parameter with value 
    print(value)
}

//calling the function
myFunction(havingValue: 50)

Notice that we use the havingValue to pass the parameter when we call the function but to access the parameter inside of the function, we use value.

Omitting Argument Labels

Each time we have called a function that has a parameter, we have been defining the parameter name like below

myFunction(label: Int) {}

//calling the function
myFunction(label: 32)

We can omit the label when calling the function by adding a _ as the function external name like below

myFunction(_ label: Int) {}

//calling the function without the label definition
myFunction(32)

There is more to function in swift than what I have covered here which is just an introduction to it. You can read more about swift function here on apple documentation

The “let” keyword in swift

Agoi Abel Adeyemi — Mon, 08 Jan 2018 08:12:05 +0000

In swift, we use the let keyword to declare a constant variable, a constant is a variable that once declared, the value can not be changed.

Declaring constants

We can declare a variable in swift like below:

let myAge: Int = 27

Notice the let keyword above, we use it to denote that myAge is a constant and should hold the integer 27. Unlike variable declared using the var keyword, we cannot change the value of a constant once it has been assigned.

A constant is very similar to a variable except it value cannot be changed when declared.

Summary

It’s important that you keep the following in mind. You can declare a constant with the let keyword, constant have the same properties as a variable (var) which include type annotation, naming convention etc., except once a value has been assigned, the value cannot be changed