How to be polyglot programmer? - Part 2

It has been many days since I posted any article and was thinking to continuing this series. So here it is. I discussed about Variables and Primitive types in my previous article. If you haven't already read it do check it out here. In this article we will discuss about keywords and loops in different programming languages.

So, let us begin.

Keywords

Before going into keywords of different programming languages, what are keywords? To put in simple terms

They are reserved keywords in any programming language which are used by compiler, interpreters or transpilers to determine what operation to perform.

Example of most common keywords are for, const, var, let, while are few among many.

All programming languages have some common way of declaring variables. Most of them uses common keywords like int, char, double, float and also variable modifiers like signed, unsigned etc. More explanation about them in my previous article. Even for declaring constants they use common keyword const.

Also they use similar keywords for loops and might differ in function declaration and user defined type declaration for which I will have dedicated sections.

There is not much to talk about keywords as a common as when you will work with a programming language you easily come to know about them.

Lets move to loops:

Loops

Loops are sequence of code that repeats a task a given number of time until and unless exit/break conditions are met.

Taking a very very very very basic example of printing your name 10 times, you can do it with print (function or operator that outputs to stdout) statement of a given language or you can use loops. Here I will do the same as an example to printing hashnode name 10 times in different languages and show similarity between them.

For a basic loop most languages have common for loop syntax

For loop

These loops are used when you know how many times your loop will run

// common syntax
for (initialization; condition; increment/decrement) {
  // body
}

C/C++/Java

for (int a = 0; i < 10; i++) {
  printf("%s", "Hashnode"); // <-- for C
  std::cout << "Hashnode"; // <-- for C++
  System.out.println("Hashnode"); // <-- Java
}

Python

for x in range(10):
  print("Hashnode") # <-- python 3 syntax

Javascript/Typescript/Dart

for (var i = 0; i < 10; i++) {
  console.log("Hashnode"); // <-- for Javascript and Typescript
  print("Hashnode"); // <-- for Dart
}

Typescript with Type def

for (i: int = 0; i < 10; i++) {
  console.log("Hashnode");
}

Kotlin

for (x in  0..10) {
  println("Hashnode")
}

Golang

for i: = 0; i < 10; i++ {
  fmt.Println("Hashnode")
}

Rust/Swift

for x in  0..10 {
  println!("Hashnode"); // <-- for Rust
  print("Hashnode") // <-- for Swift
}

While loop

These loops are used when you don't know before hand how many times your loop will run

// common syntax
while (condition) {
  // body
}

C/C++/Java/Kotlin/Javascript/Typescript/Dart/Rust/Swift

int i = 0; // <-- declaration depends on language
while (i < 10) {
  printf("%s", "Hashnode"); // <-- for C
  std::cout << "Hashnode"; // <-- for C++
  System.out.println("Hashnode"); // <-- Java
  console.log("Hashnode"); // <-- for Javascript/Typescript
  print("Hashnode"); // <-- for Dart
  println("Hashnode"); // <-- for Kotlin
  println!("Hashnode"); // <-- for Rust
  print("Hashnode") // <-- for Swift
  i++;
}

Python

i = 0
while i < 10:
  print("Hashnode") # <-- python 3 syntax
  i += 1

Golang

i := 0
for i < 10 {
  fmt.Println("Hashnode")
  i++
}

Do while

do-while statements works in same way as while loops with a difference that it will execute once and then check for condition, thats the reason why condition is written at end.

These types of loop is used where you know that one time loop will surely run but after that it needs to check condition to know it should continue or exit.

// common syntax
do/repeat/loop {  // <-- different keywords
  // body
} while/until (condition) // <-- different keywords

C/C++/Java/Kotlin/Javascript/Typescript/Dart

int i = 0 // <-- declaration depends on language
do {
  printf("%s", "Hashnode"); // <-- for C
  std::cout << "Hashnode"; // <-- for C++
  System.out.println("Hashnode"); // <-- for Java
  println("Hashnode") // <-- for Kotlin
  console.log("Hashnode"); // <-- Javascript/Typescript
  print("Hashnode");
  i++
} while(i < 10);

Python, Golang, Rust and Swift don't have do-while loops in language but you can built on like as follows:

Python

i = 0
while True:
  print("Hashnode")
  i += 1
  if i > 9:
    break

Golang

i := 0
for ok := true; ok; ok = (i < 10) {
  fmt.Println("Hashnode")
  i++
}
// or
i := 0
for {
  fmt.Println("Hashnode")
  i++
  if !(i < 10) {
    break
  }
}

Rust

let i = 0
loop {
  println!("Hashnode");
  i++;
  if (i > 9) break;
}

Swift

var i = 0
repeat {
  print("Hashnode")
  i++
} while (i < 10)

So as you can see there are many similarities between different programming languages in looping where most of them share common syntax in while and do-while while some have different kind of declaring do-while where others do even have do-while loop but you can easily build them. for loops are also similar in most of the languages with some sugar syntax above them.

Funtional languages

When it comes to Functional programming languages syntax is different and mainly loop are concept of Procedural/Imperative programming languages while Functional programming languages they have recursion.

Haskell

printStringNTimes 0 = return ()
printStringNTimes n =
 do
  putStrLn "Hashnode"
  printStringNTimes (n-1)

main = printStringNTimes 10

Elixir

Enum.each(0..10, fn(x) ->
  IO.puts "Hashnode"
end)

Explaining funtional languages will need its own article as its different in concept and in syntax will surely conver functional language in future article.

Next we will look at conditionals.

Hope you like the article.

Happy learning, Happy coding!

No Comments Yet