jspqsp/string.html at master · oturing/jspqsp · GitHub

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
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
<!DOCTYPE html>
<html>
<head>
	<meta charset="utf-8">
	<title>Testes com strings</title>
	<script type="text/javascript" src="doctest.js"></script>
	<!-- This stylesheet is optional, but does improve the output: -->
	<link rel="stylesheet" type="text/css" href="doctest.css" />
	<style type="text/css">
	body {
	  font-family: sans-serif;
	}
	</style>
</head>

<body class="autodoctest">
<!-- the autotest class tells doctest to run the tests and fill
in extra elements automatically -->
<h1>Strings em JavaScript</h1>

Existem dois tipos de strings em JavaScript: strings primitivas, e
objetos <code>String</code>. Strings primitivas são construídas
a partir de literais entre aspas simples ou duplas, ou invocando
diretamente o objeto global <code>String</code> como uma função (sem
usar o operador <code>new</code>). Instâncias de <code>String()</code>
são criadas invocando <code>new String()</code>.

<div class="test">
<pre class="doctest">
$ s0 = "ABC"             // string primitiva
$ typeof s0
"string"

$ s1 = String("ABC")     // string primitiva
$ typeof s1
"string"

$ s2 = new String("ABC") // objeto String
$ typeof s2
"object"</pre>
</div>

Os operadores == e === produzem os seguintes resultados ao comparar
strings primitivas e objetos String:

<div class="test">
<pre class="doctest">
$ s0 === s1
true
$ s1 === s2
false
$ s1 == s2
true
$ s1 === "ABC"
true
$ s2 === new String("ABC")
false</pre>
</div>

Muitos métodos de objetos String devolvem strings primitivas como
resultado. Por, exemplo o método <code>concat</code>, aplicado sobre
um objeto String, mesmo quando recebe como argumento outro objeto
String, devolve uma string primitiva:

<div class="test">
<pre class="doctest">
$ s = new String("ABC")
$ s.concat(new String('xyz'))
"ABCxyz"
$ typeof s.concat(new String('xyz'))
"string"</pre>
</div>

Em algumas situações o interpretador JavaScript converte
automaticamente entre estes dois tipos de strings. Strings
primitivas não possuem atributos (propriedades ou métodos). Quando
se tenta acessar qualquer atributo em uma string primitiva, um
objeto String é criado temporariamente, e é este objeto que na
verdade acaba sendo acessado (em Java, o mecanismo semelhante de
conversão automática de tipos primitivos para objetos chama-se
autoboxing).

É por isso que no exemplo abaixo a atribuição <code>s1.sabor =
"morango"</code> acaba não surtindo efeito: o atributo <code>sabor
</code> é criado em um objeto String temporário criado a partir de
<code>s1 </code>, e não diretamente em <code>s1</code>. Ao fazer o
mesmo em <code>s2</code>, o atributo é preservado.

<div class="test">
<pre class="doctest">
$ s1 = "ABC"     // string primitiva
$ s1.sabor = "morango"
$ a1 = []
$ for (prop in s1) a1.push(prop)
$ a1
["0", "1", "2"]</pre>
</div>

A mesma atribuição, quando feita a um objeto String, funciona:
<div class="test">
<pre class="doctest">
$ s2 = new String("ABC") // objeto String
$ s2.sabor = "morango"
$ a2 = []
$ for (prop in s2) a2.push(prop)
$ a2.sort()  // necessário ordenar, pois a ordem das propriedades é indefinida
["0", "1", "2", "sabor"]</pre>
</div>


<h2>Atributos básicos de instâncias</h2>

<h3><em>string</em>.length</h3>

Comprimento da string, em caracteres.

<div class="test">
<pre class="doctest">
$ s = "abacaxi"
$ s.length
7</pre>
</div>

<a id="getitem" />
<h3><em>string</em>[«índice»] <sup>ES5</sup></h3>

Caractere na posição «índice» da string, ou <code>undefined</code>, se
o «índice» está fora dos limites da string. Ver também
<a href="#getitem"><em>string</em>.charAt(«índice»)</a>.

<div class="test">
<pre class="doctest">
$ s = "abacaxi"
$ s[3]
"c"
$ typeof s[20]
"undefined"
$ typeof s[-2]
"undefined"</pre>
</div>

<h2>Métodos herdados de <code>String.prototype</code></h2>

<a id="charAt" />
<h3><em>string</em>.charAt(«índice»)</h3>

Devolve o caractere na posição «índice» da string ou "" (uma string
vazia), se o o «índice» está fora dos limites da string. Ver também
<a href="#getitem"><em>string</em>[«índice»]</a>.

<div class="test">
<pre class="doctest">
$ s = "abacaxi"
$ s.charAt(1)
"b"
$ s.charAt(-1)
""
$ typeof s.charAt(-1)
"string"</pre>
</div>

