Recadastramento da AMS


1- Recadastramento da AMS para quem paga por Boleto e 2- Programas de Descontos dos Laboratórios

Recadastramento obrigatório para quem utiliza boleto bancário é estendido até 15/08

O prazo para recadastramento dos Beneficiários AMS que efetuam o pagamento da AMS por boleto bancário foi estendido até 15/08.

O recadastramento é obrigatório e tem como objetivo a atualização do cadastro e o atendimento às recomendações da Auditoria da Petrobras.

Caso o benefíciario não se recadastre dentro do prazo, seu benefício AMS será suspenso a partir do dia 16/08.  Caso não seja realizada a devida atualização cadastral em até 90 dias a partir dessa data, o benefício será cancelado em definitivoO prazo não será prorrogado.

O processo será realizado de forma eletrônica através do Botão Compartilhado.

Além do beneficiário titular, todos os dependentes inscritos no Benefício AMS também precisam se recadastrar.

Os beneficiários que não se recadastrarem terão seu Benefício AMS suspenso.
Para auxiliar no recadastramento a companhia preparou um breve passo a passo.

Os beneficiários que encontrarem dificuldades no recadastramento poderão entrar em contato com a Petrobras para tirar dúvidas, no telefone 0800 287 2267 – opção 5 Recadastramento.

Programas de descontos dos grandes laboratórios farmacêuticos

Enquanto a PETROBRÁS não assegura a volta do melhor padrão de serviços (reembolso e delivery), amplitude de medicamentos e acesso, anteriores, do Benefício Farmácia (BF), bem como não cumpra a decisão do TCU de assumir a gestão do plano, os trabalhadores podem procurar minorar estes problemas aproveitando os programas de fidelidade e descontos que os laboratórios oferecem.

 

Os laboratórios farmacêuticos oferecem descontos em seus preços, especialmente, nos medicamentos de uso contínuo. Geralmente, basta se cadastrar nos sites dos laboratórios ou dos respectivos programas, bem como ter a receita médica para aproveitar os descontos. Para esclarecer sobre os procedimentos específicos de cadastramento em cada laboratório faça contato a partir do Serviço de Atendimento ao Consumidor (SAC).

 

Os cadastros envolvem informações para contato, o CRM do médico que lhe receitou o medicamento e o nome, especificação do medicamento. Se o medicamento estiver na lista de descontos, poderá ir direto na farmácia, com sua identificação e número/código de referência de sua inscrição para aproveitar o desconto.

 

Consulte alguns desses programas:

Aché – Cuidados pela Vida

Novartis – Vale Mais Saúde

Bayer – Conexão Saúde

Mantecorp – Vida Mais

AstraZeneca – Faz Bem

Pfizer – Mais Pfizer

 

Os problemas com as operadoras do Benefício Farmácia, bem como o que vem revelando a lavajato mostraram: a Terceirização e a ampla Contratação são o caminho da fraude

A nosso ver, a questão da gestão do Benefício Farmácia é mais um exemplo claro em que a terceirização expressa sua inadequação, pois a Petrobrás ficou como culpada onde é vítima, suas ações e intervenções de coerção, as multas que aplicou, não obrigaram a contratada a honrar o serviço e nem se conseguiu tomar as rédeas da gestão ou muito menos assegurar um padrão e qualidade de atendimento adequados às necessidades dos trabalhadores e às metas de controle, transparência, gestão financeira e econômica da própria Petrobrás. Isto é, pagou à contratada por um serviço que não recebeu e ainda esteve colhendo perdas de imagem perante a opinião pública e permanece perdendo perante seus próprios trabalhadores.

Sem o impedimento de gerir sobre situação sobrestada e em julgamento pelo TCU, esperamos as mais rápidas providências para que começassem o reembolso de todas as compras pendentes e, especialmente, conforme nota, assumissem diretamente a prestação do Benefício Farmácia com a estrutura do RH. Ao que nos parece, não foi e nem é a proposta que a empresa apresentou aos Sindicatos. Veja mais em: http://fnpetroleiros.org.br/nova-proposta-de-beneficio-farmacia-e-baseado-em-modelo-estrangeiro/

Microsoft Open Source Code of Conduct


This code of conduct outlines expectations for participation in Microsoft-managed open source communities, as well as steps for reporting unacceptable behavior. We are committed to providing a welcoming and inspiring community for all. People violating this code of conduct may be banned from the community.

