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.