Usando classes em CoffeeScript

Uma das coisas mais importantes que nos ajudam a definir nossa aplicação é o uso de classes, pois com elas podemos definir objetos modelados da vida real e sua passagem para o mundo digital torna-se muito mais fácil.
Em CoffeeScript construir uma classe e instanciá-la é muito simples, na verdade sua sintaxe é tão minimalista que é muito fácil para nós lembrarmos dela, ao invés de fazer uma definição de classes diretamente em JavaScript É algo um pouco mais complicado e pode levar mais tempo do que o esperado.
RequisitosPara completar este tutorial, devemos ter uma instalação funcional de CoffeeScript, também precisamos de permissões para escrever arquivos e executar CoffeeScript no computador onde estamos fazendo o tutorial. Precisamos de um editor de texto para poder escrever o código que vamos realizar para que tenhamos algo persistente e não tudo no console.
Uma classe nada mais é do que um nome e algumas propriedades que definem seu comportamento, com base nesse conceito podemos definir uma classe em CoffeeScript da seguinte forma:

 classe aluno

Isso é tudo que precisamos fazer, de forma simples já construímos nossa primeira aula em CoffeeScriptAgora o que acontece se quisermos incluir uma propriedade para poder usá-la, porque simplesmente criamos uma instância e adicionamos essa propriedade, vejamos:

 aluno = novo aluno () aluno.nome = "Carolina"

Agora vamos ver como na imagem a seguir como CoffeeScript transformar todo o nosso código em JavaScript puro ao compilar, vamos lembrar o comando para isso que seria café -c nomedoarquivo.coffee:

Em seguida, notamos como a sintaxe de JavaScript pure é muito mais extenso e complexo do que as três linhas de código que fizemos em CoffeeScript, este é o poder desta linguagem que nos permite realmente nos dedicar à nossa aplicação.
Uma das coisas mais usadas no programação orientada a objetos é adicionar métodos às classes, uma vez que estes, além das propriedades, nos darão uma ideia do que nosso objeto pode ou não fazer, por exemplo, se continuarmos com o Aula de estudante Podemos criar um método para ele no qual seu objeto expressa uma mensagem, vamos ver como fazer isso:

 classe Aluno fala: -> console.log "Hello World!"

Se criarmos um objeto dessa mesma classe, já poderíamos usar o mesmo método. Por exemplo:

 aluno = novo alunoestudante.talk ()

Com isso, garantimos que nosso método pode ser usado muitas vezes, desde que façamos várias instâncias, o que dá ao nosso código uma das características da orientação a objetos, que é reuso. Agora vamos redefinir nosso código para que aceite argumentos, com isso podemos fazer muito mais do que uma simples impressão pelo console, vejamos:

 aula conversa do aluno: (nome) -> console.log "Olá # {nome}!" aluno = novo aluno aluno.talk ("Carolina")

Vamos ver como tudo isso se traduz em código JavaScript quando compilamos:

Algo importante que podemos fazer ao construir objetos derivados de classes é manter seu valor durante sua vida em nossa aplicação, com isso podemos fazer componentes que podem acessar suas propriedades através de métodos e assim utilizá-los em diferentes partes de nossa aplicação.
A fim de manipular uma propriedade dentro CoffeeScript nós apenas temos que usar o @ operador seguido pelo nome da propriedade a ser usada, que pode ser codificado da seguinte forma:

 classe Aluno fala: () -> console.log “Olá # {@ nome}!” aluno = novo Aluno () aluno.name = “Carolina” aluno. fala ()

Vamos ver como fica quando executado diretamente no console:

Uma vez feito isso, vamos ver como nosso código compilado se parece JavaScript puro:

A diferença na quantidade de código é notável e basta fazer algo tão simples como definir uma classe com um método, então instanciá-lo e chamar o método criado.
Há ocasiões em que a definição da nossa classe nos leva a criar métodos que devem ser chamados dentro de outras, isso para conseguir uma programação menos repetitiva e mais funcional, vamos ver como podemos fazer isso usando o seguinte código escrito em CoffeeScript.

 classe Aluno fala: () -> console.log "Olá, meu nome é: # {@ name}!" @knowAge () knowAge: () -> console.log "Minha idade é: # {@ age}" student = new Student () student.name = "Vanessa" student.age = “23” student.talk ()

Vamos ver como no console podemos ver o resultado da execução do código anterior:

Até agora temos definido as propriedades do objeto após sua inicialização, embora seja uma prática viável, quando temos que criar objetos com muitas propriedades isso pode ser difícil de manter.
A melhor coisa nos casos em que temos que trabalhar com muitos objetos e muitas propriedades é ser capaz de usar o poder de construtoresCom eles podemos dar vida ao nosso objeto diretamente sem ter que definir as diferentes propriedades de uma forma "manual". Para definir um construtor, use uma estrutura semelhante à seguinte:

 classe Construtor do aluno: (nome, idade) -> @nome = nome @ idade = idade falar: () -> console.log "Olá, meu nome é: # {@ nome}!" @saberEdad () saberEdad: () -> console.log "Minha idade é: # {@ age}"

Se olharmos para a definição da classe, o construtor nada mais é do que um método, o interessante é que quando ele é chamado construtor já CoffeeScript ele sabe que é um método especial para nossa classe e o tratará como tal, por isso, quando vamos criar as instâncias de nossa classe, não precisamos chamá-lo explicitamente. Vamos ver um exemplo de como agora podemos definir nossos objetos:

 aluno = novo aluno ("Carolina", "26") aluno.speaking ()

Vemos que não precisamos definir a propriedade Nome nem a propriedade idade, simplesmente passamos os valores para o construtor na ordem em que os definimos em nossa classe e ele faz o resto do trabalho para nós. Claro que este exemplo é muito simplista, mas vamos imaginar que temos que instanciar centenas de objetos com valores que vêm de uma fonte de persistência como um banco de dados.
Vamos ver na imagem a seguir como fica nosso novo código, uma vez que é compilado e traduzido para JavaScript puro:

Neste caso, vemos que JavaScript não usa a palavra-chave construtor ao construir o método que definimos em CoffeeScript, neste ponto começamos a ver de forma mais direta a diferença entre as linguagens, além do que resolvemos em cerca de 12 ou 13 linhas de código, em JavaScript tornar-se mais do que 20 linhas, algo a ser levado em consideração quando estamos fazendo grandes aplicações.
Uma das vantagens de trabalhar com programação orientada a objetos é que podemos fazer herança de classes, isso significa ser capaz de criar novas classes e obter a funcionalidade de classes pais, com isso reduzimos o número de elementos que temos que criar do zero, já que ao herdar tomamos todos os métodos e propriedades da classe pai, na classe filha ou na nova classe só temos que definir os métodos e propriedades que são exclusivos para ele.
Talvez para aqueles que são novos em programação este conceito seja um pouco confuso ou complexo, no entanto, olhando para o exemplo a seguir, certamente seremos um pouco mais claros sobre o que podemos alcançar.

 classe Pessoa a saber Idade: () -> console.log "Minha idade é: # {@ age}" classe Aluno estende Pessoa para falar: () -> console.log "Olá # {@ name}!" aluno = novo Student () student.age = "30" student.name = "Jon" student.knowAge ()

Analisando, vemos como temos uma aula Pessoa e este tem um método knowAge () com o qual imprimimos por console a idade da instância, ao criar a classe Aluna nós dizemos a ele que ele herda de Pessoa então, implicitamente, nossa nova classe já tem o método knowAge () mesmo que não seja definido na classe.
Vamos ver na imagem a seguir como fica nosso novo código, uma vez que é compilado e traduzido para JavaScript puro:

Podemos então ver que nosso código JavaScript é bastante complexo para definir herança, mas ao usar CoffeeScript sua otimização é extremamente alta. Se virmos o utilitário, vamos imaginar classes muito complexas como componentes de aplicativos que podem nos fornecer múltiplas funcionalidades em nossas novas classes, sem ter que escrever mais do que o código específico de que realmente precisamos.
Com isso terminamos este tutorial, pois vemos o mundo das classes em CoffeeScript Não é tão complexo quanto parecia à primeira vista, tudo consiste em conhecer os fundamentos e a filosofia da programação orientada a objetos. O que podemos garantir é que o uso de CoffeeScript como uma linguagem, torna a complexidade do uso de classes em JavaScript cair consideravelmente, uma vez que sua sintaxe é muito mais próxima de linguagens como Pitão ou Rubi eles o tornam muito mais elegante e menos confuso ao ler o código desenvolvido.Gostou e ajudou este tutorial?Você pode recompensar o autor pressionando este botão para dar a ele um ponto positivo