Our open source communities strive to:

  • Be friendly and patient: Remember you might not be communicating in someone else’s primary spoken or programming language, and others may not have your level of understanding.
  • Be welcoming: Our communities welcome and support people of all backgrounds and identities. This includes, but is not limited to members of any race, ethnicity, culture, national origin, color, immigration status, social and economic class, educational level, sex, sexual orientation, gender identity and expression, age, size, family status, political belief, religion, and mental and physical ability.
  • Be respectful: We are a world-wide community of professionals, and we conduct ourselves professionally. Disagreement is no excuse for poor behavior and poor manners. Disrespectful and unacceptable behavior includes, but is not limited to:
    • Violent threats or language.
    • Discriminatory or derogatory jokes and language.
    • Posting sexually explicit or violent material.
    • Posting, or threatening to post, people’s personally identifying information (“doxing”).
    • Insults, especially those using discriminatory terms or slurs.
    • Behavior that could be perceived as sexual attention.
    • Advocating for or encouraging any of the above behaviors.
  • Understand disagreements: Disagreements, both social and technical, are useful learning opportunities. Seek to understand the other viewpoints and resolve differences constructively.
  • This code is not exhaustive or complete. It serves to capture our common understanding of a productive, collaborative environment. We expect the code to be followed in spirit as much as in the letter.

Scope

This code of conduct applies to all repos and communities for Microsoft-managed open source projects regardless of whether or not the repo explicitly calls out its use of this code. The code also applies in public spaces when an individual is representing a project or its community. Examples include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.

Note: Some Microsoft-managed communities have codes of conduct that pre-date this document and issue resolution process. While communities are not required to change their code, they are expected to use the resolution process outlined here. The review team will coordinate with the communities involved to address your concerns.

Reporting Code of Conduct Issues

We encourage all communities to resolve issues on their own whenever possible. This builds a broader and deeper understanding and ultimately a healthier interaction. In the event that an issue cannot be resolved locally, please feel free to report your concerns by contacting opencode@microsoft.com. Your report will be handled in accordance with the issue resolution process described in the Code of Conduct FAQ.

In your report please include:

  • Your contact information.
  • Names (real, usernames or pseudonyms) of any individuals involved. If there are additional witnesses, please include them as well.
  • Your account of what occurred, and if you believe the incident is ongoing. If there is a publicly available record (e.g. a mailing list archive or a public chat log), please include a link or attachment.
  • Any additional information that may be helpful.

All reports will be reviewed by a multi-person team and will result in a response that is deemed necessary and appropriate to the circumstances. Where additional perspectives are needed, the team may seek insight from others with relevant expertise or experience. The confidentiality of the person reporting the incident will be kept at all times. Involved parties are never part of the review team.

Anyone asked to stop unacceptable behavior is expected to comply immediately. If an individual engages in unacceptable behavior, the review team may take any action they deem appropriate, including a permanent ban from the community.

This code of conduct is based on the template established by the TODO Group and used by numerous other large communities (e.g., FacebookYahooTwitterGitHub) and the Scope section from the Contributor Covenant version 1.4.

Correios – preço de carta e telegrama via internet


Carta Nacional Via Internet

Vigência 09/05/2017 – Preços em R$

Sem Aviso de Recebimento Com Aviso de Recebimento
Carta Nacional Via Internet 6,80 11,80

Carta Comercial à Faturar

Vigência 09/05/2017 – Preços em R$

Gramas Básico Reg. Reg+AR Reg. + MP Reg+AR+MP
Até 20 1,80 6,10 10,40 12,00 16,30
Mais de 20 até   50 2,55 6,85 11,15 12,75 17,05
Mais de 50 até 100 3,50 7,80 12,10 13,70 18,00
Mais de 100 até 150 4,25 8,55 12,85 14,45 18,75
Mais de 150 até 200 5,05 9,35 13,65 15,25 19,55
Mais de 200 até 250 5,85 10,15 14,45 16,05 20,35
Mais de 250 até 300 6,65 10,95 15,25 16,85 21,15
Mais de 300 até 350 7,45 11,75 16,05 17,65 21,95
Mais de 350 até 400 8,20 12,50 16,80 18,40 22,70
Mais de 400 até 450 9,00 13,30 17,60 19,20 23,50
Mais de 450 até 500 9,80 14,10 18,40 20,00 24,30
OBS: Aos objetos com peso superior a 500g, serão aplicadas as mesmas condições de VALOR e prestação do SEDEX.

Carta Comercial à Vista

Vigência 09/05/2017 – Preços em R$

Gramas Básico Reg Reg+AR Reg. + MP Reg+AR+MP
Até 20 1,80 6,80 11,80 12,70 17,70
Mais de 20 até   50 2,55 7,55 12,55 13,45 18,45
Mais de 50 até 100 3,50 8,50 13,50 14,40 19,40
Mais de 100 até 150 4,25 9,25 14,25 15,15 20,15
Mais de 150 até 200 5,05 10,05 15,05 15,95 20,95
Mais de 200 até 250 5,85 10,85 15,85 16,75 21,75
Mais de 250 até 300 6,65 11,65 16,65 17,55 22,55
Mais de 300 até 350 7,45 12,45 17,45 18,35 23,35
Mais de 350 até 400 8,20 13,20 18,20 19,10 24,10
Mais de 400 até 450 9,00 14,00 19,00 19,90 24,90
Mais de 450 até 500 9,80 14,80 19,80 20,70 25,70
OBS: Aos objetos com peso superior a 500g, serão aplicadas as mesmas condições de VALOR e prestação do SEDEX.

