## Ruby Simplified Part 4: Ruby Loops

Let’s look at some Ruby loop constructs: for, while, and until.

```# .Each loop
x = 10
x.times do |i|
puts "#{i}"    # Starts at 0, ends at 9
end

# For loop
for i in 0..10 do  # Needs a range
puts "#{i}"    # Starts at 0, ends at 10
end

# While loop
x = 0
while x < 10
puts "#{x}"    # Starts at 0, ends at 9
x += 1
end

# Until loop
x = 0
until x >= 10 do
puts "#{x}"    # Starts at 0, ends at 9
x += 1
end```

Ruby also supports break and next, these are equivalent to break and continue in C#.

```# Break
for i in 0..10
if i > 5
break      # Terminate the most internal loop
end
puts "#{i}"    # Will print 0 1 2 3 4 5
end

# Next
for i in 0..10
if i < 5
next
end
puts "#{i}"    # Will print 5 6 7 8 9 10
end```

## Ruby Simplified Part 3: Ruby conditional statements

Let’s look at some conditional statements in Ruby, if-else, case, and unless.

```=begin
A simple program to test user input,
notice that this comment is multiline
=end

# If-Else statement
x = gets        # Get user input
x = x.chomp     # Chop off the '\n' at the end
x = x.to_i      # convert the string into an integer

if (x < 0)
puts "user input " + x.to_s + " is negative"    # convert integer into string with .to_s
elsif (x == 0)
puts "user input " + x.to_s + " is zero"
else
puts "user input " + x.to_s + " is positive"
end

# The 'if' modifier
puts "Writes this line only if x is 1" if x == 1

# Case statement
x = gets.chomp.to_i     # Notice how we shorten the operations

case
when x < 0
puts "user input " + x.to_s + " is negative"
when x == 0
puts "user input " + x.to_s + " is zero"
when x > 0
puts "user input " + x.to_s + " is positive"
end

# Unless statement
x = gets.chomp.to_i

unless x > 0        # The equivalent of 'unless' is the if(!...) in C#
unless x == 0
puts "user input " + x.to_s + " is negative"
else
puts "user input " + x.to_s + " is zero"
end
else
puts "user input " + x.to_s + " is positive"
end

# Unless conditional
puts "Write this line unless x is 0, meaning, if x is 0 then don’t write this line" unless x == 0

# Anything inside 'BEGIN' is called before the program is run
BEGIN { puts "Simple program to test user input." }

# Anything inside 'END' is called after the program is run
END { puts "All done!" }```

## Ruby Simplified Part 2: Major language features

Some features of the Ruby programming language, comparing them with C#,

1. Ruby is a dynamically typed programming language.
C# got dynamic extensions to the language in C# 4.0

2. Ruby is open source. Not only is it free of charge, but also free to use, copy, modify, and distribute.
C# is not open source, for an open source implementation of the ECMA standards for C#, see the Mono Project.

3. Ruby was designed as an interpreted language. The first Ruby interpreter (MRI) was written in C and was a single pass interpreter. The current official interpreter (YARV), however, compiles Ruby into something called ‘YARV Instruction Sequence’, which is then compiled just-in-time (JIT) to assembly language. There are several other implementations of Ruby (ex., JRuby, IronRuby, and MacRuby) which also compile the Ruby code in a two step process to machine language.
C# also has a two-step process, it’s first compiled into an intermediate language (IL) by the C# compiler and then JIT compiled to machine language by the CLR.

4. Ruby is a pure object oriented language. In Ruby everything is an object. You can append .class to anything to get the class name. Type puts 1.class (you’ll get ‘Fixnum’).
In C#, not everything is a object (numbers, structs, etc.)

5. Ruby has automatic memory management.
C# also has a full fledged garbage collector.

6. Ruby supports single inheritance only. Although we’ll see how to implement multiple inheritance using modules/mixins.
C# also supports single inheritance only. Multiple inheritance in C# is implemented using interfaces.

7. Ruby has modern exception handling features (using begin-rescue-ensure).
C# equivalent of this is the try-catch-finally blocks.

## Ruby Simplified Part 1: Installing Ruby on Windows

Install the current version of Ruby using the Ruby Installer. During installing choose the options below, and finish the installation process.

Now if you go to the C:\Ruby folder, you’ll see,

Open up a command prompt, and type ruby –v,

We’ve successfully installed the current version! To get help with more Ruby commands use ruby –h.

Now let’s try out “Hello World” in Ruby. Type ‘irb’ at the command prompt to get the Interactive Ruby Shell – it’s a command line for Ruby. Then use puts to output a string.

To run a ruby file, create a file ‘hello.rb’,

Now execute the file with ruby hello.rb,

## Ruby Simplified Series

Ruby has become a very popular programming language because of it’s simplicity and productivity. In this series we’ll explore some of the syntax and features of the Ruby programming language.

