Há um mês, consegui meu primeiro emprego e me tornei um desenvolvedor trainee, nossa equipe usa a linguagem Scala. Parece-me que todos os desenvolvedores iniciantes no primeiro dia estão perdidos. ao mesmo tempo, montes de novos nomes, tecnologias, algumas regras e você nunca sabe o que, absolutamente tudo é novo para você, este é o primeiro trabalho. No meu caso, eu ainda não sabia o idioma em que iria programar, até a entrevista que nunca tinha ouvido falar. Bottom line: no primeiro dia eu estava na íntegra. Pergunte como, então, consegui este emprego? Eu conhecia Java, na entrevista me disseram que o javista poderá ir para o rock com bastante facilidade e você não pode se preocupar. Mas, aparentemente, um pouco à frente ainda valia a pena, porque a primeira vez na minha frente eu vi telas cheias de texto, nas quais quase metade ficou imediatamente clara.
Mas mesmo o fato de eu não entender algo trouxe mais desconforto, mas o fato de que havia muito diferente, e até o tipo da variável vem após o nome e, às vezes, não existe.
final String str = "abc";
val str = "abc"
É assim que a função é descrita:
int sum(int a, int b) {return a+b;}
def sum(a: Int, b: Int) = {a + b}
E Scala também possui um console REPL (Read-eval-print-loop), como, por exemplo, em Python. Como você já percebeu, os pontos e vírgulas estão ausentes. Você pode executar programas de página única sem um main, os nomes dos métodos e variáveis podem conter e começar com qualquer caractere, sem regras. Não há estática, mas há Objeto, também existem objetos primitivos, == na verdade são iguais. Se o método não tiver parâmetros, não será necessário encerrar a chamada do método, os colchetes também serão opcionais se não houver parâmetros e se for necessário apenas 1 parâmetro, você poderá escrever assim:
str.charAt(5);
str charAt 5
E outro exemplo interessante:
val res = 1 + 1
Não, não são apenas 1 mais 1, aqui o objeto 1, o método + é chamado e o objeto 1 é passado para ele como o único parâmetro.Para mim, isso foi uma quebra de modelo.
Para minha surpresa, veio um livro maravilhoso de David Pollack - Beginning Scala. O livro começa com uma frase, após a qual percebi que devo lê-lo até o fim:
Ai! Isso machuca meu cérebro! Pare de me fazer pensar de maneira diferente. Oh, espere ... dói menos agora. Eu entendi. Essa maneira diferente de resolver o problema tem alguns benefícios. Eu me senti assim depois do meu primeiro ano na faculdade de direito. Eu me senti assim por um tempo quando comecei a codificar Scala.
David tem uma tremenda experiência em programação, ele começou esse negócio 20 anos antes do meu nascimento, conseguiu trabalhar com mais de 10 linguagens de programação até chegar a Scala. E agora ele diz:
Scala é uma linguagem de programação que fornece a melhor experiência do mundo para desenvolvedores.
No entanto, o autor honestamente adverte que não é tão fácil dominá-lo, ele levou dois anos para fazer isso, mas ele espera que possamos ser mais rápidos e que ele ajudará nisso. Este não é um livro muito simples e envolve alguma experiência em programação com o leitor. Especialmente quem já programou em Java vai gostar, porque existem muitas referências a esse idioma e podem ser comparadas.
Além do Beginning Scala, também li as lições da Escola Scala do Twitter, para todas as lições que há uma tradução para o russo, mas o livro de David Pollack foi encontrado apenas na versão em inglês.
O projeto Scala Exercises ajudou a consolidar a teoria, além de viagens independentes pela fonte do rock e do trabalho, existem tarefas muito simples, mas são adequadas para corrigir alguns aspectos a princípio e verificar se você leu e compreendeu tudo corretamente corretamente.
E vou falar um pouco sobre as coisas mais comuns e muito simples que eu tive que entender em primeiro lugar.
Opção Em poucas palavras - este é um contêiner no qual está vazio (Nenhum, parece nulo, mas tem mapa, filtro, ...) métodos, ou existe exatamente um valor Um pouco (valor) e seu uso podem tornar o código mais seguro e não lançando uma NullPointerException, porque você deseja, não deseja, mas ainda precisa recuperar os dados limpos da Option e, neste momento, já é difícil esquecer de fazer um cheque.
Obviamente, o Option possui um método get, mas não é recomendável usá-lo, porque nesse caso todo o ponto do Option é perdido, porque None.get lança uma exceção.
Algumas das comodidades mais óbvias:
É fácil retornar o valor padrão se a opção estiver vazia
optValue.getOrElse(defaultValue)
Em caso de qualquer ação:
optValue match { case Some(value) => action case None => defaultAction }
Exemplo do Scala Beginning. O caminho é um determinado banco de dados que contém tipos de Pessoa
def findPerson(key: Int): Option[Person]
O método retornará Some [Person] se essa entrada for encontrada e None, caso contrário.
Agora queremos obter a idade do usuário por chave.
def ageFromKey(key: Int): Option[Int] = findPerson(key).map(_.age)
Não precisamos testar o None e o método acabou sendo muito conciso.
Correspondência de padrões . No começo, pensei que esse é o mesmo switch Java e dificilmente o usarei, mas não é. Em Scala, esse é um dos designs mais usados.
Tipo de fundição:
obj match { case str: String => str case number: Int => number }
Você pode adicionar condições adicionais e adicionar uma ação padrão.
obj match { case strWithA: String if strWithA.contains("a") => strWithA case negative: Int if negative < 0 => negative case zero if zero == 0 => zero case _ => defaultAction }
É extremamente conveniente usar a correspondência de padrões com classes de caso. Exemplo do Scala Beginning
Stuff("David", 45) match { case Stuff("David", age) if age < 30 => "young David" case Stuff("David", _) => "old David" case _ => "Other" }
FunçõesPara começar, no Scala, funções são instâncias que implementam uma determinada interface, ou melhor, traçam FunctionX, em que X é o número de parâmetros e assume um valor de 1 a 22. Nesta bandeja, o único método é aplly, que é chamado para a função. Como funções são instâncias comuns, podemos transmiti-las e retorná-las de métodos e funções.
Exemplo do Scala Beginning. Passamos em uma resposta alguma função de Int para String, e ela retorna o resultado dessa função com o parâmetro 42.
def answer(f: Function1[Int, String]) = f(42)
ou a mesma coisa
def answer(f: Function1[Int, String]) = f.apply(42)
Uma coisa muito conveniente é combinadores funcionais /
Deixe apenas elementos positivos na matriz:
arr.filter(value => value > 0)
Um exemplo um pouco mais complexo. Calcule a soma dos valores da função f a partir dos elementos positivos da lista. 2 maneiras de fazer isso:
list.filter(x => x > 0).foldLeft(0)(_ + f(_)) list.filter(x => x > 0).map(f).sum
E no final, eu gostaria de dizer por que escrevi tudo isso. Eu não queria ensinar ninguém a Scala ou falar sobre o idioma como tal; existem muitos artigos no Habré e na Internet e muitos são muito bons e úteis. Meu objetivo era simplesmente contar a minha história, o que pode ser interessante para alguém e pode ajudar e apoiar alguns dos mesmos recém-chegados perdidos, que o destino acabou de colidir com esta rocha. Desejo-lhe boa sorte! Programadores experientes são incentivados a compartilhar suas dicas e opiniões nos comentários, sobre o caminho de um programador Scala novato.