Week-09

Aprendizagem

As excepções são levantadas utilizando-se objectos de classe Exception, através da evocação do método Kernel.raise().
A classe Exception define 2 métodos que informam com mais detalhe sobre a excepção:
- message() - retorna um objecto String com detalhes, numa forma mais human-readable, sobre o que correu mal.
- backtrace() - retorna um Array de Strings que representa o call stack no ponto em que a excepção foi levantada.
Existe uma hierarquia da Excepções Standard, que são classes derivadas da classe Exception. Por omissão, o método raise() cria um objecto de classe RuntimeError.
É possível definirem-se novas classes derivadas da classe Exception ou da classe StandardError - mais comum - para ter um tratamento mais específico no código.
O tratamento de excepções faz-se com blocos begin..rescue..end ou begin..rescue..else..end, sendo possível ter um stack de rescue para diferentes excepções.
Pode-se sempre assegurar uma determinada execução de código através do uso de blocos begin..rescue..ensure..end.
O método respond_to?() é usado em Duck Typing.
Os objectos, por omissão, são mutáveis. Podem, no entanto, passar a serem imutáveis através do método Object.freeze(). As classes são sempre mutáveis, ou seja, apenas as suas instâncias é que podem ficar imutáveis. Um objecto imutável tem as seguintes propriedades:
- são thread-safe, ou seja, não podem ser corrompidos por threads.
- tornam o “encapsulamento” mais fácil, pois outros objectos não podem alterar o seu estado.
- são boas hash-keys, visto os seus códigos de hash não serem alteráveis.

DuckTyping - Em Ruby “confia-se” mais nas capacidades de um objecto do que no tipo (classe) desse objecto. Por isso o termo Duck Typing refere-se ao tipo do objecto ser definido pelo que o objecto pode fazer em oposição ao que o objecto é. Ou seja, Duck Typing no Ruby é ter o foco nos métodos da classe em vez de ter o foco na própria classe.

Syntactic Sugar - os programadores usam o termo syntactic sugar para indicar regras especiais na linguagem que lhes permitem codificar de uma forma que não corresponde à forma habitual, mas que é mais fácil de ler e de entender.

Exercícios

Exercício 1

exercise-01.rb

=begin
In Lesson Read/Write Text files you had written a program that swapped the contents of two text files.
Modify that program to include exception handling.
=end
 
class UnexistantFileException < StandardError
end
class FileNotReadableException < StandardError
end
class FileNotWritableException < StandardError
end
 
def read_lines_from_file(file_name)
 
  raise UnexistantFileException  if !File.exists?(file_name)
  raise FileNotReadableException if !File.readable?(file_name)
 
  lines = []
  open(file_name, 'r') do | file_handler |
    lines = file_handler.readlines
  end
  return lines
 
end
 
def save_lines_to_file(file_name, lines)
 
  raise UnexistantFileException  if !File.exists?(file_name)
  raise FileNotWritableException if !File.writable?(file_name)
 
  open(file_name, 'w') do | file_handler |
    lines.each do | line |
      file_handler.puts line
    end
  end
 
end

As excepções são tão simples de usar que parecem ser muito básicas. No entanto, são muito flexíveis e poderosas, ao mesmo tempo que são práticas de usar. É realmente um bom exemplo de PLS - Principle of Least Surprise.
DuckTyping e SyntacticSugar são expoentes máximos do Ruby, face à maioria das linguagens.

Pontos Baixos

Esta secção regista o que considero serem os pontos baixos da linguagem Ruby quando comparada com outras linguagens que conheço.

Índice

Week-09

Aprendizagem

Exercícios

Exercício 1

Questionário

Referências

Considerações

Pontos Altos

Pontos Baixos