-
Notifications
You must be signed in to change notification settings - Fork 11
/
mais-sobre-strings.html
145 lines (132 loc) · 12.8 KB
/
mais-sobre-strings.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
<!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>Mais sobre Strings</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">Mais sobre Strings</p>
<p>Existem muitos métodos na classe <strong>String</strong> (você não precisa memorizar todos; pode olhar na documentação) como o <strong>reverse</strong> que dá uma versão ao contrário de uma string (o <strong>reverse</strong> não altera a string original). <strong>length</strong> (tamanho) dá o número de caracteres (incluindo espaços) na string.<br />
<strong>upcase</strong> altera cada letra em mínusculo (caixa baixa) para maiúsculo (caixa alta), e <strong>downcase</strong> faz o oposto. <strong>swapcase</strong> altera a caixa de cada letra na string e, por fim, <strong>capitalize</strong> é como <strong>downcase</strong>, exceto por trocar a primeira letra para maiúscula (se for uma letra), <strong>slice</strong> dá uma substring de um string maior.</p>
<p>Os métodos <strong>upcase</strong>, <strong>downcase</strong>, <strong>swapcase</strong> e <strong>capitalize</strong> tem métodos correspondentes que alteram a string em questão ao invés de criar uma nova: <strong>upcase!</strong>, <strong>downcase</strong>!, <strong>swapcase!</strong> e <strong>capitalize!</strong>. Assumindo que você não precisa da string original, estes métodos irão economizar memória, especialmente se a string for grande.</p>
<p>Sabemos que Strings literais são sequências de caracteres entre aspas simples ou duplas. A diferença entre as duas formas está na quantidade de processamento que o Ruby faz na string enquanto constrói a literal. No caso da aspas simples, o Ruby faz muito pouco. A barra invertida serve para escapar outra barra invertida, para que a segunda barra não seja interpretada como um caractere de escape. Em strings com aspas simples, uma barra invertida não é especial se o caractere que se segue é qualquer coisa que não uma barra invertida. Por exemplo, <strong>‘a\b’</strong> e <strong>a\\b</strong> são iguais. No caso das aspas duplas, o Ruby tem mais trabalho. Primeiro, ele procura por substituições – sequências que começam com uma barra invertida – e as substitui com algum valor binário. A segunda coisa que o Ruby faz com strings com aspas duplas é a interpolação de expressões. Dentro da string, a sequência <strong>#{expressao}</strong> é substituída pelo valor de expressão (veja o exemplo p013expint.rb). Nesse programa, o valor retornado por um método Ruby é o valor da última expressão avaliada, então podemos nos livrar do valor da variável (resultado) e a declaração <strong>return</strong> juntos.</p>
<div class="CodeRay">
<pre><span class="no"> 1</span> <span class="c"># p013expint.rb</span>
<span class="no"> 2</span> <span class="r">def</span> <span class="fu">diz_boanoite</span>(nome)
<span class="no"> 3</span> result = <span class="s"><span class="dl">"</span><span class="k">Boa noite, </span><span class="il"><span class="idl">#{</span>nome<span class="idl">}</span></span><span class="dl">"</span></span>
<span class="no"> 4</span> <span class="r">return</span> resultado
<span class="no"> 5</span> <span class="r">end</span>
<span class="no"> 6</span> puts diz_boanoite(<span class="s"><span class="dl">'</span><span class="k">Satish</span><span class="dl">'</span></span>)
<span class="no"> 7</span>
<span class="no"> 8</span> <span class="c"># programa modificado</span>
<span class="no"> 9</span> <span class="r">def</span> <span class="fu">diz_boanoite2</span>(nome)
<span class="no"><strong>10</strong></span> <span class="s"><span class="dl">"</span><span class="k">Boa noite, </span><span class="il"><span class="idl">#{</span>nome<span class="idl">}</span></span><span class="dl">"</span></span>
<span class="no">11</span> <span class="r">end</span>
<span class="no">12</span>
<span class="no">13</span> puts diz_boanoite2(<span class="s"><span class="dl">'</span><span class="k">Talim</span><span class="dl">'</span></span>)
</pre>
</div>
<p>É importante notar que cada vez que uma literal string é usada em uma atribuição ou como um parâmetro, um novo objeto String é criado.</p>
<p>Como a memória é gerenciada pada Strings no Ruby? Há um pool separado para elas? As Strings são objetos da classe String. Essa classe tem mais de 75 métodos padrões. Se você consultar o “Guia de Usuário Ruby”, verá que ele diz que “não temos que nos preocupar com o espaço ocupado por uma string. Estamos livre de todo o gerenciamento de memória”.</p>
<h2>Listando os métodos de uma classe ou objeto</h2>
<div class="CodeRay">
<pre><span class="no">1</span> <span class="co">String</span>.methods.sort
</pre>
</div>
<p>Apresenta uma lista de métodos que o objeto String do tipo Class responde.</p>
<div class="CodeRay">
<pre><span class="no">1</span> <span class="co">String</span>.instance_methods.sort
</pre>
</div>
<p>Este método lhe apresenta todos os métodos de instância possuidos por String em ordem alfabética.</p>
<div class="CodeRay">
<pre><span class="no">1</span> <span class="co">String</span>.instance_methods(<span class="pc">false</span>).sort
</pre>
</div>
<p>Com esse método, você pode ver os métodos de instância de uma classe sem os métodos das classes ancestrais.</p>
<h2>Comparando duas strings para a igualdade</h2>
<p>As Strings têm diversos métodos para testar a igualdade. O mais comum é o == (duplos sinais de igual). Outro método de instância para testar a igualdade, String.eql?, checa se duas strings tem o conteúdo idêntico. Ele retorna o mesmo resultado que o ==. Um terceiro método de instância, String.equal?, testa se duas strings são o mesmo objeto. O exemplo p013strcmp.rb ilustra isso:</p>
<div class="CodeRay">
<pre><span class="no"> 1</span> <span class="c"># p013strcmp.rb</span>
<span class="no"> 2</span> <span class="c"># String#eql?, testa se duas strings tem conteúdo idêntico.</span>
<span class="no"> 3</span> <span class="c"># Retorna o mesmo resultado que ==</span>
<span class="no"> 4</span> <span class="c"># String#equal?, teste se duas strings são o mesmo objeto</span>
<span class="no"> 5</span> s1 = <span class="s"><span class="dl">'</span><span class="k">Jonathan</span><span class="dl">'</span></span>
<span class="no"> 6</span> s2 = <span class="s"><span class="dl">'</span><span class="k">Jonathan</span><span class="dl">'</span></span>
<span class="no"> 7</span> s3 = s1
<span class="no"> 8</span> <span class="r">if</span> s1 == s2
<span class="no"> 9</span> puts <span class="s"><span class="dl">'</span><span class="k">Ambas strings têm o mesmo conteúdo</span><span class="dl">'</span></span>
<span class="no"><strong>10</strong></span> <span class="r">else</span>
<span class="no">11</span> puts <span class="s"><span class="dl">'</span><span class="k">Ambas strings não têm o mesmo conteúdo</span><span class="dl">'</span></span>
<span class="no">12</span> <span class="r">end</span>
<span class="no">13</span> <span class="r">if</span> s1.eql?(s2)
<span class="no">14</span> puts <span class="s"><span class="dl">'</span><span class="k">Ambas strings têm o mesmo conteúdo</span><span class="dl">'</span></span>
<span class="no">15</span> <span class="r">else</span>
<span class="no">16</span> puts <span class="s"><span class="dl">'</span><span class="k">Ambas strings não têm o mesmo conteúdo</span><span class="dl">'</span></span>
<span class="no">17</span> <span class="r">end</span>
<span class="no">18</span> <span class="r">if</span> s1.equal?(s2)
<span class="no">19</span> puts <span class="s"><span class="dl">'</span><span class="k">As duas strings são objetos idênticos</span><span class="dl">'</span></span>
<span class="no"><strong>20</strong></span> <span class="r">else</span>
<span class="no">21</span> puts <span class="s"><span class="dl">'</span><span class="k">As duas strings não são objetos idênticos</span><span class="dl">'</span></span>
<span class="no">22</span> <span class="r">end</span>
<span class="no">23</span> <span class="r">if</span> s1.equal?(s3)
<span class="no">24</span> puts <span class="s"><span class="dl">'</span><span class="k">As duas strings são objetos idênticos</span><span class="dl">'</span></span>
<span class="no">25</span> <span class="r">else</span>
<span class="no">26</span> puts <span class="s"><span class="dl">'</span><span class="k">As duas strings são objetos idênticos</span><span class="dl">'</span></span>
<span class="no">27</span> <span class="r">end</span>
</pre>
</div>
<h2>Usando %w</h2>
<p>Às vezes, criar arrays (listas) de palavras pode ser algo doloroso, por todas as aspas e vírgulas. Felizmente, o Ruby tem um atalho: o <strong>%w</strong> faz o que queremos.</p>
<div class="CodeRay">
<pre><span class="no"> 1</span> nomes1 = [ <span class="s"><span class="dl">'</span><span class="k">marcelo</span><span class="dl">'</span></span>, <span class="s"><span class="dl">'</span><span class="k">hugo</span><span class="dl">'</span></span>, <span class="s"><span class="dl">'</span><span class="k">william</span><span class="dl">'</span></span>, <span class="s"><span class="dl">'</span><span class="k">ricardo</span><span class="dl">'</span></span>, <span class="s"><span class="dl">'</span><span class="k">rafael</span><span class="dl">'</span></span> ]
<span class="no"> 2</span> puts nomes1[<span class="i">0</span>] <span class="c"># marcelo</span>
<span class="no"> 3</span> puts names1[<span class="i">3</span>] <span class="c"># ricardo</span>
<span class="no"> 4</span> <span class="c"># isso é mesma coisa:</span>
<span class="no"> 5</span> nomes2 = <span class="s"><span class="dl">%w{</span><span class="k"> marcelo hugo william ricardo rafael </span><span class="dl">}</span></span>
<span class="no"> 6</span> puts nomes2[<span class="i">0</span>] <span class="c"># marcelo</span>
<span class="no"> 7</span> puts nomes2[<span class="i">3</span>] <span class="c"># ricardo</span>
<span class="no"> 8</span>
<span class="no"> 9</span> <span class="c"># Um jeito rápido de converter para caixa alta</span>
<span class="no"><strong>10</strong></span> <span class="c"># O símbolo :upcase representa uma chamada ao método upcase</span>
<span class="no">11</span> puts nomes2.map(&<span class="sy">:upcase</span>)
</pre>
</div>
<p>Você pode ver todos os detalhes da classe String na <a href="http://www.ruby-doc.org/ruby-1.9/classes/String.html" title="em inglês">documentação oficial do Ruby</a>.</p>
<div class="pagination"><a href="construcoes-simples.html">Construções simples ></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>