<p class="vt">Veja também: <a href="#getitem"><em>string</em>[«índice»]</a></p>

<h3><em>string</em>.charCodeAt(«índice»)</h3>

Código Unicode do caracter na posição «índice».

<div class="test">
<pre class="doctest">
$ s = "ABC"
$ s.charCodeAt(1) // letra B
66
$ s.charCodeAt(10) // não há posição 10, resultado "Not a Number"
NaN
$ "☂".charCodeAt(0).toString(16) // Unicode em hexadecimal
"2602"</pre>
</div>


<h3><em>string</em>.concat([«string2» [ , «string3» [ , ... ] ] ] »)</h3>

Devolve uma nova string formada pela concatenação da instância
<em>string</em> aos argumentos «string2», «string2» etc.

<div class="test">
<pre class="doctest">
$ s = "ABC"
$ s.concat('xyz', '!')
"ABCxyz!"</pre>
</div>

<h3><em>string</em>.indexOf(«subString» [, «índice»])</h3>

Devolve a posição da primeira ocorrência «subString» em
<em>string</em>, ou -1 caso não ocorra. O argumento opcional «índice»
determina a posição inicial da procura.

<div class="test">
<pre class="doctest">
$ s = "banana"
$ s.indexOf('na')
2
$ s.indexOf('na', 3)
4
$ s.indexOf('ab', 3)
-1</pre>
</div>

<h3><em>string</em>.lastIndexOf(«subString» [, «índice»])</h3>

Devolve a posição da última ocorrência «subString» em
<em>string</em>, ou -1 caso não ocorra. O argumento opcional «índice»
determina a posição inicial da procura.

<div class="test">
<pre class="doctest">
$ s = "banana"
$ s.lastIndexOf('na')
4
$ s.lastIndexOf('na', 3)
2
$ s.lastIndexOf('ab', 3)
-1</pre>
</div>

<h3><em>string</em>.localeCompare(«string2»)</h3>

Compara alfabeticamente <em>string</em> com «string2», considerando
as regras de ordenação do locale -- a configuração local do ambiente
onde o interpretador JavaScript está sendo executada. Devolve um número
negativo se <em>string</em> precede «string2» na ordem alfabética,
positivo se <em>string</em> sucede «string2», ou zero se as strings são
iguais.

Este método serve para complementar os operadores primitivos &lt;,
>, &lt;= e >= que apenas comparam os códigos Unicode das duas
sequências de caracteres, e sem levar em conta as regras de
ordenação alfabética convencionais.</dd> </dl>

Veja como o operador &lt; não respeita a ordem alfabética:

<div class="test">
<pre class="doctest">
$ s0 = "abacate"
$ s1 = "Avião"
$ s2 = "Aviso"
$ s0 &lt; s1 // porque o código de "a" é 97, e "A" é 65
false
$ s1 &lt; s2 // porque o código de "ã" é 227, e "s" é 115
false
</pre>
</div>

Em contraste, o método <code>localeCompare</code> funciona como
esperado, mas não em todos os navegadores. (LR: testei no Firefox 12,
no Opera 9 e no Chromium 18; os testes funcionarm nos dois primeiros,
mas não no Chromium)

<div class="test">
<pre class="doctest">
$ s0.localeCompare(s1) &lt; 0 // "abacate" vem antes de "Avião"
true
$ s1.localeCompare(s2) &lt; 0 // "Avião" vem antes de "Aviso"
true
</pre>
</div>

<h2>Métodos com expressões regulares</h2>

<h3><em>string</em>.replace(«searchValue», «replaceValue»)</h3>
<h3><em>string</em>.match(«regexp»)</h3>

<h3><em>string</em>.search(«regexp»)</h3>
<h3><em>string</em>.slice(«start», «end»)</h3>
<h3><em>string</em>.split(«separator», «limit»)</h3>
<h3><em>string</em>.substring («start», «end»)</h3>
<h3><em>string</em>.toLowerCase()</h3>
<h3><em>string</em>.toLocaleLowerCase()</h3>
<h3><em>string</em>.toUpperCase()</h3>
<h3><em>string</em>.toLocaleUpperCase()</h3>
<h3><em>string</em>.trim()</h3></h3>


<h2>Atributos do objeto global <code>String</code></h2>

<h3>String.fromCharCode(«código1» [, «código2» [, ... ] ] )</h3>

Devolve uma string primitiva construída a partir de um ou mais códigos
Unicode.

<div class="test">
<pre class="doctest">
$ String.fromCharCode(65, 66, 67)
"ABC"
$ String.fromCharCode(0x2660, 0x2661, 0x2662, 0x2663)
"♠♡♢♣"</pre>
</div>

<h3><em>string</em>.constructor</h3>
<h3><em>string</em>.property</h3>
<h3><em>string</em>.toString()</h3>
<h3><em>string</em>.valueOf()</h3>


</body></html>