Ruby: mais flexibilidade do que Java / C #?

Question

Será que é que eu sou um novato aprender Ruby, ou ele realmente tem mais maneiras de escrever (o mesmo) coisas do que Java / C #? Além disso, se é mais flexível do que Java, existem características lingüísticas do Ruby que são geralmente não usado para confusão evitar?

Exemplos disso podem ser atribuição paralela e todas as diferentes maneiras de escrever Cordas, talvez?

Nota: Não estou pedindo uma comparação com Java / C # ... só esta questão da língua, por favor ...

Editar: Eu entendo que C #, Java e Ruby são fortemente digitado, e que só Ruby (como Python e outros) é digitado dinamicamente (enquanto Java / C # são de tipagem estática). Algumas das respostas dizem que as linguagens dinamicamente digitados são mais flexíveis. É este necessariamente verdade, e como isso afeta a sintaxe? Eu só estou perguntando sobre flexibilidade sintática.

(PHP também é digitado dinamicamente e ele faz não parece mais flexível do que Java / C #, tanto quanto eu vi. Mais uma vez, quero dizer, em termos de sintaxe, não em termos de implantação nem qualquer outro aspecto ...)

Answer 1

Eu não sei Java ou C #, mas eu deixe que o fato de que você pode redefinir como + trabalhos sobre os números falam por si.

Answer 2

Quanto a mim as características mais usadas em Ruby e ausentes em Java são códigos de blocos / lambdas / encerramentos.

Outra grande (mas talvez perigoso) recurso é aulas abertas - você pode mudar qualquer classe que você quiser - adicionar novo método, mudar de idade, etc. Você pode até adicionar método para determinado objeto, e não toda a classe:.)

Answer 3

Outra linguagem dinâmica que é bastante semelhante ao Ruby é Python. No entanto, no Zen de Python , uma das regras determina que " deve haver um, e apenas um, maneira de fazer alguma coisa". Este é um oposto para Ruby que permite tanto meta-programação que há essencialmente um número infinito de maneiras de fazer a mesma coisa.

Dito isto, a sua um tanto irônico que até Python 3.0 (aka: 3000) valores de string e unicode eram diferentes tipos. Enquanto isso faz sentido, as pessoas às vezes ficam em problemas onde eles estão convertendo entre os dois muito a realizar operações de texto.

Se você tem uma escolha, eu quase recomendo usar Python como sua introdução para linguagens dinâmicas. Não há nada de errado com Ruby, mas você pode achar que você vai correr em menos situações onde o caminho "certo" para fazer algo que não é totalmente óbvio.

Em resposta a PHP sendo digitado dinamicamente:

sistema de tipo do PHP é flexível, permitindo que os tipos sejam convertidos automaticamente com base em que contexto eles são usados. Isto realmente não faz tipos dinâmicos, em seguida, reais, no entanto. A linguagem em si é mais estático e não vai permitir que você adicionar atributos para objetos em tempo de execução, por exemplo (pelo menos, a última vez que verifiquei).

Python, e muito possivelmente Ruby, são, na verdade, fortemente digitado, o que significa que confiança pode fazer comparações de tipo, e não pode fazer truques PHP como a adição de cadeias numéricas para obter um número. linguagens dinâmicas verdadeiros também muitas vezes permitem a meta-classificando onde você pode ajustar o tipo de uma instância ou classe, ou adicionar atributos para tanto, tudo em tempo de execução.

Answer 4

Ruby é uma linguagem dinâmica. C # e Java são ambos tipagem estática linguagem com tipagem forte. C # no v4.0 irá adicionar recursos dinâmicos, mas até agora, Java e C # ter tido um paradigma completamente diferente e mais rigoroso do que linguagens dinâmicas como Ruby e Python.

Answer 5

Eu comentou sobre a resposta de RKJ acima sobre lambda de. Este código demonstra o exemplo que você pediu;

def abs(n); (n < 0) ? -n : n; end
def square(n); n * n; end
def average(x, y); (x + y) / 2; end

def fixed_point(x, point, process, test)
  return point if test.call(x, point)
  fixed_point(x, process.call(x, point), process, test)
end

def sqrt(n)
  process = lambda {|n,g| average g, (n/g) }
  test = lambda {|n,g| abs(square(g) - n) < 0.001} 
  fixed_point(n, 1.0, process, test)
end

O primeiro ponto a notar é que o método fixed_point lida com a idéia geral de aplicar progressivamente um processo com alguns dados até que passe um determinado teste. A função sqrt define o processo de encontrar uma raiz quadrada e o teste para determinar quando estamos a ser satisfeito. são então passados ??estes 'procedimentos', tal como qualquer outra forma de dados para que fixed_point pode trabalhar a sua magia.

Em vez de armazenar temporariamente o processo e testar a coisa toda poderia ser anônimo. Poderíamos reescrever sqrt como;

def sqrt(n)
  fixed_point( n, 1.0, 
      lambda {|n,g| average g, (n/g)},
      lambda {|n,g| abs(square(g) - n) < 0.001} )
end

Sem esta capacidade, eu teria que definir tanto o processo como o teste como funções individuais e criar uma função sqrt_fixed_point especial para chamá-los. Tanto quanto eu estou ciente Java pode fazer algo semelhante usando Functores mas eu não sei o suficiente para comentário. O consenso que já vi em blogs ou similar é que Java faz isso tão terrivelmente complicado que você vai ter uma hemorragia nasal apenas tentando-o.

Claro, outra opção que Ruby dá é metaprogramming. Eu poderia reescrever sqrt para que ele reescreve (on the fly) fixed_point usando o processo e teste correto, mas isso provavelmente é um abuso do recurso: -)

ps. O link JoelOnSoftware é publicado merece repetir; http://www.joelonsoftware.com/items/2006/08/01. html

Answer 6

Todos os idiomas tipagem dinâmica (como Ruby) geralmente são mais flexíveis do que os de tipagem estática (como Java). Você não tem que lutar com o sistema de tipos, que muitas vezes você acaba fazendo em linguagens de tipagem estática.