Carta não Comercial e Cartão Postal à Vista

Vigência 09/05/2017 – Preços em R$

Gramas Básico Reg. Reg+AR Reg. + MP Reg+AR+MP
Até 20 1,25 6,25 11,25 12,15 17,15
Mais de 20 até   50 1,95 6,95 11,95 12,85 17,85
Mais de 50 até 100 2,60 7,60 12,60 13,50 18,50
Mais de 100 até 150 3,30 8,30 13,30 14,20 19,20
Mais de 150 até 200 4,00 9,00 14,00 14,90 19,90
Mais de 200 até 250 4,75 9,75 14,75 15,65 20,65
Mais de 250 até 300 5,45 10,45 15,45 16,35 21,35
Mais de 300 até 350 6,10 11,10 16,10 17,00 22,00
Mais de 350 até 400 6,80 11,80 16,80 17,70 22,70
Mais de 400 até 450 7,50 12,50 17,50 18,40 23,40
Mais de 450 até 500 8,20 13,20 18,20 19,10 24,10

TypeScript is a language for application-scale JavaScript


TypeScript is a language for application-scale JavaScript. TypeScript adds optional types, classes, and modules to JavaScript. TypeScript supports tools for large-scale JavaScript applications for any browser, for any host, on any OS. TypeScript compiles to readable, standards-based JavaScript. Try it out at the playground, and stay up to date via our blog and Twitter account.

Installing

For the latest stable version:

npm install -g typescript

For our nightly builds:

npm install -g typescript@next

Contribute

There are many ways to contribute to TypeScript.

This project has adopted the Microsoft Open Source Code of Conduct. For more information see the Code of Conduct FAQ or contact opencode@microsoft.comwith any additional questions or comments.

Documentation

Building

In order to build the TypeScript compiler, ensure that you have Git and Node.jsinstalled.

Clone a copy of the repo:

git clone https://github.com/Microsoft/TypeScript.git

Change to the TypeScript directory:

cd TypeScript

Install Gulp tools and dev dependencies:

npm install -g gulp
npm install

Use one of the following to build and test:

gulp local            # Build the compiler into built/local 
gulp clean            # Delete the built compiler 
gulp LKG              # Replace the last known good with the built one.
                      # Bootstrapping step to be executed when the built compiler reaches a stable state.
gulp tests            # Build the test infrastructure using the built compiler. 
gulp runtests         # Run tests using the built compiler and test infrastructure. 
                      # You can override the host or specify a test for this command. 
                      # Use host=<hostName> or tests=<testPath>. 
gulp runtests-browser # Runs the tests using the built run.js file. Syntax is gulp runtests. Optional
                        parameters 'host=', 'tests=[regex], reporter=[list|spec|json|<more>]'.
gulp baseline-accept  # This replaces the baseline test results with the results obtained from gulp runtests.
gulp lint             # Runs tslint on the TypeScript source.
gulp help             # List the above commands. 

Usage

node built/local/tsc.js hello.ts

TypeScript


From Wikipedia, the free encyclopedia
Adicionar ao Google AgendaTypeScript
TypeScript Logo.png
Paradigm Multi-paradigmscriptingobject-orientedstructuredimperativefunctionalgeneric
Designed by Microsoft
Developer Microsoft
First appeared 1 October 2012; 4 years ago[1]
Stable release
2.3 / 27 April 2017; 2 months ago[2]
License Apache License 2.0
Filename extensions .ts
Website www.typescriptlang.org
Influenced by
JavaScriptJavaC#
Influenced
AtScript

TypeScript is a free and open-source programming language developed and maintained by Microsoft. It is a strict syntactical superset of JavaScript, and adds optional static typing to the language. Anders Hejlsberg, lead architect of C# and creator of Delphi and Turbo Pascal, has worked on the development of TypeScript.[3][4][5][6] TypeScript may be used to develop JavaScript applications for client-side or server-side (Node.js) execution.

TypeScript is designed for development of large applications and transcompiles to JavaScript.[7] As TypeScript is a superset of JavaScript, existing JavaScript programs are also valid TypeScript programs.

TypeScript supports definition files that can contain type information of existing JavaScript libraries, much like C/C++ header files can describe the structure of existing object files. This enables other programs to use the values defined in the files as if they were statically typed TypeScript entities. There are third-party header files for popular libraries like jQueryMongoDB, and D3.js. TypeScript headers for the Node.js basic modules are also available, allowing development of Node.js programs within TypeScript.[8]

