-
Notifications
You must be signed in to change notification settings - Fork 11
/
Copy pathnumeros-em-ruby.html
239 lines (226 loc) · 11.8 KB
/
numeros-em-ruby.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en-us">
<head>
<meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>Números em Ruby</title>
<meta name="author" content="" />
<!--- Blueprint CSS Framework -->
<link rel="stylesheet" href="css/blueprint/screen.css" type="text/css" media="screen, projection">
<link rel="stylesheet" href="css/blueprint/print.css" type="text/css" media="print">
<!--[if IE]>
<link rel="stylesheet" href="css/blueprint/ie.css" type="text/css" media="screen, projection">
<![endif]-->
<!-- CodeRay syntax highlighting CSS -->
<link rel="stylesheet" href="css/coderay.css" type="text/css" />
<!-- Homepage CSS -->
<link rel="stylesheet" href="css/site.css" type="text/css" media="screen, projection" />
</head>
<body>
<div class="container">
<div class="column span-22 prepend-1 append-1 first last" id="header">
<h1 class="title"><a href="index.html" alt="voltar para o início">Tutorial de Ruby do GURU-SP</a></h1>
<hr>
</div>
<div class="column span-17 prepend-1 first">
<p class="title">Números em Ruby</p>
<p>Vamos brincar com números. Em Ruby, números sem pontos decimais são chamados inteiros (integers), e números com pontos decimais são geralmente chamados de números em ponto flutuante (floating-point numbers) ou, mais simples, floats (você deve inserir pelo menos um dígito depois do ponto decimal). Um literal inteiro é uma sequência simples de dígitos ex.: 0, 123, 123456789. Underscores podem ser inseridos em literais inteiros (embora não no começo ou no final), e essa característica é utilizada algumas vezes como separador de casa de milhar ex. 1_000_000_000. Caracteres do tip ounderscore são ignorados no dígito de string. Aqui está o programa <strong>p002numerosruby.rb</strong></p>
<div class="CodeRay">
<pre><span class="no"> 1</span> <span class="c"># p002numerosruby.rb</span>
<span class="no"> 2</span> <span class="c">=begin
<span class="no"> 3</span> Números Ruby
<span class="no"> 4</span> Operadores comuns:
<span class="no"> 5</span> + adição
<span class="no"> 6</span> - subtração
<span class="no"> 7</span> * multiplicação
<span class="no"> 8</span> / divisão
<span class="no"> 9</span> =end</span>
<span class="no"><strong>10</strong></span>
<span class="no">11</span> puts <span class="i">1</span> + <span class="i">2</span>
<span class="no">12</span> puts <span class="i">2</span> * <span class="i">3</span>
<span class="no">13</span> <span class="c"># Divisão de inteiros</span>
<span class="no">14</span> <span class="c"># Quando você faz um cálculo aritmético com inteiros,</span>
<span class="no">15</span> <span class="c"># você receberá uma resposta em inteiros</span>
<span class="no">16</span> puts <span class="i">3</span> / <span class="i">2</span>
<span class="no">17</span> puts <span class="i">10</span> - <span class="i">11</span>
<span class="no">18</span> puts <span class="fl">1.5</span> / <span class="fl">2.6</span>
</pre>
</div>
<div class='box'>
<p>Inteiros Ruby são objetos da classe <strong>Fixnum</strong> ou <strong>Bignum</strong>. As classes <strong>Fixnum</strong> e <strong>Bignum</strong> representam inteiros de diferentes tamanhos. Ambas as classes descendem de <strong>Integer</strong> (e, sendo assim, de <strong>Numeric</strong>). Os números em ponto flutuantes são objetos da classe <strong>Float</strong>, correspondendo a arquitetura nativa do tipo de dados double. As classes <strong>Complex</strong>, <strong>BigDecimal</strong> e <strong>Rational</strong> não são embutidas no Ruby mas são distribuídas com ele como parte das bibliotecas padrões. Nós falaremos sobre classes em detalhes mais tarde.</p>
</div>
<p>A hierarquia das classes (cortesia: <a href="http://www.cs.mun.ca/%7Edonald">Donald Craig</a>) é como a mostrada na figura abaixo:</p>
<p><img src="images/hierarquia_classes.gif" alt="" /></p>
<h2>Operadores e precedência</h2>
<p>Vamos dar uma olhada nos operadores do Ruby (cortesia: Dave Thomas – <a href="http://www.pragprog.com/titles/ruby3/programming-ruby-3">Programming Ruby</a>). Eles estão organizados aqui em ordem de precedência, da mais alta para a mais baixa.</p>
<table style="border:1px solid black;">
<tr>
<th>Método </th>
<th>Operador </th>
<th>Descrição </th>
</tr>
<tr>
<td> Sim </td>
<td> [] []= </td>
<td> Referência a um elemento, conjunto de elementos </td>
</tr>
<tr>
<td> Sim </td>
<td> ** </td>
<td> Exponenciação </td>
</tr>
<tr>
<td> Sim </td>
<td> ! ~ + – </td>
<td> Não (negação), complemento, mais e menos unários (os nomes de métodos para os dois últimos são +@ e -@)</td>
</tr>
<tr>
<td> Sim </td>
<td> * / % </td>
<td> Multiplicação, divisão e módulo </td>
</tr>
<tr>
<td> Sim </td>
<td> >> << </td>
<td> Deslocamento para direita e esquerda </td>
</tr>
<tr>
<td> Sim </td>
<td> & </td>
<td> “E” (bitwise par inteiros) </td>
</tr>
<tr>
<td> Sim </td>
<td> ^ </td>
<td> “Ou” exclusivo e “ou” comum (bitwise par inteiros) </td>
</tr>
<tr>
<td> Sim </td>
<td> <= < > >= </td>
<td> Operadores de comparação </td>
</tr>
<tr>
<td> Sim </td>
<td> <= < > >= </td>
<td> Igualdade e operadores para casamento de padrões (!= e !~ não podem ser definidos como métodos) </td>
</tr>
<tr>
<td> </td>
<td> && </td>
<td> “E” lógico </td>
</tr>
<tr>
<td> </td>
<td> </td>
<td> “Ou” lógico </td>
</tr>
<tr>
<td> </td>
<td> .. … </td>
<td> Intervalos inclusivo e exclusivo </td>
</tr>
<tr>
<td> </td>
<td> ?: </td>
<td> Operador ternário (If-then-else) </td>
</tr>
<tr>
<td> </td>
<td> = %= /= -= += = &= >>= <<= <strong>= &&= = *</strong>= </td>
<td> Operadores de atribuição </td>
</tr>
<tr>
<td> </td>
<td> defined? </td>
<td> Checa se um símbolo foi definido </td>
</tr>
<tr>
<td> </td>
<td> not </td>
<td> Negação lógica </td>
</tr>
<tr>
<td> </td>
<td> or and </td>
<td> Composição lógica</td>
</tr>
<tr>
<td> </td>
<td> if unless while until </td>
<td> Modificadores de expressão</td>
</tr>
<tr>
<td> </td>
<td> begin/end </td>
<td> Expressão de blocos</td>
</tr>
</table>
<div class='box'>
<ol>
<li>Os operadores de incremento e decremento (++ e —) não estão disponíveis em Ruby, nem da forma “pré” nem “pós”. Entretanto, note que os operadores += e -= estão disponíveis.</li>
<li>Parênteses funcionam da mesma forma como em expressões aritméticas. Qualquer coisa dentro de parênteses é calculado primeiro (ou, de uma forma mais técnica, é dado uma precedência maior).</li>
<li>Os operadores checados na figura são um tipo de <em>syntactic sugar</em> (“açúcar sintático”, mais sobre isso depois) – onde algo parece com um operador mas na verdade é uma chamada a um método.<br />
</div></li>
</ol>
<p>O operador módulo (%) do Ruby se comporta da seguinte forma:</p>
<div class="CodeRay">
<pre><span class="no">1</span> puts (<span class="i">5</span> % <span class="i">3</span>) <span class="c"># imprime 2</span>
<span class="no">2</span> puts (<span class="i">-5</span> % <span class="i">3</span>) <span class="c"># imprime 1</span>
<span class="no">3</span> puts (<span class="i">5</span> % <span class="i">-3</span>) <span class="c"># imprime -1</span>
<span class="no">4</span> puts (<span class="i">-5</span> % <span class="i">-3</span>) <span class="c"># imprime -2</span>
</pre>
</div>
<p>A definição do operador módulo do Ruby é diferente do C e do Java. Em Ruby, a operação -7 % 3 retorna 2. Já em Java e C, o resultado é -1. Em Ruby, o sinal do resultado (para o operador %) é sempre o mesmo sinal do segundo operando.</p>
<h2>Diferença entre os operadores or e ||</h2>
<p>Ambos, <strong>or</strong> e <strong>||</strong>, retornam o primeiro argumento ao menos que este retorne <strong>false</strong>, neste caso avaliam e retornam o segundo argumento. Isto é demonstrado no exemplo seguinte:</p>
<div class="CodeRay">
<pre><span class="no">1</span> puts <span class="pc">nil</span> || <span class="i">2008</span>
<span class="no">2</span> puts <span class="pc">false</span> || <span class="i">2008</span>
<span class="no">3</span> puts <span class="s"><span class="dl">"</span><span class="k">ruby</span><span class="dl">"</span></span> || <span class="i">2008</span>
</pre>
</div>
<p>A saída é:</p>
<div class="CodeRay">
<pre><span class="no">1</span> >ruby test.rb
<span class="no">2</span> <span class="i">2008</span>
<span class="no">3</span> <span class="i">2008</span>
<span class="no">4</span> ruby
<span class="no">5</span> ><span class="co">Exit</span> code: <span class="i">0</span>
</pre>
</div>
<p>A única diferença entre <strong>or</strong> e <strong>||</strong> é sua precedência. <strong>||</strong> tem uma precedência mais alta do que <strong>or</strong>.</p>
<p>Uma prática comum é usar || para atribuir valor a uma variável somente se nenhum valor foi atribuído a ela. Isso pode ser escrito assim:</p>
<div class="CodeRay">
<pre><span class="no">1</span> <span class="iv">@variavel</span> = <span class="iv">@variavel</span> || <span class="s"><span class="dl">"</span><span class="k">valor padrão</span><span class="dl">"</span></span>
</pre>
</div>
<p>ou, mais idiomático, como:</p>
<div class="CodeRay">
<pre><span class="no">1</span> <span class="iv">@variavel</span> ||= <span class="s"><span class="dl">"</span><span class="k">valor padrão</span><span class="dl">"</span></span>
</pre>
</div>
<p>Uma razão para essas versões alternativas de operadores booleanos é o fato de que eles têm precedência mais baixa do que o operador de atribuição. Isto significa que você pode escrever uma expressão booleana como a seguinte que atribui valores à variáveis até que ele encontre um valor false:</p>
<div class="CodeRay">
<pre><span class="no">1</span> <span class="r">if</span> a = f(x) <span class="r">and</span> b = f(y) <span class="r">and</span> c = f(z) <span class="r">then</span> d = g(a,b,c) <span class="r">end</span>
</pre>
</div>
<p>Esta expressão simplesmente não funcionaria se escrita com <strong>&&</strong> ao invés de <strong>and</strong>.</p>
<div class="pagination"><a href="diversao-com-strings.html">Diversão com strings ></a></div>
</div>
<div class="column span-5 append-1 last">
<p><a href="http://www.gurusp.org" title="Grupo de Usuários Ruby de SP"><img src="images/logo_guru-sp.jpg" title="Logo do GURU-SP" alt="Logo do Guru-SP" /></a></p>
<div class="box">
<p>Este material tem como base o <a href="http://www.rubylearning.com" title="Ruby Learning">tutorial do RubyLearning.com de Satish Talim</a> e foi traduzido por membros do <a href="http://www.gurusp.org" title="Grupo de Usuários Ruby de SP">GURU-SP</a> com a permissão do autor.</p>
<p class="last">Ajude o RubyLearning participando em algum dos <a href="http://www.rubylearning.org" title="cursos do Ruby Learning">cursos pagos</a> ou <a href="http://pledgie.com/campaigns/415" title="Ajude o Ruby Learning">fazendo uma doação para o projeto</a></p>
</div>
<p class="quiet"><a href="index.html" title="índice">Voltar para o índice</a></p>
<h5></h5>
<p class="incr"></p>
</div>
<div class="column span-22 prepend-1 append-1 first last" id="footer">
<hr />
<p>Tuturial de Ruby do <a href="http://www.gurusp.org" title="Grupo de Usuários Ruby de SP">GURU-SP</a>. Este site foi criado com <a href="http://webby.rubyforge.org">Webby</a></p>
</div>
</div>
</body>
</html>