0:00:00.000,0:00:04.526
Esta vai ser uma sessão muito curta. Só quero acrescentar um teste adicional

0:00:04.526,0:00:09.984
que calha funcionar muito bem com os dados dos nomes dos bebés.

0:00:09.984,0:00:15.376
Esta vai ser uma alternativa ao igual igual (==) que utilizámos anteriormente

0:00:15.376,0:00:20.768
nos dados dos nomes dos bebés. Agora quero mostrar-vos duas funções que se chamam

0:00:20.768,0:00:25.960
startsWith (começaCom) e endsWith() (terminaCom). Elas funcionam com strings (cadeias de caracteres). Para explicar

0:00:25.960,0:00:30.720
vamos dar uma olhada ao código. Tudo isto já vimos antes...

0:00:30.720,0:00:34.417
abri a tabela, tenho o ciclo, tenho a funcão que olha para cada linha...

0:00:34.417,0:00:38.771
portanto vamos olhar para o teste (condição) que temos aqui. A primeira parte

0:00:38.771,0:00:42.974
do teste é igual ao que já vimos antes. Eu digo row.getField("name")

0:00:42.974,0:00:47.127
para ir buscar o campo 'nome' à linha actual. Anteriormente fizemos

0:00:47.127,0:00:50.874
examples como: é igual a 'Abby' ou 'Robert' ou o que quer que seja com os iguais (==).

0:00:50.874,0:00:55.279
A forma como estas funções pode parecer um pouco estranha.

0:00:55.279,0:00:59.348
Tem um ponto (.) e a seguir escrevemos o nome da função, do lado direito do que queremos comparar.

0:00:59.348,0:01:03.787
Portanto, pego no nome e imediatamente escrevo um ponto (.) seguido de startsWith (começaCom).

0:01:03.787,0:01:08.613
Em seguida, dentro dos parentesis podemos pôr qualquer texto.

0:01:08.613,0:01:13.622
Aqui eu digo 'Ab'. Portanto este teste verifica: será que o nome começa com as letras 'Ab'?

0:01:13.622,0:01:18.754
E se começar, então a condição é verdadeira. Se não começar, é falsa.

0:01:18.754,0:01:23.458
É como se lêssemos: o nome começa com 'Ab'?

0:01:23.458,0:01:28.589
Vamos experimentar! Se eu executar o código, podemos ver que ele percorreu as 2000 linhas

0:01:28.589,0:01:33.598
e escolheu apenas aquelas que começam com 'Ab'. O teste deu

0:01:33.598,0:01:41.094
verdadeiro para todas estas. Portanto, o que eu escrever aqui... vamos ter linhas onde o nome

0:01:41.094,0:01:47.482
começa com isso. Ou seja, podemos testar outros valores

0:01:47.482,0:01:53.630
vamos experimentar com 'Da'. Não há muitos... Podemos experimentar apenas com um 'A' maiúsculo.

0:01:53.630,0:02:00.264
Só uma letra. Vamos ter muitos resultados. Muitos nomes começam com a letra 'A'.

0:02:00.264,0:02:07.655
Se testarmos com um 'a' minúsculo, e executarmos. Não temos resultados nenhuns. O que se passa

0:02:07.655,0:02:12.312
é que para o computador o 'A' maiusculo e o 'a' minusculo são duas letras diferentes.

0:02:12.312,0:02:17.459
E os nomes nestes dados que temos começam todos com letra maiúscula

0:02:17.459,0:02:22.422
e as letras seguintes são minusculas. Ou seja, começar com um 'A' minusculo

0:02:22.422,0:02:27.201
não dá resultados nenhuns, ao contrário do 'A' maiusculo

0:02:27.201,0:02:32.042
onde obtemos todos os nomes que começam por 'A'.

0:02:32.042,0:02:37.128
Podem ver aqui, apenas a primeira letra é maiuscula.

0:02:37.128,0:02:45.359
Temos de ter isso em atenção no teste. Vamos agora experimentar com um 'Z'.

0:02:45.359,0:02:53.616
Ele encontra nomes que começam com 'Z', e temos todos estes resultados.

0:02:53.616,0:03:02.081
Ou podemos diminuir o número de resultados e procurar por 'Za'. Ou restringir ainda mais

0:03:02.081,0:03:07.551
e procurar aqueles que começam com 'Zai'.

0:03:07.551,0:03:12.140
Se tentarmos com 'Zaix', voltamos a não encontrar nenhum nome.

0:03:12.140,0:03:16.843
Assim, é perfeitamente possível fazermos um teste que devolve falso para todas as 2000 linhas.

0:03:16.843,0:03:21.374
E consequentemente não imprime nada no ecrã. Se reduzir a string para 'Zai' voltamos a ver esses.

0:03:21.374,0:03:26.193
Esta é a função startsWith (começaCom). Para estes primeiros exemplos vamos utilizá-la

0:03:26.193,0:03:30.724
sempre desta forma. Vamos à linha do bebé, obtemos o nome dessa linha,

0:03:30.724,0:03:35.255
e dizemos logo: .startsWith() para comparar o início do nome.

0:03:35.255,0:03:41.277
Como podem adivinhar, também temos uma função .endsWith (terminaCom), que vai comparar o final do do nome.

0:03:41.277,0:03:46.539
Se eu disser: termina com um 'z' minusculo e testar...

0:03:46.539,0:03:52.425
não temos muitos resultados, apenas 3 nomes terminam com um 'z'.

0:03:52.425,0:03:57.895
Podemos testar com outra letra ou até várias letras...

0:03:57.895,0:04:04.267
Vou dizer por exemplo, termina com 'ly'... Ou termina com 'la'...

0:04:04.267,0:04:09.180
Se executar, podemos ver que temos mais resultados.

0:04:09.180,0:04:13.663
Por acaso estes são todos nomes de raparigas, mas isso é apenas um padrão cultural

0:04:13.663,0:04:18.514
nos nomes ingleses: se termina em 'la' é provavelmente um nome de rapariga.

0:04:18.514,0:04:23.243
Estas são apenas mais duas funções.

0:04:23.243,0:04:28.094
E iremos usá-las para comparar os nomes nos dados que temos dos bebés.

0:04:28.094,0:04:32.700
Mas também nos vão permitir fazer alguns problemas mais interessantes.