The TypeScript compiler is itself written in TypeScript and transcompiled to JavaScript. It is licensed under the Apache 2 License.

TypeScript is included as a first-class programming language in Microsoft Visual Studio 2013 Update 2 and later, beside C# and other Microsoft languages.[9] An official extension allows Visual Studio 2012 to support TypeScript as well.[10]

History[edit]

TypeScript was first made public in October 2012 (at version 0.8), after two years of internal development at Microsoft.[11][12] Soon after the announcement, Miguel de Icaza praised the language itself, but criticized the lack of mature IDE support apart from Microsoft Visual Studio, which is not available on Linux and OS X.[13][14] As of 2013 there is support in other IDEs, particularly in Eclipse, via a plug-in contributed by Palantir Technologies.[15][16] Various text editors, including EmacsVimSublimeWebstorm and Atom[17] also support TypeScript.[18]

TypeScript 0.9, released in 2013, added support for generics.[19] TypeScript 1.0 was released at Microsoft’s Build developer conference in 2014.[20] Visual Studio 2013 Update 2 provides built-in support for TypeScript.[21]

In July 2014, the development team announced a new TypeScript compiler, claiming 5× performance gains. Simultaneously, the source code, which was initially hosted on CodePlex, was moved to GitHub.[22]

On 22 September 2016, TypeScript 2.0 was released; it introduced several features, including the ability for programmers to optionally prevent variables from being assigned null values.[23]

Language design[edit]

TypeScript originated from the perceived shortcomings of JavaScript for the development of large-scale applications both at Microsoft and among their external customers.[24] Challenges with dealing with complex JavaScript code led to demand for custom tooling to ease developing of components in the language.[25]

TypeScript developers sought a solution that would not break compatibility with the standard and its cross-platform support. Knowing that the current ECMAScript standard proposal promised future support for class-based programming, TypeScript was based on that proposal. That led to a JavaScript compiler with a set of syntactical language extensions, a superset based on the proposal, that transforms the extensions into regular JavaScript. In this sense TypeScript was a preview of what to expect of ECMAScript 2015. A unique aspect not in the proposal, but added to TypeScript, is optional static typing[26] that enables static language analysis, which facilitates tooling and IDE support.

ECMAScript 2015 support[edit]

TypeScript adds support for features such as classes, modules and an arrow function syntax as proposed in the ECMAScript 2015 standard.

Language features[edit]

TypeScript is a language extension that adds features to ECMAScript 5. Additional features include:

The following features are backported from ECMAScript 2015:

Syntactically, TypeScript is very similar to JScript .NET, another Microsoft implementation of the ECMA-262 language standard that added support for static typing and classical object-oriented language features such as classes, inheritance, interfaces, and namespaces.

Compatibility with JavaScript[edit]

TypeScript is a strict superset of ECMAScript 2015, which is a superset of ECMAScript 5, commonly referred to as JavaScript.[28] As such, a JavaScript program is also a valid TypeScript program, and a TypeScript program can seamlessly consume JavaScript. By default the compiler targets ECMAScript 5, the current prevailing standard. But is also able to generate constructs used in ECMAScript 3 or 2015.

With TypeScript, it is possible to use existing JavaScript code, incorporate popular JavaScript libraries, and call TypeScript-generated code from other JavaScript.[29] Type declarations for these libraries are provided with the source code.

Type annotations[edit]

TypeScript provides static typing through type annotations to enable type checking at compile time. This is optional and can be ignored to use the regular dynamic typing of JavaScript.

function add(left: number, right: number): number {
	return left + right;
}

The annotations for the primitive types are numberboolean and string. Weakly- or dynamically-typed structures are of type any.

Type annotations can be exported to a separate declarations file to make type information available for TypeScript scripts using types already compiled into JavaScript. Annotations can be declared for an existing JavaScript library, as has been done for Node.js and jQuery.

The TypeScript compiler makes use of type inference to infer types when types are not given. For example, the add method in the code above would be inferred as returning a number even if no return type annotation had been provided. This is based on the static types of left and right being numbers, and the compiler’s knowledge that the result of adding two numbers is always a number. However, explicitly declaring the return type allows the compiler to verify correctness.

If no type can be inferred because of lack of declarations, then it defaults to the dynamic any type. A value of the any type supports the same operations as a value in JavaScript and minimal static type checking is performed for operations on any values.[30]

Declaration files[edit]

When a TypeScript script gets compiled there is an option to generate a declaration file (with the extension .d.ts) that functions as an interfaceto the components in the compiled JavaScript. In the process the compiler strips away all function and method bodies and preserves only the signatures of the types that are exported. The resulting declaration file can then be used to describe the exported virtual TypeScript types of a JavaScript library or module when a third-party developer consumes it from TypeScript.

The concept of declaration files is analogous to the concept of header file found in C/C++.