Ruby Simplified Part 1: Installing Ruby on Windows

Ruby Simplified Part 2: Major language features

## Powershell Simplified Part 9: Powershell Tips

Some Powershell tips and tricks to make your life easier,

1. Working with write-host,

```write-host "starting " –nonewline          # don't add a new line after the string
write-host "iexplore.exe" -foregroundcolor red -backgroundcolor yellow  # change text color
write-host "`nIs a new line`n"             # `n is a new line
write-host "`tIs a tab"                    # `t is a tab
write-host ("{0} : {1}" -f "formatting a string", "works!")    # format a string
write-host "this is a double-quote `""
write-host "this is a single-quote '" ```

2. Powershell also has an equivalent of C#’s string literal, called here-string,

```\$a = @"
This can have any char: ``~!@#\$%^&*()_+{}|\;'"<>?[]/     # note that ` needs to be escaped with another `
"@
write-host \$a```

3. To get the current script name,

```write-host \$MyInvocation.MyCommand.Name         # get current script name
write-host \$MyInvocation.MyCommand.Definition   # get current script full directory ```

4. Sometimes we need to suppress a Powershell cmd output,

```\$path = "c:\program files\internet explorer\signup\test"
new-item \$path -itemtype directory              # will output some extra information to stdout

# to suppress the output, try one of these,
new-item \$path -itemtype directory > \$null      # preferred way
new-item \$path -itemtype directory | out-null
\$null = new-item \$path -itemtype directory
[void] (new-item \$path -itemtype directory)```

5. Strings and variable/expression expansions,

```\$a = "test"
write-host 'this is a \$a'            # single-quote won't expand the variable
write-host "this is a \$a"            # only double-quotes will process variable substitutions

\$file = get-item \$env:windir\explorer.exe
write-host "file version: \$file.versioninfo.productversion"        # variables get expanded in strings not property expressions
write-host "file version: \$(\$file.versioninfo.productversion)"     # use \$() for expression expansion ```

6. Getting keyboard input,

```write-host "Press any key to continue ..."
write-host "Pressed \$(\$x.character)"
switch(\$x.virtualkeycode) {           # for special keys, map the virtualkeycode,
13 { write-host "Enter" }
16 { write-host "Shift" }
}```

7. We can add custom C# types to Powershell using add-type. However add-type has a limitation that once you load an assembly into a .NET application, the types it contains are not released until the application shuts down, so running the sample below again will result in “Add-Type : Cannot add type. The type name ‘myClass’ already exists.

```add-type -typedefinition @"
using System;
public class myClass {
private string _test = "He said: ";
private static string test = "She said: ";

public string Test {
get { return this._test; }
set { this._test = value; }
}

public string DoSomething(string str) {
return this.Test + str;
}

public static string DoSomethingElse(string str) {
return test + str;
}
}
"@

[myClass]::DoSomethingElse("test")   # invoke the static method
\$a = new-object myClass
\$a.DoSomething("test")               # invoke the instance method```

## Powershell Simplified Part 8: Accessing the File System

With Powershell you can manipulate the file system easily,

```\$path = "c:\program files\internet explorer"

# get all the files in a folder and subfolders
\$dlls = get-childitem \$path -recurse

# filter based on file extension
\$dlls = get-childitem \$path -filter *.dll -recurse

# count the total number of files
\$count = (get-childitem \$path -filter *.dll -recurse).count

# for multiple filders use 'include' and 'exclude'
\$dlls = get-childitem \$path -include *.dll, *.exe -recurse

# filder based on other criteria
\$dlls = get-childitem \$path -filter *.dll -recurse | where-object { \$_.length -gt 150KB }

foreach (\$dll in \$dlls) { write-host \$dll }```

Use the PSIsContainer to determine if a directory item is a file or a subdirectory.

```# find subdirs only
\$dirs = get-childitem \$path -recurse | where-object { \$_.PSIsContainer }

# find files only
\$files = get-childitem \$path -recurse | where-object { \$_.PSIsContainer -eq \$false}```

We can get detailed information about a file,

```get-item \$env:windir\explorer.exe | select-object *   # view individual file properties
\$file = get-item \$env:windir\explorer.exe             # get individual file properties
write-host \$file.versioninfo.productversion```

Now let’s do some basic file/folder operations,

```\$path = "c:\program files\internet explorer\signup\test"

# check if a directory exists
if (-not (test-path \$path)) { write-host "Invalid path" }

# create a directory
new-item \$path -itemtype directory

# create a file
\$filepath = [System.IO.Path]::Combine(\$path, "test.txt")
new-item \$filepath -itemtype file

# write to the file

\$content = get-content \$filepath
write-host \$content

# rename the file
rename-item \$filepath "test.xml"

# change a file property
\$filepath = [System.IO.Path]::Combine(\$path, "test.xml")
\$file = get-item \$filepath