DEV Community: Ishaan Bedi

Understanding Strings in Swift

Ishaan Bedi — Tue, 15 Feb 2022 15:55:05 +0000

In this article, we'll be looking at the concept of Strings in Swift.

Strings, as the name suggests, are a thread/collection of characters, woven together to form a word or a sentence.

To initialize a string in Swift, we enclose the word or the sentence inside double-quotes. We may initialize string either as a variable or a constant, depending upon our need.

Example:

let myName = "Ishaan"

In this code snippet, we have declared a constant myName and we have stored a string value of "Ishaan" in it.

Easy, as it gets :)

Multiline strings in Swift

What if we want to store a poem or some text where we have to use multiple lines. The first syntax you'll guess in your mind would be something like this:

let myPoem = "Hello,
We haven't talked in quite some time
I know
I haven't been the best
Of sons, hello, I've been traveling in the desert of my mind
And I Haven't found a drop"

But this is the wrong syntax and Swift will raise an error while compiling the code.

As you can see, Swift did not compile our code and showed us errors.

The solution to this problem is to wrap our string inside three double-quotes instead of using double-quotes one time.

let myPoem = 
""""
Hello,
We haven't talked in quite some time
I know
I haven't been the best
Of sons, hello, I've been traveling in the desert of my mind
And I Haven't found a drop
"""

Now, this is the perfect syntax and we have successfully created a multi-line string in Swift.

And we can see that Swift compiled our code without any error this time.

Including a double quote in our string

What if we want to include double quotes inside our string, for example, we have to store a conversation inside our string.

If we use our familiar syntax by wrapping our double quotes inside double quotes, Swift will get confused about which double quote is wrapping whom (too much confusion, I know). As you can see from the following screenshot as well that our program has not been compiled.

Let's get it sorted:

To get double quotes inside our string, just put a backslash before the double quote inside the string, and you are good to go. As you can see from the above code snippet, we can see that after introducing backslash before double quotes, our program has successfully compiled and is working as per our satisfaction.

String interpolation in Swift

The next crucial part in understanding strings in Swift is understanding the concept of String Interpolation

To interpolate a variable or a constant inside a string, we use a backslash followed by a variable or a constant wrapped inside a pair of parenthesis, and it's done.

Let's look at the following code snippet to understand better.

As you can see, we have interpolated strings inside a variable myDetails by including the constant myName & the variable myAge in it.

We can insert any kind of raw Swift code inside \( ), be it be calculations, values of any kind of data type, or a reference from another variable/constant. You may see below code snippets as an example for this concept:

So, that's all for this article. Hope you've got a deep understanding of strings in Swift. We'll be looking at some advanced string methods and operations in an upcoming article.

Thank you for reading this far.

Check out more at ishaanbedi.me

Understanding Constants in Swift

Ishaan Bedi — Fri, 04 Feb 2022 06:21:47 +0000

In today's article, we'll be looking at the concept of Constants in Swift.

I have already posted an article on Variables in Swift, check it out here.

Just like variables, the concept of constants is also very easy to understand and implement.

Let's dive deeper and understand constants in-depth:

What are constants?

Just like its name, constants are something that remains constant throughout the program!

Once a value is declared as a constant in the memory, its value cannot be changed throughout the execution of your program or application.

How to initialize a constant?

To declare a constant, we use the let keyword, followed by the name we want to give to that particular constant and assign it to any kind of data type we want to be constant throughout the execution of the program.

It's just like initializing a variable, but replacing the var with the let keyword.

We can store any kind of data type as a constant, whether it may be an integer, float, double, string, boolean, etc.

Let's look at an example:

let myName = "Ishaan"

According to this code snippet, we declare a new constant called myName that stores the string ' Ishaan'.

Do remember to use the keyword let, otherwise, your program will generate an error.

Now, myName, a constant has a value of 'Ishaan' in the memory, which will remain constant throughout the flow of our program.

You may try implementing this on your own on a Swift Playground or some other compiler and explore new concepts and errors.

Now, if we try to change the value of the constant myName, Swift will show us an error, as shown in the image below:

In the second attempt of initialization, Swift throws an error that it cannot assign myName to a new value as it is a constant.

It also shows us a hint to solve this problem by replacing let with var. In other words, it's asking us to declare myName as a variable if we need to change its value at any point of time, later in the program.

Some examples with other data types:

let isAdult = true
print(isAdult)

In this example, we store a boolean value as a constant in isAdult and then we print it. As expected, we will get true as the output.

let myNumber = 13
print(myNumber)

In this example, we store an integral value of 13 as a constant in myNumber and then we print it. As expected, we will get 13 as the output.

let mathScore = 98.5
print(mathScore)

In this example, we store a floating value of 98.5 as a constant in mathScore and then we print it. As expected, we will get 98.5 as the output.

Good to know: Just like a variable, we can also explicitly declare a constant's data type to define what kind of data we want it to store in it.

let mathScore:Int
mathScore = 100
print(mathScore)

Here, we are explicitly telling the compiler to make sure that the constant mathScore stores an integer value only, though only one time we'll be doing it (anywhere in the program).

You may avoid explicitly declaring data type unless it's absolutely necessary.

So that's all for this article. You now have a deep understanding of constants in Swift. Hope you have understood what I wanted to convey.

Thank you for reading this far.

Check out more at ishaanbedi.me

Understanding Variables in Swift

Ishaan Bedi — Mon, 31 Jan 2022 05:28:53 +0000