declare module arithmetics {
    add(left: number, right: number): number;
    subtract(left: number, right: number): number;
    multiply(left: number, right: number): number;
    divide(left: number, right: number): number;
}

Type declaration files can be written by hand for existing JavaScript libraries, as has been done for jQuery and Node.js.

Large collections of declaration files for popular JavaScript libraries are hosted on GitHub in DefinitelyTyped and the Typings Registry. A command-line utility called typings is provided to help search

Classes[edit]

TypeScript supports ECMAScript 2015 classes that integrate the optional type annotations support.

class Person {
    private name: string;
    private age: number;
    private salary: number;

    constructor(name: string, age: number, salary: number) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    toString(): string {
        return `${this.name} (${this.age}) (${this.salary})`; // As of version 1.4
    }
}

Generics[edit]

TypeScript supports generic programming.[31]

Modules and namespaces[edit]

TypeScript distinguishes between modules and namespaces. Both features in TypeScript support encapsulation of classes, interfaces, functions and variables into containers. Namespaces (formerly internal modules) utilize immediately-invoked function expression of JavaScript to encapsulate code, whereas modules (formerly external modules) leverage JavaScript library patterns to do so (AMD or CommonJS).[32]

Development tools[edit]

Compiler[edit]

The TypeScript compiler, named tsc, is written in TypeScript that can be compiled into regular JavaScript that can be executed in any JavaScript engine in any host, such as a browser. The compiler package comes bundled with a script host that can execute the compiler. It is also available as a Node.js package that uses Node.js as a host.

There is also an alpha version of a client-side compiler in JavaScript, which executes TypeScript code on the fly, upon page load.[33]

The current version of the compiler supports ECMAScript 5 by default. An option is allowed to target ECMAScript 2015 to make use of language features exclusive to that version (e.g. generators). Classes, despite being part of the ECMAScript 2015 standard, are available in both modes.

IDE and editor support[edit]

Integration with build automation tools[edit]

Using plug-ins, TypeScript can be integrated with build automation tools, including Grunt (grunt-ts[37]), Apache Maven (TypeScript Maven Plugin[38]), Gulp (gulp-typescript[39]) and Gradle (TypeScript Gradle Plugin[40]).

See also[edit]

