Frequentemente, você vai querer escrever um método que calcula algum
valor e o retorna. Métodos retornando resultados são chamados
funções. Escrever uma função não é realmente mais difícil do
que escrever um simples método. [!java|c]Você simplesmente tem que
especificar o tipo de dados do resultado esperado entes do nome da
função (onde nós previamente tínhamos void
).[/!]
[!scala]Você simplesmente tem que adicionar um dois-pontos (:) depois
do parêntesis e escrever o tipo de dados que sua função vai retornar,
e adicionar um símbolo de igualdade (=). Esta sintaxe é na verdade
mais próxima de definir uma variável, com seu tipo, do que na verdade
escrever uma função.[/!] Você pode usar a instrução
return
em qualquer lugar do corpo da sua função para
especificar que o cálculo foi feito (a função não continuará sendo
executada), e que o resultado é o valor que acompanha a palavra-chave
return
.
[!java|c]double pi() {[/!][!scala]def pi(): Double = {[/!][!python]def pi():[/!] return 3.14159[!java|c];[/!] [!java|scala|c]}[/!]
Na verdade, você também pode usar a palavra-chave return
em métodos que não retornam qualquer resultado, para interromper o
cálculo. Obviamente que nestes casos você não passa nenhum valor para
retornar.
É possível ter várias instruções return
em várias
ramificações de um condicional. De fato, é proibido ter um caminho de
execução no corpo da função sem nenhum return
, ou
escrever algum código depois da instrução return
. Na
verdade, se a máquina alcança o fim da função sem encontrar qualquer
return
, ela não sabe o real valor que deve retornar a
quem chamou a função. Além disto, o return
interrompe
imediatamente a execução da função (por que se preocupar olhando além
quando você sabe o resultado da função?). Então, se existe algum
código depois de um return
, deve ser um erro e o
compilador irá te alertar disto.
[!java|scala|c][!java]boolean [/!][!c]int [/!][!scala]def [/!]isFrontFree()[!scala]:Boolean =[/!] { if (estáDeFrenteParaParede() == [!java|scala]true[/!][!c]1[/!]) { return [!java|scala]false[/!][!c]0[/!]; /* proibido colocar código aqui */ } else { return [!java|scala]true[/!][!c]1[/!]; /* nem aqui */ } /* e nem mesmo aqui. desista */ }[/!][!python]def livreEmFrente(): if estáDeFrenteParaParede() == True: return False # proibido colocar código aqui else return True # nem aqui # e nem mesmo aqui, desista[/!]
temBaggle
, e ela retorna um valor booleano
indicando se a linha na frente do buggle contém um baggle ou não. O
buggle vai usar isto para buscar a primeira linha contendo um baggle,
e parar nela.
A forma fácil de fazer esta função é usar uma variável booleana
chamada baggleAvistado
indicando se nós vimos ou não um
baggle até o momento. O valor inicial é
'[!python]False[/!][!scala|java]false[/!][!c]0[/!]'.
Então mova 6 passos para frente (o mundo contém 7 células e nós já
estamos em uma delas). Para cada célula, se ela contiver um baggle,
vamos guardar true em baggleVisto
(e se não, vamos
simplesmente andar para frente).
No final, vamos nos mover 6 passos para trás, e retornar o valor de
baggleVisto
para quem chamou o método.
Este exercício é um pouco diferente já que ele tem dois mundos iniciais, cada um com um objetivo específico. Seu código deve funcionar em ambos. Observe que o menu de seleção de mundo (logo abaixo do controle de velocidade) permite que você alterne entre os mundos.
Quando sua função temBaggle
funcionar, siga para o
próximo exercício.