In today's article, we'll be looking at the concept of variables in Swift.

Variables, in any programming language, is the concept that a programmer learns about in the initial days of learning that language, and understanding it is an important part of gaining a solid grip over that particular language.

Talking about variables in Swift, the concept of variables is very easy to understand and implement.

Let's dive deeper and understand variables in depth.

What are variables?

As the name suggests, variables are something that can vary.

A variable refers to a storage location we reserve in the computer’s memory for some data or value to store that we can change freely & manipulate as per our program's requirements.

How to initialize a variable?

To declare a variable, we use the var keyword, followed by the name we want to give to that particular variable and assign it to something we want this particular variable to store in the memory.

We can store any kind of data type as a variable, whether it may be an integer, float, double, string, boolean, etc.

Let's look at an example:

var myNumber = 13

According to this code snippet, we declare a new variable called myNumber that stores the integer value of 13.

Do remember to use the keyword var, otherwise, your program will generate an error.

Now, myNumber, a variable has a value of 13 in the memory.

You may try implementing this on your own on a Swift Playground or some other compiler.

We can perform any kind of operations on this variable like mathematical calculations, building & solving logic, implementing algorithms, etc, just thinking of it as a substitute for the integer 13.

And as we discussed above, we can change or manipulate this value.

myNumber = 26

No need to use the var keyword again as we are trying to modify an existing variable that is already declared earlier.

Now the variable myNumber has the value of integer 26 in the memory.

As you can see, after reassigning the variable to 26, the second print(myNumber) statement prints out 26 in the console.

IMPORTANT NOTE

If we are reassigning the variable to a new value, the new value should be of the same data type of which the variable was earlier declared for:

var myAge = 18

myAge = 19

The above code snippet is valid in the Swift program as we are reassigning an integer 19 to the variable, which was earlier initialized with a value of integer 18. The data type at both times of initialization was an integer, making this program valid.

Whereas in the following code snippet, an error will be generated:

var myAge = 18

myAge = "eighteen"

As you can see, the Swift compiler shows us an error that it cannot assign a variable of type string to a variable that was earlier assigned an integral value.

Keep this in mind, and you are good to go :)

Some examples with other data types:

var name = "John Doe"
print(name)

In this example, we store a variable of type string "John Doe" in the variable name and then we print it.

var isAdult = false

var isStudent = true

In this example, we initialize two variables and store a boolean value in them.

var myScore = 9.4

In this example, we store a floating value in the variable myScore.

You may try more examples on your own by storing and experimenting with other data types.

Good to know: We can explicitly declare a variable's data type to define what kind of data we want it to store in it.

Example:

var myAge:Int
myAge = 18

Here, we are explicitly telling the compiler to make sure that the variablemyAge always stores an integer value only.

So now you also have an idea of explicitly declaring the data type of a variable.

Since we already know that if we directly initialize a variable to some data type, it'll always store that kind of data type only in future re-assignments, you may avoid explicitly declaring data type unless it's absolutely necessary.

So that's all for this article. You now have a deep understanding of variables in Swift. Hope you have understood what I wanted to convey.

Thank you for reading this far.

Check out more at ishaanbedi.me

Remove Duplicate Elements From An Array With Just a Single Line Of Code!

Ishaan Bedi — Fri, 28 Jan 2022 05:55:25 +0000

In today's article, we'll be looking at a super simple trick that can be used to remove duplicate elements from an array in Javascript.

With the help of this trick, you can delete the duplicate elements from an array without the use of loops or other complex operations.

We'll be using the concept of Sets in Javascript to achieve this.

So let's start...

We start with initializing a new example array, on which we’ll perform the operation to remove duplicate elements.

var arr = [1,2,2,3,3,3,4,4,4,4,5,5,5,5,5];

In this example array, we have duplicate integers (as many times as their value). We want to remove duplicate elements from this array and our updated array should look like this:

[1, 2, 3, 4, 5]

Now to remove duplicate elements, the simplest part, we use a combination of arrays’ spread operator (to spread the elements of the array) along with creating a new Set which will allow us to store only the unique elements from the array.

        arr = [... new Set(arr)];

This re-initializes the variable arr with the non-duplicate elements, just like the way we want.

Arr -> [1, 2, 3, 4, 5]

If you want to retain the original array, you may declare a new variable that stores the non-duplicate elements array from the original array.

Ex.

var arr = [1, 2, 2, 3, 3, 3];
var newArr = [... new Set(arr)];

Through this way, we get a new array with no duplicate elements, and we also have our original array, which we might need later.

Arr -> [1, 2, 2, 3, 3, 3]

newArr -> [1, 2, 3]

Not only integers, but we can use this concept for any data type. Let’s take an example with elements of type String.

var stringArray = ['a', 'b', 'b', 'c', 'd', 'd', 'd', 'e', 'e', 'f'];

Now, using the same concept as discussed above, we use

stringArray = [... new Set(stringArray)];

And, as you guessed, the output after removing all the duplicate elements from the array is


["a", "b", "c", "d", "e", "f"]

The last example we take is with an array of boolean values.

var boolArray = [true,true,false,false,true,false];

Applying the same concept, we use:

boolArray = [... new Set(boolArray)];

And as expected, we have the boolArray with only two elements, ie,

[true, false]

The final key point:

The Set() constructor lets us create Set Objects that lets us store the unique value of any data type.

Thank you for reading this far. Check out more at www.ishaanbedi.me