References[edit]

  1. Jump up^ “TypeScript”CodePlex. Retrieved 26 April 2015.
  2. Jump up^ “TypeScript 2.3”TypeScript. Retrieved 11 May 2017.
  3. Jump up^ Foley, Mary Jo (1 October 2012). “Microsoft takes the wraps off TypeScript, a superset of JavaScript”ZDNetCBS Interactive. Retrieved 26 April2015.
  4. Jump up^ Somasegar, S. (1 October 2012). “Somasegar’s blog”Somasegar’s blog. Microsoft. Retrieved 26 April 2015.
  5. Jump up^ Baxter-Reynolds, Matt (1 October 2012). “Microsoft TypeScript: Can the father of C# save us from the tyranny of JavaScript?”ZDNet. Retrieved 26 April 2015.
  6. Jump up^ Jackson, Joab (1 October 2012). “Microsoft Augments Javascript for Large-scale Development”CIOIDG Enterprise. Retrieved 26 April 2015.
  7. Jump up^ Bright, Peter (3 October 2012). “Microsoft TypeScript: the JavaScript we need, or a solution looking for a problem?”Ars TechnicaCondé Nast. Retrieved 26 April 2015.
  8. Jump up^ “borisyankov/DefinitelyTyped”GitHub. Retrieved 26 April 2015.
  9. Jump up^ TypeScript Homepage“Visual Studio includes TypeScript in the box, starting with Visual Studio 2013 Update 2”
  10. Jump up^ TypeScript 1.0 Tools for Visual Studio 2012
  11. Jump up^ “Microsoft augments JavaScript for large-scale development”InfoWorldIDG. 1 October 2012. Retrieved 26 April 2015.
  12. Jump up^ Turner, Jonathan (2 April 2014). “Announcing TypeScript 1.0”TypeScript Language team blog. Microsoft. Retrieved 26 April 2015.
  13. Jump up^ Miguel de Icaza (2012-10-01). “TypeScript: First Impressions”. Retrieved 2012-10-12But TypeScript only delivers half of the value in using a strongly typed language to Unix developers: strong typing. Intellisense, code completion and refactoring are tools that are only available to Visual Studio Professional users on Windows. There is no Eclipse, MonoDevelop or Emacs support for any of the language features
  14. Jump up^ “Microsoft TypeScript: Can the father of C# save us from the tyranny of JavaScript?”ZDNet. 2012-10-01. Retrieved 2012-10-12And I think this is a pretty big misstep. If you’re building web apps that run on anything other than Windows, you’re likely using a Mac and most likely not using Visual Studio. You need the Visual Studio plug-in to get the IntelliSense. All you get without Visual Studio is the strong-typing. You don’t get the productivity benefits you get from IntelliSense..
  15. Jump up^ “TypeScript-Unterstützung für Eclipse”heise Developer. 6 August 2013. Retrieved 26 April 2015.
  16. Jump up^ “TypeScript”Eclipse Marketplace. Eclipse Foundation. Retrieved 26 April 2015.
  17. Jump up^ “TypeStrong: The only TypeScript package you will ever need”. Retrieved 21 July 2016.
  18. Jump up^ Hillar, Gastón (14 May 2013). “Working with TypeScript in Visual Studio 2012”Dr. Dobb’s Journal. Retrieved 26 April 2015.
  19. Jump up^ “TypeScript 0.9 arrives with new compiler, support for generics”The Register. 18 June 2013. Retrieved 26 April 2015.
  20. Jump up^ Hejlsberg, Anders (2 April 2014). “TypeScript”Channel 9. Microsoft. Retrieved 26 April 2015.
  21. Jump up^ Jackson, Joab (25 February 2014). “Microsoft TypeScript graduates to Visual Studio”PC WorldIDG. Retrieved 26 April 2015.
  22. Jump up^ Turner, Jonathan (21 July 2014). “New Compiler and Moving to GitHub”TypeScript Language team blog. Microsoft. Retrieved 26 April 2015.
  23. Jump up^ Bright, Peter (22 September 2016). “TypeScript, Microsoft’s JavaScript for big applications, reaches version 2.0”Ars TechnicaCondé Nast. Retrieved 22 September 2016.
  24. Jump up^ Anders Hejlsberg (2012-10-05). “What is TypeScript and why with Anders Hejlsberg”. http://www.hanselminutes.com. Retrieved 2014-01-15.
  25. Jump up^ S. Somasegar (2012-10-01). “TypeScript: JavaScript Development at Application Scale”. msdn.com. Retrieved 2013-11-27.
  26. Jump up^ optional static typing is called gradual typing
  27. Jump up^ Klint Finley (2012-10-01). “Microsoft Previews New JavaScript-Like Programming Language TypeScript”. TechCrunch. Retrieved 2013-11-27.
  28. Jump up^ “Angular 2”angular.io. Retrieved 2016-05-04.
  29. Jump up^ “Welcome to TypeScript”typescriptlang.orgMicrosoft. Retrieved 26 April 2015.
  30. Jump up^ TypeScript Language Specification p.24
  31. Jump up^ Turner, Jonathan (18 June 2013). “Announcing TypeScript 0.9”TypeScript Language team blogMicrosoft.
  32. Jump up^ Sönke Sothmann (2014-01-31). “An introduction to TypeScript’s module system”. blog.oio.de. Retrieved 2014-02-21.
  33. Jump up^ “niutech/typescript-compile”GitHub. Retrieved 26 April 2015.
  34. Jump up^ Olivier Bloch (2012-10-01). “Sublime Text, Vi, Emacs: TypeScript enabled!”Microsoft. Retrieved 2012-10-28.
  35. Jump up^ “TypeScript support in WebStorm 6”. JetBrains.
  36. Jump up^ “TypeScript support in ReSharper 8.1”. JetBrains.
  37. Jump up^ “TypeStrong/grunt-ts”GitHub. Retrieved 26 April 2015.
  38. Jump up^ “ppedregal/typescript-maven-plugin”GitHub. Retrieved 26 April 2015.
  39. Jump up^ “ivogabe/gulp-typescript”GitHub. Retrieved 14 July 2017.
  40. Jump up^ “sothmann/typescript-gradle-plugin”GitHub. Retrieved 26 April 2015.

External links[edit]

ES6, ECMAScript 6 ou ES2015, é simplesmente a mais nova versão do JavaScript


O que é

ES6, ECMAScript 6 ou ES2015, é simplesmente a mais nova versão do JavaScript.

Na verdade, o nome mais usado atualmente é ES2015. A ideia do comitê responsável (conhecido como TC39) pelas atualizações da linguagem é justamente fazer um release anual. Então nesse ano teremos o ES2016 (ou ES7). E assim sucessivamente.

Porém nesse post usarei o nome ES6 porque é o mais conhecido pela comunidade.

ECMAScript x JavaScript x ES

Uma dúvida bem comum é o porquê dessa mudança do nome.
Na verdade não houve nenhuma mudança: JavaScript é como nós chamamos a linguagem, só que esse nome é um trademark da Oracle (que veio após a compra da Sun). O nome oficial da linguagem é ECMAScript. E ES é simplesmente uma abreviação do mesmo.

Objetivos do ES6

O TC39 focou em alguns objetivos no desenvolvimento do ES6:

  • Ser uma linguagem melhor para construir aplicações complexas
  • Resolver problemas antigos do JavaScript
  • Facilidade no desenvolvimento de libraries

Esses objetivos ficarão mais claros quando olharmos na prática as features do ES6.


Como usar

No momento que esse post está sendo escrito, a grande maioria dos browsersainda não dão suporte ao ES6, então o que podemos fazer para contornar essa limitação?

Podemos usar um transpiler como o Babel.

O Babel transforma o seu código de ES6 para ES5 (versão que a maioria dos browsers dá suporte hoje).

Transpilando ES6 para ES5

Vamos começar um projeto simples para demonstrar o uso do Babel:

mkdir es6
cd es6
touch index.js .babelrc

Agora vamos iniciar o npm com:

npm init

Aceite todas as opções e agora entre com o comando:

npm --save-dev babel-cli babel-preset-es2015

Vamos agora abrir o index.js para escrever código em ES6:

O Babel por si só não sabe como transpilar o código. Por isso ele precisa de alguns plugins.

Vamos alterar o .babelrc para informar ao Babel qual plugin estamos utilizando para fazer a conversão de que precisamos. Como iremos usar o ES2015, nosso .babelrc deverá ficar assim:

{
  'presets': ['es2015']
}

Basta então rodarmos o comando abaixo para que o transpile seja concluído.

babel index.js -o script.js

O comando pode ser traduzido da seguinte forma: Babel, pegue o arquivo index.js e gere um output com o nome script.js.

Se abrirmos o novo arquivo (script.js) que foi gerado, ele ficará assim:

Portanto, geramos um arquivo ES5 a partir de um ES6. Obviamente o que foi feito acima não é recomendado para aplicações reais, mas apenas uma forma rápida de se demonstrar a utilidade de transpilers.

Numa aplicação real uma recomendação seria utilizar o Webpack com o Babel. Mas isso por si só, é grande o bastante para caber em um post futuro. Inclusive já estou trabalhando nesse post, então se você quiser ser informado de quando ele estiver pronto, assine a nossa newsletter!


Quais as novidades do ES6

Agora que já sabemos o que é o ES6 e como podemos usá-lo hoje mesmo com o Babel, podemos então ver as features que ele adicionará na linguagem e seus benefícios.

Declaração de variáveis

Para entender os benefícios da nova forma de se declarar variáveis em ES6 com let e const, precisamos antes entender o conceito de hoisting.

Eu expliquei esse conceito e mais outros detalhes que todo desenvolvedor JavaScript deveria saber. Se você ainda não domina o hoisting sugiro ler o post antes, e somente depois retornar aqui.

var x let
A diferença principal entre o var e o let é que enquanto o primeiro tem escopo de função, o segundo possui escopo de bloco:

Um outro exemplo de coisas inesperadas que acontecem quando usamos o var:

Em resumo, let conserta o antigo problema causado pelo hoisting fazendo com que a declaração de variáveis funcione da forma esperada pela maioria dos desenvolvedores.

let x const
const funciona de forma semelhante. A única diferença é que as variáveis criadas não podem ser reatribuídas:

É comum achar que const deixa a variável imutável, assim como algumas libscomo ImmutableJS. Isso não é verdade. As propriedades de um objeto, por exemplo, podem ser alteradas:

A minha opinião é de que devemos declarar todas as variáveis com const e quando a variável precisa ser reatribuída, e somente nesse caso, devemos usar o let. Não devemos usar o var (praticamente) nunca.

Parâmetro de funções

Algumas pequenas alterações foram adicionadas em relação a parametrização de funções. Apesar dessas mudanças serem pequenas, elas trazem enormes benefícios.

default parameters
Os parâmetros de funções tem undefined como valor default. Porém, em alguns casos, pode ser necessário utilizar um outro valor. Com a versão atual do JavaScript (ES5) nós já podemos fazer isso dessa forma:

O ES6 introduziu uma nova forma, bem mais simples, de se fazer isso. Basta adicionar o valor default na definição do parâmetro desejado:

Ou então, com apenas uma linha:

rest parameters
Na versão atual do JavaScript podemos utilizar o objeto arguments para pegar todos os parâmetros de uma função:

arguments porém, apresenta alguns problemas:

  1. O objeto parece com um array, mas não é exatamente um
  2. Todos os parâmetros da função são automaticamente atribuídos ao arguments. Não temos uma forma clara de diferenciar os parâmetros.

Com esses problemas em mente, os Rest Parameters foram adicionados no ES6. O mesmo exemplo da soma poderia ser reescrito dessa forma:

Ou dessa forma mais funcional:

Se o exemplo ficou confuso, uma dica interessante é ler meu último post sobre Programação Funcional com JavaScript. É provável que deixe o exemplo mais claro.

Agora vamos imaginar o mesmo problema da soma, só que o primeiro parâmetro seria de onde a soma começaria e os próximos parâmetros seriam os números a serem somados:

Ou então:

Programação Funcional

As minhas alterações preferidas do ES6 estão nessa categoria. Nos próximos exemplos tentarei mostrar o porquê.

arrow functions
Os arrow functions são um excelente syntax sugar na criação de funções. Uma função que seria escrita dessa forma em ES5:

Pode ser escrita dessa forma em ES6 com o uso das arrow functions:

Dessa forma já conseguimos ver uma maior expressividade e um menor número total de caracteres. Mas podemos melhorá-la ainda mais:

Com funções de apenas uma linha, podemos simplesmente omitir o return e as chaves.

Mas o verdadeiro benefício das arrows functions não está na expressividade, ele se encontra na resolução de um antigo problema da linguagem: o this.

No exemplo abaixo em ES5, podemos observar o this sendo utilizado de forma errada:

Uma das formas mais comuns de resolver esse problema, como demonstrei nesse post, é usando o bind() ou então com self = this.

Com as arrow functions isso não é necessário. O this funcionará exatamente da forma esperada:

destructuring
Uma nova forma de declarar variáveis extraindo valores de objetos e arraysé através do destructuring. Ela funciona dessa forma:

E com rest parameters:

Com objetos ela funciona desse jeito:

Provavelmente, o uso mais comum vai ser no import de libs. Vamos ter o poder de transformar isso:

Nisso:

Você deve estar se perguntando sobre a minha motivação de ter colocado o destructuring na categoria de Programação Funcional.
A resposta é simples: destructuring é muito semelhante ao pattern matching, que é uma das bases das linguagens funcionais.


Orientação a Objetos

Vamos falar agora sobre a feature mais polêmica do ES6: classes.

Eu pessoalmente não gosto dessa adição. Posso estar errado em relação a isso, e só o tempo vai confirmar ou não, mas acredito que os grandes problemas da linguagem foram causados por tentar se parecer com Java. Adicionar classes é algo que segue exatamente essa linha.

Mas independente da minha opinião elas foram adicionadas e vão trazer mudanças, então precisamos estudá-las.

Classes

Classes nos dão uma sintaxe amigável que definem o estado e o comportamento de objetos que representam as abstrações que usamos diariamente.

constructor
Por exemplo, se necessitarmos de uma abstração para animais em que cada animal possui um nome, poderíamos implementar dessa forma:

O método constructor tem como tarefa fazer a inicialização da instância. Ele é chamado automaticamente na criação da mesma e garante que ela esteja em um estado válido.

getters/setters
Como getters setters são muito comuns na utilização de classes, o ES6 veio com um syntax sugar para lidar com os mesmos. Então podemos reescrever o exemplo anterior dessa forma melhorada:

Lembrando que a principal função dos getters/setters é proteger os dados internos das instâncias de um objeto.

Se você está se perguntando o porquê do underscore antes da propriedade name, a resposta simples é de que isso é uma convenção que indica que essa variável deve ser mantida privada.

herança
Vamos pensar em um caso em que além de um nome, um Animal também terá um novo comportamento: emitir um som.

Podemos utilizar o conceito de herança com o extends e implementar dessa forma:

Para os leitores que querem ir mais a fundo em relação as classes em ES6, sugiro esses dois posts:


Módulos

Um dos grandes problemas do JavaScript era não ter um sistema built-in de módulos assim como a maioria das linguagens possui.

Dessa ausência surgiram algumas possíveis soluções como CommonJS e AMD. Se você quiser saber mais sobre esses dois últimos, eu sugiro essathread no Stack Overflow.

Nesse post falarei apenas sobre o novo sistema de módulos do ES6.

ES6 Modules

A maioria dos desenvolvedores que já trabalhou em projetos grandes sabe a importância dos módulos: organizar o sistema, aumentar o reuso e diminuir a complexidade de cada pequeno trecho do seu code base.

export/import
Exportar módulos é bem simples. Após criarmos uma função podemos simplesmente adicionar a palavra export antes da definição da mesma:

E para importar esse módulo em outro arquivo também é simples:

Com múltiplas funções é bem semelhante:

E para importar:

Podemos também importar o módulo completo:

classes
Para importar e exportar classes também não há muitas mudanças, basta criar uma classe com o export na frente:

Agora podemos importá-la assim:

default
É comum termos a necessidade de exportar apenas uma função/classe por arquivo. Nesse cenário podemos utilizar a exportação default:

Uma das vantagens é que o cliente (quem faz o import) é que vai setar o nome do módulo como bem quiser:


Caso Real

Para ver um caso real de todas as features citadas acima (exceto classes) é só dar uma lida no projeto open source que estou trabalhando recentemente, o pareto.js.

Ele é semelhante ao underscore/lodash só que tem somente os poucos métodos que nós realmente precisamos no dia-a-dia, foi desenvolvido com as tecnologias mais novas: ES6, Babel e Webpack e além disso encoraja o uso de functional programming.